Исправление утечки памяти, оптимизация кода, лучшая читаемость кода

app/workers/crypto/crypto.ts

@@ -1,115 +1,88 @@
 import { sha256, md5 } from "node-forge";
-import { generateRandomKey } from "../../utils/utils";
 import * as secp256k1 from '@noble/secp256k1';
 
 const worker = new Worker(new URL('./crypto.worker.ts', import.meta.url), { type: 'module' });
 
-export const encodeWithPassword = async (password : string, data : any) : Promise<any> => {
-    let task = generateRandomKey(16);
-    return new Promise((resolve, _) => {
-        worker.addEventListener('message', (event: MessageEvent) => {
-            if (event.data.action === 'encodeWithPasswordResult' && event.data.task === task) {
-                resolve(event.data.result);
-            }
-        });
-        worker.postMessage({ action: 'encodeWithPassword', data: { password, payload: data, task } });
-    });
-}
+type WorkerReq =
+    | { id: number; type: 'encodeWithPassword'; payload: { password: string; data: any } }
+    | { id: number; type: 'decodeWithPassword'; payload: { password: string; data: any } }
+    | { id: number; type: 'encrypt'; payload: { publicKey: string; data: string } }
+    | { id: number; type: 'decrypt'; payload: { privateKey: string; data: string } }
+    | { id: number; type: 'chacha20Encrypt'; payload: { data: string } }
+    | { id: number; type: 'chacha20Decrypt'; payload: { ciphertext: string; nonce: string; key: string } };
 
-export const decodeWithPassword = (password : string, data : any) : Promise<any> => {
-    let task = generateRandomKey(16);
+type WorkerRes =
+    | { id: number; ok: true; data: any }
+    | { id: number; ok: false; error: string };
+
+let seq = 0;
+const pending = new Map<number, (res: WorkerRes) => void>();
+
+worker.onmessage = (e: MessageEvent<WorkerRes>) => {
+    const res = e.data;
+    const cb = pending.get(res.id);
+    if (cb) {
+        pending.delete(res.id);
+        cb(res);
+    }
+};
+
+function callWorker(req: Omit<WorkerReq, 'id'>): Promise<any> {
     return new Promise((resolve, reject) => {
-        worker.addEventListener('message', (event: MessageEvent) => {
-            if (event.data.action === 'decodeWithPasswordResult' && event.data.task === task) {
-                if(event.data.result === null){
-                    reject("Decryption failed");
-                    return;
-                }
-                resolve(event.data.result);
-            }
-        });
-        worker.postMessage({ action: 'decodeWithPassword', data: { password, payload: data, task } });
+        const id = ++seq;
+        pending.set(id, (res) => (res.ok ? resolve(res.data) : reject(res.error)));
+        worker.postMessage({ ...req, id });
     });
 }
 
-export const generateKeyPairFromSeed = async (seed : string) => {
-    //generate key pair using secp256k1 includes privatekey from seed
+export const encodeWithPassword = (password: string, data: any): Promise<any> => {
+    return callWorker({ type: 'encodeWithPassword', payload: { password, data } });
+};
+
+export const decodeWithPassword = (password: string, data: any): Promise<any> => {
+    return callWorker({ type: 'decodeWithPassword', payload: { password, data } });
+};
+
+export const encrypt = (data: string, publicKey: string): Promise<any> => {
+    return callWorker({ type: 'encrypt', payload: { publicKey, data } });
+};
+
+export const decrypt = (data: string, privateKey: string): Promise<any> => {
+    return callWorker({ type: 'decrypt', payload: { privateKey, data } });
+};
+
+export const chacha20Encrypt = (data: string): Promise<any> => {
+    return callWorker({ type: 'chacha20Encrypt', payload: { data } });
+};
+
+export const chacha20Decrypt = (ciphertext: string, nonce: string, key: string): Promise<any> => {
+    return callWorker({ type: 'chacha20Decrypt', payload: { ciphertext, nonce, key } });
+};
+
+export const generateKeyPairFromSeed = async (seed: string) => {
     const privateKey = sha256.create().update(seed).digest().toHex().toString();
     const publicKey = secp256k1.getPublicKey(Buffer.from(privateKey, "hex"), true);
     return {
         privateKey: privateKey,
         publicKey: Buffer.from(publicKey).toString('hex'),
     };
+};
 
-}
-
-export const encrypt = async (data : string, publicKey : string) : Promise<any>  => {
-    let task = generateRandomKey(16);
-    return new Promise((resolve, _) => {
-        worker.addEventListener('message', (event: MessageEvent) => {
-            if (event.data.action === 'encryptResult' && event.data.task === task) {
-                resolve(event.data.result);
-            }
-        });
-        worker.postMessage({ action: 'encrypt', data: { publicKey, payload: data, task } });
-    });
-}
-
-export const decrypt = async (data : string, privateKey : string) : Promise<any> => {
-    let task = generateRandomKey(16);
-    return new Promise((resolve, reject) => {
-        worker.addEventListener('message', (event: MessageEvent) => {
-            if (event.data.action === 'decryptResult' && event.data.task === task) {
-                if(event.data.result === null){
-                    reject("Decryption failed");
-                    return;
-                }
-                resolve(event.data.result);
-            }
-        });
-        worker.postMessage({ action: 'decrypt', data: { privateKey, payload: data, task } });
-    });
-}
-
-export const chacha20Encrypt = async (data : string) => {
-    let task = generateRandomKey(16);
-    return new Promise((resolve, _) => {
-        worker.addEventListener('message', (event: MessageEvent) => {
-            if (event.data.action === 'chacha20EncryptResult' && event.data.task === task) {
-                resolve(event.data.result);
-            }
-        });
-        worker.postMessage({ action: 'chacha20Encrypt', data: { payload: data, task } });
-    });
-}
-
-export const chacha20Decrypt = async (ciphertext : string, nonce : string, key : string) => {
-    let task = generateRandomKey(16);
-    return new Promise((resolve, _) => {
-        worker.addEventListener('message', (event: MessageEvent) => {
-            if (event.data.action === 'chacha20DecryptResult' && event.data.task === task) {
-                resolve(event.data.result);
-            }
-        });
-        worker.postMessage({ action: 'chacha20Decrypt', data: { ciphertext, nonce, key, task } });
-    });
-}
-
-export const generateMd5 = async (data : string) => {
+export const generateMd5 = async (data: string) => {
     const hash = md5.create();
     hash.update(data);
     return hash.digest().toHex();
-}
+};
 
-export const generateHashFromPrivateKey = async (privateKey : string) => {
+export const generateHashFromPrivateKey = async (privateKey: string) => {
     return sha256.create().update(privateKey + "rosetta").digest().toHex().toString();
-}
+};
 
-export const isEncodedWithPassword = (data : string) => {
-    try{
+export const isEncodedWithPassword = (data: string) => {
+    try {
         atob(data).split(":");
         return true;
-    } catch(e) {
+    } catch (e) {
         return false;
     }
-}
+};