refactor: make console log less verbose when not needed

.env

@@ -0,0 +1,4 @@
+# Example environment file for vite to use.
+# For more information, see: https://vitejs.dev/guide/env-and-mode.html
+
+ENABLE_PERF_LOG=0

src/decrypt-worker/util/DecryptError.ts

@@ -0,0 +1 @@
+export class UnsupportedSourceFile extends Error {}

src/decrypt-worker/util/transformBlob.ts

@@ -1,5 +1,6 @@
 import { Transformer, Parakeet, TransformResult, fetchParakeet } from '@jixun/libparakeet';
 import { toArrayBuffer } from './buffer';
+import { UnsupportedSourceFile } from './DecryptError';
 
 export async function transformBlob(
   blob: Blob | ArrayBuffer,
@@ -21,7 +22,9 @@ export async function transformBlob(
     cleanup.push(() => writer.delete());
 
     const result = transformer.Transform(writer, reader);
-    if (result !== TransformResult.OK) {
+    if (result === TransformResult.ERROR_INVALID_FORMAT) {
+      throw new UnsupportedSourceFile(`transformer<${transformer.Name}> does not recognize this file`);
+    } else if (result !== TransformResult.OK) {
       throw new Error(`transformer<${transformer.Name}> failed with error: ${TransformResult[result]} (${result})`);
     }
 

src/decrypt-worker/worker/handler/decrypt.ts

@@ -1,8 +1,9 @@
 import { Parakeet, fetchParakeet } from '@jixun/libparakeet';
-import { timedLogger } from '~/util/timedLogger';
+import { timedLogger, withGroupedLogs as withTimeGroupedLogs } from '~/util/logUtils';
 import { allCryptoFactories } from '../../crypto/CryptoFactory';
 import { toArrayBuffer, toBlob } from '~/decrypt-worker/util/buffer';
 import { CryptoBase, CryptoFactory } from '~/decrypt-worker/crypto/CryptoBase';
+import { UnsupportedSourceFile } from '~/decrypt-worker/util/DecryptError';
 
 // Use first 4MiB of the file to perform check.
 const TEST_FILE_HEADER_LEN = 4 * 1024 * 1024;
@@ -29,8 +30,11 @@ class DecryptCommandHandler {
         }
         return result;
       } catch (error) {
-        console.error('decrypt failed: ', error);
+        if (error instanceof UnsupportedSourceFile) {
-        continue;
+          console.debug('WARN: decryptor does not recognize source file, wrong crypto?', error);
+        } else {
+          console.error('decrypt failed with unknown error: ', error);
+        }
       }
     }
 
@@ -83,10 +87,7 @@ class DecryptCommandHandler {
 
 export const workerDecryptHandler = async ({ id, blobURI }: { id: string; blobURI: string }) => {
   const label = `decrypt( ${id} )`;
-  console.group(label);
+  return withTimeGroupedLogs(label, async () => {
-
-  try {
-    return await timedLogger(`${label}/total`, async () => {
     const parakeet = await timedLogger(`${label}/init`, fetchParakeet);
     const blob = await timedLogger(`${label}/fetch-src`, async () => fetch(blobURI).then((r) => r.blob()));
     const buffer = await timedLogger(`${label}/read-src`, async () => blob.arrayBuffer());
@@ -94,7 +95,4 @@ export const workerDecryptHandler = async ({ id, blobURI }: { id: string; blobUR
     const handler = new DecryptCommandHandler(id, parakeet, blob, buffer);
     return handler.decrypt(allCryptoFactories);
   });
-  } finally {
-    (console.groupEnd as (label: string) => void)(label);
-  }
 };

src/util/fnWrapper.ts

@@ -2,21 +2,19 @@ function isPromise<T = unknown>(p: unknown): p is Promise<T> {
   return !!p && typeof p === 'object' && 'then' in p && 'catch' in p && 'finally' in p;
 }
 
-export function timedLogger<R = unknown>(label: string, fn: () => R): R {
+export function wrapFunctionCall<R = unknown>(pre: () => void, post: () => void, fn: () => R): R {
-  console.time(label);
+  pre();
 
   try {
     const result = fn();
 
     if (isPromise(result)) {
-      result.finally(() => {
+      result.finally(post);
-        console.timeEnd(label);
-      });
     }
 
     return result;
   } catch (e) {
-    console.timeEnd(label);
+    post();
     throw e;
   }
 }

src/util/logUtils.ts

@@ -0,0 +1,25 @@
+import { wrapFunctionCall } from './fnWrapper';
+
+export function timedLogger<R = unknown>(label: string, fn: () => R): R {
+  if (import.meta.env.ENABLE_PERF_LOG !== '1') {
+    return fn();
+  } else {
+    return wrapFunctionCall(
+      () => console.time(label),
+      () => console.timeEnd(label),
+      fn
+    );
+  }
+}
+
+export function withGroupedLogs<R = unknown>(label: string, fn: () => R): R {
+  if (import.meta.env.ENABLE_PERF_LOG !== '1') {
+    return fn();
+  } else {
+    return wrapFunctionCall(
+      () => console.group(label),
+      () => (console.groupEnd as (label: string) => void)(label),
+      () => timedLogger(`${label}/total`, fn)
+    );
+  }
+}