template-replacement 3.3.3 → 3.4.0

package/worker/child/base.ts

@@ -1,114 +1,150 @@
 import agency from './agency'
-import { messageData, messageTypes, methodCall } from '../type';
-import ReplaceInterface, { media } from '../../replace/interface';
-import { generateId } from '../../helper';
+import { messageData, messageTypes, methodCall, methodCallReply } from '../type'
+import ReplaceInterface, { media } from '../../replace/interface'
+import { generateId } from '../../helper'
 
 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>> = {
-  addTempFile: true,
-  extractVariables: true,
-  extractMedias: true,
-  execute: true,
-  filesEncrypt: true,
-  fileEncrypt: true,
-  executeMultipleParams: true,
-}
+//允许调用的方法
+const allowCallMethodNames: Set<methodKeys<ReplaceInterface>> = new Set(["addTempFile", "extractVariables", "extractMedias", "execute", "filesEncrypt", "fileEncrypt", "executeMultipleParams"])
 
-const tasks = new Map<string, Function>()
+//处理方法调用的返回值
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const resultHandles = new Map<methodKeys<ReplaceInterface>, (result: any, transfer: Transferable[]) => Transferable[]>([
+  ['execute', (result: Record<string, Uint8Array>, transfer: Transferable[] = []) => {
+    for (const key in result) {
+      const value = result[key]
+      if (value?.length) {
+        transfer.push(value.buffer)
+      }
+    }
+    return transfer
+  }],
+  ['executeMultipleParams', (result: Record<string, Uint8Array>[], transfer: Transferable[] = []) => {
+    for (const map of result) {
+      for (const key in map) {
+        const value = map[key]
+        if (value?.length) {
+          transfer.push(value.buffer)
+        }
+      }
+    }
+    return transfer
+  }],
+  ['extractMedias', (result: Record<string, media[]>, transfer: Transferable[] = []) => {
+    for (const key in result) {
+      const medias = result[key]
+      for (const media of medias) {
+        if (media.data?.length) {
+          transfer.push(media.data.buffer)
+        }
+      }
+    }
+    return transfer
+  }],
+  ['fileEncrypt', (result: Uint8Array, transfer: Transferable[] = []) => {
+    if (result?.length) {
+      transfer.push(result.buffer)
+    }
+    return transfer
+  }],
+  ['filesEncrypt', (result: Uint8Array[], transfer: Transferable[] = []) => {
+    for (const item of result) {
+      if (item?.length) {
+        transfer.push(item.buffer)
+      }
+    }
+    return transfer
+  }],
+])
+
+const tasks = new Map<string, (value: unknown) => void>()
 
 let dispatch: ReplaceInterface
 
 export default function _init(replace: ReplaceInterface) {
-    dispatch = new agency(replace)
+  dispatch = new agency(replace)
 }
 
-export async function call<T>(method: string, ...params: any[]): Promise<T> {
+export function call<T>(method: string, ...params: unknown[]): Promise<T> {
   const replyId = generateId()
   postMessage({
     type: messageTypes.methodCall,
     data: {
       replyId,
       method: method,
-      params: params
-    }
+      params: params,
+    },
   })
 
   return new Promise<T>((resolve, reject) => {
-    tasks.set(replyId, resolve)
+    tasks.set(replyId, resolve as (value: unknown) => void)
   })
 }
 
-
-addEventListener('message', async event => {
-    const data = event.data as messageData
-    switch (data.type) {
-      case messageTypes.methodCall:
-        // 调用方法
-        const callData = data.data as methodCall
-        const method = callData.method as methodKeys<ReplaceInterface>
-        if (!allowCallMethodNames[method]) {
-          return
-        }
-        const fun = dispatch[method]
-        if (!dispatch[method]) {
-          return
+addEventListener('message', async (event) => {
+  const data = event.data as messageData
+  if (!data?.data) {
+    return
+  }
+  switch (data.type) {
+    case messageTypes.methodCall:
+      // 调用方法
+      const callData = data.data as methodCall<methodKeys<ReplaceInterface>>
+      const method = callData.method
+      if (!allowCallMethodNames.has(method)) {
+        //跳过不允许被调用的方法
+        return
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+      const fun = dispatch[method] as Function | undefined
+      if (!fun) {
+        return
+      }
+      let result: unknown
+      let error: unknown = undefined
+      try {
+        result = await Promise.resolve(fun.apply(dispatch, callData.params))
+      } catch (e) {
+        console.error(e)
+        error = (e as Error).message || ((e as Error).name || "error")
+      }
+      if (!callData.replyId) {
+        return
+      }
+      const transfer: Transferable[] = []
+      if (result) {
+        const resultHandle = resultHandles.get(method)
+        if (resultHandle) {
+          resultHandle(result, transfer)
         }
-        const res = await Promise.resolve(fun.apply(dispatch, callData.params))
-        if (callData.replyId) {
-          const transfer: any = []
-          if (res) {
-            switch (method) {
-              case 'execute':
-                for (const key in (res as Record<string, Uint8Array>)) {
-                  const value: Uint8Array = res[key]
-                  value.buffer && transfer.push(value.buffer)
-                }
-                break;
-              case 'executeMultipleParams':
-                for (const map of (res as Record<string, Uint8Array>[])) {
-                  for (const key in map) {
-                    const value: Uint8Array = map[key]
-                    value.buffer && transfer.push(value.buffer)
-                  }
-                }
-                break;
-              case 'extractMedias':
-                for (const key in (res as Record<string, Uint8Array>)) {
-                  const medias: media[] = res[key]
-                  for (const media of medias) {
-                    transfer.push(media.data.buffer)
-                  }
-                }
-                break;
-              case 'fileEncrypt':
-                (res as Uint8Array).length && transfer.push((res as Uint8Array).buffer)
-                break;
-              case 'filesEncrypt':
-                for (const item of (res as Uint8Array[])) {
-                  transfer.push(item.buffer)
-                }
-                break;
-            }
-          }
-          postMessage({
-            type: messageTypes.methodCallReply,
-            data: {
-              replyId: callData.replyId,
-              result: res
-            }
-          }, transfer.length ? { transfer } : undefined)
-        }
-        break;
-      case messageTypes.methodCallReply:
-        // 方法调用的返回数据
-        const fn = tasks.get(data?.data?.replyId)
-        if (!fn) {
-          return
-        }
-        fn(data?.data?.result)
-        tasks.delete(data?.data?.replyId)
-    }
+      }
+      postMessage(
+        {
+          type: messageTypes.methodCallReply,
+          data: {
+            replyId: callData.replyId,
+            result,
+            error
+          },
+        },
+        transfer.length ? { transfer } : undefined,
+      )
+      break
+    case messageTypes.methodCallReply:
+      // 方法调用的返回数据
+      const replyId = (data.data as methodCallReply).replyId
+      if (!replyId) {
+        return
+      }
+      const fn = tasks.get(replyId)
+      if (!fn) {
+        return
+      }
+      fn((data.data as methodCallReply).result)
+      tasks.delete(replyId)
+  }
 })

package/worker/child/general.ts

@@ -1,5 +1,4 @@
-import Replace from '../../replace/general';
-import init from './base';
+import Replace from '../../replace/general'
+import init from './base'
 
 init(new Replace())
-

package/worker/child/sign.ts

@@ -1,9 +1,9 @@
-import Replace from '../../replace/sign';
-import init, { call } from './base';
+import Replace from '../../replace/sign'
+import init, { call } from './base'
 
 const replace = new Replace()
 init(replace)
 
-replace.sign = async (data: any): Promise<string> => {
-  return await call<string>('sign', data)
+replace.sign = (data: unknown): Promise<string> => {
+  return call<string>('sign', data)
 }

package/worker/index.ts

@@ -1,68 +1,67 @@
-import { messageData } from "./type"
-import DispatcherInterface from "./interface"
+import { messageData } from './type'
+import DispatcherInterface from './interface'
 
 export type webworker = new () => Worker
 
 export default class worker implements DispatcherInterface {
-    #concurrency: number
-    #counter: number = 0
-    #workers: Worker[] = []
-    #listenerList: ((event: MessageEvent)=>void)[] = []
+  #concurrency: number
+  #counter: number = 0
+  #workers: Worker[] = []
+  #listenerList: ((event: MessageEvent) => void)[] = []
 
-    constructor(webworker: webworker, concurrency?: number) {
-        this.#concurrency = Number(concurrency)
-        if (!this.#concurrency || this.#concurrency < 1) {
-            try {
-                this.#concurrency = navigator.hardwareConcurrency < 8 ? navigator.hardwareConcurrency : 8
-            } catch (error) {
-            }
-        }
-        if (!this.#concurrency || this.#concurrency < 1) {
-            this.#concurrency = 1
-        }
-        for (let index = 0; index < this.#concurrency; index++) {
-            this.#addOneWorker(webworker)
-        }
+  constructor(webworker: webworker, concurrency?: number) {
+    this.#concurrency = Number(concurrency)
+    if (this.#concurrency < 1) {
+      try {
+        this.#concurrency = navigator.hardwareConcurrency < 8 ? navigator.hardwareConcurrency : 8
+      } catch (error) { }
     }
-
-    #addOneWorker(webworker: webworker) {
-        const worker: Worker = new webworker()
-        worker.onmessage = async (event: MessageEvent) => {
-            const tasks: unknown[] = []
-            for (const fun of this.#listenerList) {
-                tasks.push(fun(event))
-            }
-            const res = await Promise.all(tasks)
-            for (const reply of res) {
-                if (reply) {
-                    worker.postMessage(reply)
-                }
-            }
-        }
-        this.#workers.push(worker)
+    if (this.#concurrency < 1) {
+      this.#concurrency = 1
     }
-
-    concurrency(): number {
-        return this.#concurrency
+    for (let index = 0; index < this.#concurrency; index++) {
+      this.#addOneWorker(webworker)
     }
+  }
 
-    postMessage(message: messageData, options?: StructuredSerializeOptions) {
-        if (!this.#workers[++this.#counter]) {
-            this.#counter = 0
+  #addOneWorker(webworker: webworker) {
+    const worker: Worker = new webworker()
+    worker.onmessage = async (event: MessageEvent) => {
+      const tasks: unknown[] = []
+      for (const fun of this.#listenerList) {
+        tasks.push(fun(event))
+      }
+      const res = await Promise.all(tasks)
+      for (const reply of res) {
+        if (reply) {
+          worker.postMessage(reply)
         }
-        this.#workers[this.#counter].postMessage(message, options)
+      }
     }
+    this.#workers.push(worker)
+  }
+
+  concurrency(): number {
+    return this.#concurrency
+  }
 
-    addListener(fun: (event: MessageEvent) => void) {
-        this.#listenerList.push(fun)
+  postMessage(message: messageData, options?: StructuredSerializeOptions) {
+    if (!this.#workers[++this.#counter]) {
+      this.#counter = 0
     }
+    this.#workers[this.#counter].postMessage(message, options)
+  }
 
-    removeListener(fun: (event: MessageEvent) => void) {
-        for (const i in this.#listenerList) {
-            if (this.#listenerList[i] == fun) {
-                this.#listenerList.splice((i as unknown) as number, 1)
-                return
-            }
-        }
+  addListener(fun: (event: MessageEvent) => void) {
+    this.#listenerList.push(fun)
+  }
+
+  removeListener(fun: (event: MessageEvent) => void) {
+    for (const i in this.#listenerList) {
+      if (this.#listenerList[i] == fun) {
+        this.#listenerList.splice(i as unknown as number, 1)
+        return
+      }
     }
-}
+  }
+}

package/worker/interface.ts

@@ -1,11 +1,14 @@
-import { messageData, methodCall } from "./type";
+import { messageData, methodCall } from './type'
 
 export default interface DispatcherInterface {
-    concurrency(): number
+  concurrency(): number
 
-    postMessage(message: messageData|methodCall, options?: StructuredSerializeOptions): void
+  postMessage(
+    message: messageData | methodCall,
+    options?: StructuredSerializeOptions,
+  ): void
 
-    addListener(fun: (event: MessageEvent) => void): void
+  addListener<T>(fun: (event: MessageEvent<T>) => void): void
 
-    removeListener(fun: (event: MessageEvent) => void): void
-}
+  removeListener<T>(fun: (event: MessageEvent<T>) => void): void
+}

package/worker/main/general.ts

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