chore: remove unused promise

Author: LittleSound

app/components/Scan.vue

@@ -178,7 +178,7 @@ async function scanFrame() {
         return
       if (picked.value.every(i => !!i)) {
         try {
-          const merged = await merge(picked.value as SliceData[])
+          const merged = merge(picked.value as SliceData[])
           dataUrl.value = URL.createObjectURL(new Blob([merged], { type: 'application/octet-stream' }))
         }
         catch (e) {

app/pages/index.vue

@@ -30,7 +30,7 @@ async function onFileChange(file?: File) {
   readPhase.value = ReadPhase.Reading
   const content = await file.arrayBuffer()
   readPhase.value = ReadPhase.Chunking
-  const chunks = await slice(content, 900)
+  const chunks = slice(content, 900)
   readPhase.value = ReadPhase.Ready
   data.value = chunks.map(i => JSON.stringify(i))
 }

test/slicing.test.ts

@@ -7,23 +7,23 @@ import { merge, slice } from '../utils/slicing'
 it('slice string', async () => {
   const input = await fs.readFile('test/mock-data.json', 'utf-8')
 
-  const chunks = await slice(input, 64)
+  const chunks = slice(input, 64)
   expect(chunks.length)
     .toMatchInlineSnapshot(`15`)
 
-  const recovered = await merge(chunks)
+  const recovered = merge(chunks)
   expect(input).toBe(recovered)
 })
 
 it('slice binary', async () => {
   const input = (await fs.readFile('test/mock-data.json', null)).buffer
   const inputBytes = new Uint8Array(input).length
 
-  const chunks = await slice(input, 64)
+  const chunks = slice(input, 64)
   expect(chunks.length)
     .toMatchInlineSnapshot(`24`)
 
-  const recovered = await merge(chunks)
+  const recovered = merge(chunks)
   expect(new Uint8Array(recovered as any).length).toBe(inputBytes)
   expect(String(input)).toBe(String(recovered))
 })
@@ -34,11 +34,11 @@ it('slice image binary', async () => {
   const input = (await fs.readFile(join('test', 'SampleJPGImage_100kbmb.jpg'), null)).buffer
   const inputBytes = new Uint8Array(input).length
 
-  const chunks = await slice(input, 64)
+  const chunks = slice(input, 64)
   expect(chunks.length)
     .toMatchInlineSnapshot(`2554`)
 
-  const recovered = await merge(chunks)
+  const recovered = merge(chunks)
   expect(new Uint8Array(recovered as any).length).toBe(inputBytes)
   expect(String(input)).toBe(String(recovered))
 })

utils/slicing.ts

@@ -10,19 +10,19 @@ export type SliceData = [
   chunk: string,
 ]
 
-async function arrayBufferToBase64(buffer: ArrayBuffer): Promise<string> {
+function arrayBufferToBase64(buffer: ArrayBuffer): string {
   return fromUint8Array(new Uint8Array(buffer))
 }
 
-async function base64ToArrayBuffer(str: string): Promise<ArrayBuffer> {
+function base64ToArrayBuffer(str: string): ArrayBuffer {
   return toUint8Array(str).buffer
 }
 
-export async function slice(input: string | ArrayBuffer, chunkSize = 256): Promise<SliceData[]> {
+export function slice(input: string | ArrayBuffer, chunkSize = 256): SliceData[] {
   const hash = getHash(input)
   const isBinary = typeof input !== 'string'
   const processed = typeof input !== 'string'
-    ? await arrayBufferToBase64(input)
+    ? arrayBufferToBase64(input)
     : input.toString()
   const compressed = compressToBase64(processed)
 
@@ -39,14 +39,14 @@ export async function slice(input: string | ArrayBuffer, chunkSize = 256): Promi
   )
 }
 
-export async function merge(slices: SliceData[]): Promise<string | ArrayBuffer> {
+export function merge(slices: SliceData[]): string | ArrayBuffer {
   const merged = slices.map(i => i[4]).join('')
   const decompressed = decompressFromBase64(merged)
   const targetHash = slices[0]![0]
   const isBinary = slices[0]![3] === 0
 
   const data: string | ArrayBuffer = isBinary
-    ? await base64ToArrayBuffer(decompressed)
+    ? base64ToArrayBuffer(decompressed)
     : decompressed
 
   const hash = getHash(data)