template-replacement 3.0.8

package/worker/child/base.ts

@@ -0,0 +1,89 @@
+import agency from './agency'
+import { messageData, messageTypes, methodCall } from '../type';
+import ReplaceInterface, { media } from '../../replace/interface';
+import { generateId } from '../../helper';
+import { c } from 'vite/dist/node/types.d-aGj9QkWt';
+
+type methodKeys<T> = {
+  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+
+const allowCallMethodNames: Partial<Record<methodKeys<ReplaceInterface>, boolean>> = {
+  addTempFile: true,
+  extractVariables: true,
+  extractMedias: true,
+  execute: true,
+}
+
+const tasks: Record<string, Function> = {} = {}
+
+let dispatch: ReplaceInterface
+
+export default function _init(replace: ReplaceInterface) {
+    dispatch = new agency(replace)
+}
+
+export async function call<T>(method: string, ...params: any[]): Promise<T> {
+  const replyId = generateId()
+  postMessage({
+    type: messageTypes.methodCall,
+    data: {
+      replyId,
+      method: method,
+      params: params
+    }
+  })
+
+  return new Promise<T>((resolve, reject) => {
+    tasks[replyId] = resolve
+  })
+}
+
+
+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
+        }
+        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 'extractMedias':
+                for (const key in (res as Record<string, Uint8Array>)) {
+                  const medias: media[] = res[key]
+                  medias.forEach(media => {
+                    transfer.push(media.data.buffer)
+                  })
+                }
+            }
+          }
+          postMessage({
+            type: messageTypes.methodCallReply,
+            data: {
+              replyId: callData.replyId,
+              result: res
+            }
+          }, { transfer })
+        }
+        break;
+      case messageTypes.methodCallReply:
+        tasks[data?.data?.replyId](data?.data?.result)
+        delete tasks[data?.data?.replyId]
+    }
+})

package/worker/child/general.ts

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

package/worker/child/sign.ts

@@ -0,0 +1,9 @@
+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)
+}

package/worker/index.ts

@@ -0,0 +1,65 @@
+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)[] = []
+
+    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)
+        }
+    }
+
+    #addOneWorker(webworker: webworker) {
+        const worker: Worker = new webworker()
+        worker.onmessage = async (event: MessageEvent) => {
+            const tasks = []
+            for (const fun of this.#listenerList) {
+                tasks.push(fun(event))
+            }
+            (await Promise.all(tasks)).forEach((reply: any)=>{
+                reply && worker.postMessage(reply)
+            })
+        }
+        this.#workers.push(worker)
+    }
+
+    concurrency(): number {
+        return this.#concurrency
+    }
+
+    postMessage(message: messageData, options?: StructuredSerializeOptions) {
+        if (!this.#workers[++this.#counter]) {
+            this.#counter = 0
+        }
+        this.#workers[this.#counter].postMessage(message, options)
+    }
+
+    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

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

package/worker/main/general.ts

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

package/worker/main/index.ts

@@ -0,0 +1,176 @@
+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';
+
+type methodKeys<T> = {
+  [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+
+const allowCallMethodNames: Partial<Record<methodKeys<ReplaceInterface>, boolean>> = {
+  sign: true,
+}
+
+// 分片最小任务数量
+const chunkMinNum = 20
+
+export default class WorkerReplace implements ReplaceInterface{
+  #files: Temp[] = []
+  #dispatcher: DispatcherInterface
+  #tasks: Record<string, Function> = {}
+  #concurrency: number = 1
+
+  constructor(dispatcher: DispatcherInterface) {
+    this.#dispatcher = dispatcher
+    this.setDispatcher(dispatcher)
+  }
+
+  setDispatcher(dispatcher: DispatcherInterface) {
+    dispatcher.addListener(event => {
+      const data = event.data as messageData
+      switch (data.type) {
+        case messageTypes.methodCallReply:
+          const replyData = data.data as methodCallReply
+          if (!replyData) {
+            return
+          }
+          if (this.#tasks[replyData.replyId]) {
+            this.#tasks[replyData.replyId](replyData.result)
+            delete this.#tasks[replyData.replyId]
+          }
+          break;
+        case messageTypes.methodCall:
+          const callData = data.data as methodCall
+          const method = callData.method as methodKeys<ReplaceInterface>
+          if (!allowCallMethodNames[method]) {
+            return
+          }
+          const fun = this[method]
+          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)
+              }
+            })
+          })
+      }
+    })
+
+    this.#dispatcher = dispatcher
+    this.#concurrency = this.#dispatcher.concurrency()
+  }
+
+  #call(method: string, params: any[]): any {
+    const transfer: any = []
+
+    params.forEach(param => {
+      if (param instanceof Array) {
+        param.forEach(item => {
+          if (item?.uint8Array?.buffer?.length) {
+            transfer.push(item.uint8Array.buffer)
+          }
+        })
+      }
+    })
+
+    const replyId = generateId()
+    this.#dispatcher.postMessage({
+      type: messageTypes.methodCall,
+      data: {
+        replyId,
+        method,
+        params
+      }
+    }, { transfer })
+    return new Promise((resolve, reject) => {
+      this.#tasks[replyId] = resolve
+    })
+  }
+
+  //分片
+  #chunk<T>(files: T[], chunkPackage?: (chunkData:T[]) => any): any[] {
+    let chunks = []
+    if (this.#concurrency > 1 && files.length > chunkMinNum) {
+      const chunkSize = Math.ceil(files.length/(Math.round(files.length/chunkMinNum)))
+      chunks = splitArrayIntoChunks(files, chunkSize)
+    }else {
+      chunks = [files]
+    }
+    if (chunkPackage) {
+      for (const i in chunks) {
+        chunks[i] = chunkPackage(chunks[i])
+      }
+    }
+    return chunks
+  }
+
+  async #getTempFileData(files: Temp[] | undefined): Promise<transmitFileInfo[]> {
+    if (!files) {
+      files = this.#files
+    }
+    const tasks: Promise<transmitFileInfo|undefined>[] = []
+    files.forEach(file => {
+      tasks.push(file.getTransmitFileInfo())
+    })
+    const res = await Promise.all(tasks)
+    return res.filter(item => !!item)
+  }
+
+  addTempFile(tempFile: Temp): void {
+    this.#files.push(tempFile)
+  }
+
+  clear(): void {
+    this.#files.length = 0
+  }
+
+  async #chunkCall(method: string, paramChunks: any[]): Promise<Record<string, any>>{
+    const tasks: Promise<Record<string, any>>[] = []
+    paramChunks.forEach(chunk => {
+      tasks.push(this.#call(method, chunk))
+    })
+    const tasksRes = await Promise.all(tasks)
+    return tasksRes.reduce((accumulator, current) => {
+      return {...accumulator, ...current}
+    }, {})
+  }
+
+  async extractVariables(files: Temp[] | undefined): Promise<Record<string, string[]>> {
+    const fileData = await this.#getTempFileData(files)
+    const chunks = this.#chunk(fileData, chunkData => {
+      return [chunkData]
+    })
+    return this.#chunkCall('extractVariables', chunks)
+  }
+
+  async extractMedias(files: Temp[] | undefined): Promise<Record<string, media[]>> {
+    const fileData = await this.#getTempFileData(files)
+    const chunks = this.#chunk(fileData, chunkData => {
+      return [chunkData]
+    })
+    return this.#chunkCall('extractMedias', chunks)
+  }
+
+  async sign(data: any): Promise<string> {
+    return ''
+  }
+
+  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]
+    })
+    return this.#chunkCall('execute', chunks)
+  }
+}

package/worker/main/sign.ts

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

package/worker/type.ts

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