template-replacement 3.3.3 → 3.4.0

package/worker/main/index.ts

@@ -1,17 +1,19 @@
-import { messageData, messageTypes, methodCall, methodCallReply } from '../type';
-import DispatcherInterface from '../interface';
-import { generateId, splitArrayIntoChunks } from '../../helper';
-import ReplaceInterface, { media } from '../../replace/interface';
-import paramsData from '../../replace/paramsData';
-import Temp, { transmitFileInfo } from '../../temp';
+import { messageData, messageTypes, methodCall, methodCallReply } from '../type'
+import DispatcherInterface from '../interface'
+import { generateId, splitArrayIntoChunks } from '../../helper'
+import ReplaceInterface, { media } from '../../replace/interface'
+import paramsData from '../../replace/paramsData'
+import Temp, { transmitFileInfo } from '../../temp'
+import { Zip, ZipDeflate } from 'fflate'
 
 type methodKeys<T> = {
-  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
-}[keyof T];
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  [K in keyof T]: T[K] extends Function ? K : never
+}[keyof T]
 
-const allowCallMethodNames: Partial<Record<methodKeys<ReplaceInterface>, boolean>> = {
-  sign: true,
-}
+type allMethodNames = methodKeys<ReplaceInterface>
+
+const allowCallMethodNames: Set<allMethodNames> = new Set(["sign"])
 
 // 分片最小任务数量
 const chunkMinNum = 20
@@ -19,7 +21,10 @@ const chunkMinNum = 20
 export default class WorkerReplace implements ReplaceInterface {
   #files: Temp[] = []
   #dispatcher: DispatcherInterface
-  #tasks = new Map<string, Function>()
+  #tasks = new Map<string, {
+    resolve: (value: unknown) => void,
+    reject: (reason?: unknown) => void,
+  }>()
   #concurrency: number = 1
 
   constructor(dispatcher: DispatcherInterface) {
@@ -28,8 +33,8 @@ export default class WorkerReplace implements ReplaceInterface {
   }
 
   setDispatcher(dispatcher: DispatcherInterface) {
-    dispatcher.addListener(event => {
-      const data = event.data as messageData
+    dispatcher.addListener<messageData>(event => {
+      const data = event.data
       switch (data.type) {
         case messageTypes.methodCallReply:
           const replyData = data.data as methodCallReply
@@ -37,33 +42,46 @@ export default class WorkerReplace implements ReplaceInterface {
             return
           }
           const fn = this.#tasks.get(replyData.replyId)
-          if (fn) {
-            fn(replyData.result)
-            this.#tasks.delete(replyData.replyId)
+          if (!fn) {
+            return
+          }
+          if (replyData.error) {
+            fn.reject(replyData.error)
+          } else {
+            fn.resolve(replyData.result)
           }
-          break;
+          this.#tasks.delete(replyData.replyId)
+          break
         case messageTypes.methodCall:
-          const callData = data.data as methodCall
-          const method = callData.method as methodKeys<ReplaceInterface>
-          if (!allowCallMethodNames[method]) {
+          const callData = data.data as methodCall<allMethodNames>
+          const method = callData.method
+          if (!allowCallMethodNames.has(method)) {
             return
           }
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
           const fun = this[method] as Function | undefined
           if (!fun) {
             return
           }
+
           const callRes = fun.apply(this, callData.params)
           if (!callData.replyId) {
             return
           }
-          return new Promise(async (resolve, reject) => {
-            resolve({
-              type: messageTypes.methodCallReply,
-              data: {
-                replyId: callData.replyId,
-                result: await Promise.resolve(callRes)
-              }
-            })
+          return new Promise((resolve, reject) => {
+            try {
+              Promise.resolve(callRes).then(result => {
+                resolve({
+                  type: messageTypes.methodCallReply,
+                  data: {
+                    replyId: callData.replyId,
+                    result
+                  },
+                })
+              }).catch(reject)
+            } catch (error) {
+              reject(error)
+            }
           })
       }
     })
@@ -72,8 +90,8 @@ export default class WorkerReplace implements ReplaceInterface {
     this.#concurrency = this.#dispatcher.concurrency()
   }
 
-  #call(method: string, params: any[]): any {
-    const transfer: any = []
+  #call<T>(method: allMethodNames, params: unknown[]): Promise<T> {
+    const transfer: Transferable[] = []
 
     for (const param of params) {
       if (param instanceof Array) {
@@ -84,39 +102,51 @@ export default class WorkerReplace implements ReplaceInterface {
         }
       }
     }
-
     const replyId = generateId()
-    this.#dispatcher.postMessage({
-      type: messageTypes.methodCall,
-      data: {
-        replyId,
-        method,
-        params
-      }
-    }, transfer.length ? { transfer } :  undefined)
+    this.#dispatcher.postMessage(
+      {
+        type: messageTypes.methodCall,
+        data: {
+          replyId,
+          method,
+          params,
+        },
+      },
+      transfer.length ? { transfer } : undefined,
+    )
     return new Promise((resolve, reject) => {
-      this.#tasks.set(replyId, resolve)
+      this.#tasks.set(replyId, {
+        resolve: resolve as (value: unknown) => void,
+        reject
+      })
     })
   }
 
   //分片
-  #chunk<T>(data: T[], chunkPackage?: (chunkData: T[]) => any): (T[] | ((chunkData: T[]) => any))[] {
-    let chunks
+  #chunk<T, Y = undefined>(
+    data: T[],
+    chunkPackage?: ((chunkData: T[]) => Y),
+  ): T[][] | Y[] {
+    let chunks: T[][];
     if (this.#concurrency > 1 && data.length > chunkMinNum) {
-      const chunkSize = Math.ceil(data.length / (Math.round(data.length / chunkMinNum)))
+      const chunkSize = Math.ceil(
+        data.length / Math.round(data.length / chunkMinNum),
+      )
       chunks = splitArrayIntoChunks<T>(data, chunkSize)
     } else {
       chunks = [data]
     }
     if (chunkPackage) {
       for (const i in chunks) {
-        chunks[i] = chunkPackage(chunks[i])
+        (chunks as Y[])[i] = chunkPackage(chunks[i])
       }
     }
     return chunks
   }
 
-  async #getTempFileData(files: Temp[] | undefined): Promise<transmitFileInfo[]> {
+  async #getTempFileData(
+    files: Temp[] | undefined,
+  ): Promise<transmitFileInfo[]> {
     if (!files) {
       files = this.#files
     }
@@ -128,27 +158,29 @@ export default class WorkerReplace implements ReplaceInterface {
     return res.filter(item => !!item)
   }
 
-
   clear(): void {
     this.#files.length = 0
   }
 
-  async #chunkCall(method: string, paramChunks: any[]): Promise<Record<string, any>> {
-    const tasks: Promise<Record<string, any>>[] = []
+  async #chunkCall<T>(
+    method: allMethodNames,
+    paramChunks: unknown[][],
+  ): Promise<Record<string, T>> {
+    const tasks: Promise<Record<string, T>>[] = []
     for (const chunk of paramChunks) {
       tasks.push(this.#call(method, chunk))
     }
     const tasksRes = await Promise.all(tasks)
-    return tasksRes.reduce((accumulator, current) => {
-      return { ...accumulator, ...current }
-    }, {})
+    return Object.assign({}, ...tasksRes)
   }
 
   addTempFile(tempFile: Temp): void {
     this.#files.push(tempFile)
   }
 
-  async extractVariables(files: Temp[] | undefined): Promise<Record<string, string[]>> {
+  async extractVariables(
+    files: Temp[] | undefined,
+  ): Promise<Record<string, string[]>> {
     const fileData = await this.#getTempFileData(files)
     const chunks = this.#chunk(fileData, chunkData => {
       return [chunkData]
@@ -156,7 +188,9 @@ export default class WorkerReplace implements ReplaceInterface {
     return this.#chunkCall('extractVariables', chunks)
   }
 
-  async extractMedias(files: Temp[] | undefined): Promise<Record<string, media[]>> {
+  async extractMedias(
+    files: Temp[] | undefined,
+  ): Promise<Record<string, media[]>> {
     const fileData = await this.#getTempFileData(files)
     const chunks = this.#chunk(fileData, chunkData => {
       return [chunkData]
@@ -164,11 +198,14 @@ export default class WorkerReplace implements ReplaceInterface {
     return this.#chunkCall('extractMedias', chunks)
   }
 
-  async sign(data: any): Promise<string> {
+  async sign(_: unknown): Promise<string> {
     return ''
   }
 
-  async execute(params: paramsData, files: Temp[] | undefined): Promise<Record<string, Uint8Array>> {
+  async execute(
+    params: paramsData,
+    files: Temp[] | undefined,
+  ): Promise<Record<string, Uint8Array>> {
     const fileData = await this.#getTempFileData(files)
     const chunks = this.#chunk(fileData, chunkData => {
       return [params, chunkData]
@@ -176,28 +213,116 @@ export default class WorkerReplace implements ReplaceInterface {
     return this.#chunkCall('execute', chunks)
   }
 
-  async executeMultipleParams(params: paramsData[], files: Temp[] | undefined): Promise<Record<string, Uint8Array>[]> {
+  async executeToZip(
+    params: paramsData,
+    files: Temp[] | undefined,
+  ): Promise<Uint8Array> {
+    const fileData = await this.#getTempFileData(files)
+    return new Promise((resolve, reject) => {
+      const tasks: Promise<void>[] = []
+      const u8s: Uint8Array[] = [];
+      const _zip = new Zip((err, dat, final) => {
+        if (dat.length) {
+          u8s.push(dat)
+        }
+        if (final) {
+          const blob = new Blob(u8s as BlobPart[])
+          blob.arrayBuffer().then(res => {
+            resolve(new Uint8Array(res))
+          })
+        }
+      });
+      this.#chunk(fileData, chunkData => {
+        tasks.push(new Promise((resolve, reject) => {
+          //直接使用execute方法，无需解压再合并数据，性能更好
+          this.#call<Record<string, Uint8Array>>('execute', [params, chunkData]).then(res => {
+            for (const name of Object.keys(res)) {
+              const helloTxt = new ZipDeflate(name, {
+                level: 9,
+              });
+              _zip.add(helloTxt)
+              helloTxt.push(res[name] as Uint8Array, true);
+            }
+            resolve()
+          }).catch(reject)
+        }))
+      })
+      Promise.all(tasks).then(() => {
+        _zip.end()
+      })
+    })
+  }
+
+  async executeMultipleParams(
+    params: paramsData[],
+    files: Temp[] | undefined,
+  ): Promise<Record<string, Uint8Array>[]> {
     const fileData = await this.#getTempFileData(files)
-    const tasks: Promise<Record<string, any>[]>[] = []
+    const tasks: Promise<Record<string, Uint8Array>[]>[] = []
     this.#chunk(fileData, chunkData => {
-      tasks.push(this.#call('executeMultipleParams', [params, chunkData] as any))
+      tasks.push(
+        this.#call('executeMultipleParams', [params, chunkData]),
+      )
     })
-    const tasksRes = (await Promise.all(tasks)) as Record<string, Uint8Array>[][]
-    const res = new Array(params.length)
+    const tasksRes = await Promise.all(tasks)
+    const res = Array.from({ length: params.length }, () => ({}))
     for (const item of tasksRes) {
       for (let index = 0; index < item.length; index++) {
-        res[index] = {...item[index], ...res[index]}
+        Object.assign(res[index], item[index])
       }
     }
     return res
   }
 
-  async fileEncrypt(file: Uint8Array): Promise<Uint8Array> {
-    return await this.#call('fileEncrypt', [file])
+  async executeMultipleParamsToZip(
+    params: paramsData[],
+    files: Temp[] | undefined,
+  ): Promise<Uint8Array> {
+    const fileData = await this.#getTempFileData(files)
+    return new Promise(resolve => {
+      const tasks: Promise<void>[] = []
+      const u8s: Uint8Array[] = [];
+      const _zip = new Zip((err, dat, final) => {
+        if (dat.length) {
+          u8s.push(dat)
+        }
+        if (final) {
+          const blob = new Blob(u8s as BlobPart[])
+          blob.arrayBuffer().then(res => {
+            resolve(new Uint8Array(res))
+          })
+        }
+      });
+
+      this.#chunk(fileData, chunkData => {
+        tasks.push(new Promise((resolve, reject) => {
+          this.#call<Record<string, Uint8Array>[]>('executeMultipleParams', [params, chunkData]).then(res => {
+            for (let index = 0; index < res.length; index++) {
+              const item = res[index];
+              for (const name of Object.keys(item)) {
+                const helloTxt = new ZipDeflate(index + "/" + name, {
+                  level: 9,
+                });
+                _zip.add(helloTxt)
+                helloTxt.push(item[name] as Uint8Array, true);
+              }
+            }
+            resolve()
+          }).catch(reject)
+        }))
+      })
+      Promise.all(tasks).then(() => {
+        _zip.end()
+      })
+    })
+  }
+
+  fileEncrypt(file: Uint8Array): Promise<Uint8Array> {
+    return this.#call('fileEncrypt', [file])
   }
 
   async filesEncrypt(files: Uint8Array[]): Promise<Uint8Array[]> {
-    const chunks = this.#chunk<Uint8Array>(files) as (Uint8Array[])[]
+    const chunks = this.#chunk<Uint8Array>(files)
 
     const tasks: Promise<Uint8Array[]>[] = []
     for (const chunk of chunks) {
@@ -206,4 +331,4 @@ export default class WorkerReplace implements ReplaceInterface {
     const tasksRes = await Promise.all(tasks)
     return tasksRes.flat()
   }
-}
+}

package/worker/main/sign.ts

@@ -1,8 +1,8 @@
-import webworker from "../child/sign.ts?worker&inline"
-import base from ".."
+import webworker from '../child/sign.ts?worker&inline'
+import base from '../index'
 
 export default class extends base {
-    constructor(concurrency?: number) {
-        super(webworker, concurrency)
-    }
+  constructor(concurrency?: number) {
+    super(webworker, concurrency)
+  }
 }

package/worker/type.ts

@@ -1,24 +1,25 @@
 export enum messageTypes {
-    replace,
-    replaceProgress,
-    sign,
-    signReply,
-    methodCall,
-    methodCallReply,
+  replace,
+  replaceProgress,
+  sign,
+  signReply,
+  methodCall,
+  methodCallReply,
 }
 
 export type messageData = {
-    type: messageTypes,
-    data: any | methodCall | methodCallReply
+  type: messageTypes
+  data: unknown | methodCall | methodCallReply
 }
 
-export type methodCall = {
-    replyId?: string,
-    method: string,
-    params: any[]
+export type methodCall<T = string> = {
+  replyId?: string
+  method: T
+  params: unknown[]
 }
 
 export type methodCallReply = {
-    replyId: string,
-    result: any
-}
+  replyId: string
+  result: unknown
+  error?: string
+}