template-replacement 3.0.8 → 3.2.0

package/fileSystem/db/index.ts

@@ -0,0 +1,37 @@
+import indexedDBCache from './indexedDBCache'
+import FileSystem, {fileDataType} from '../interface'
+
+const db = new indexedDBCache()
+
+export default class DbFile implements FileSystem {
+    #name: string = ''
+
+    constructor(name: string){
+        this.#name = name
+    }
+
+    async write(data: fileDataType): Promise<boolean> {
+        try {
+            await db.putData<File>({
+                url: this.#name,
+                data: new File([data], this.#name),
+            })
+            return true
+        } catch (error) {
+            console.error(error)
+            return false
+        }
+    }
+
+    async read(): Promise<File>{
+        const data = await db.getDataByKey<File>(this.#name)
+        if (data && data.data) {
+            return data.data
+        }
+        return new File([], this.#name)
+    }
+
+    remove(): Promise<void> {
+        return db.deleteDataByKey(this.#name)
+    }
+}

package/{db → fileSystem/db}/indexedDBCache.ts

@@ -111,6 +111,22 @@ export default class indexedDBCache {
         })
     }
 
+    // 通过主键移除数据
+    deleteDataByKey<T>(key: string): Promise<void> {
+        return new Promise(async (resolve, reject) => {
+            // 通过主键读取数据
+            const request = (await this.store()).delete(key)
+            // 操作成功
+            request.onsuccess = () => {
+                resolve()
+            }
+            // 操作失败
+            request.onerror = (event) => {
+                reject(event)
+            }
+        })
+    }
+
     // 清空数据库数据
     clearDB(): Promise<any> {
         return new Promise(async (resolve, reject) => {

package/fileSystem/index.ts

@@ -0,0 +1,13 @@
+import FileSystem from './interface'
+import OpfsFile from './opfs'
+import DbFile from './db'
+
+export default (name: string): FileSystem =>  {
+    if (navigator?.storage?.getDirectory) {
+        return new OpfsFile(name)
+    }
+    return new DbFile(name)
+}
+
+
+

package/fileSystem/interface.ts

@@ -0,0 +1,8 @@
+
+export type fileDataType = BufferSource | Blob | string
+
+export default interface FileSystem {
+    write(data: fileDataType): Promise<boolean>
+    read(): Promise<File>
+    remove(): Promise<void>
+}

package/fileSystem/opfs/index.ts

@@ -0,0 +1,46 @@
+import FileSystem, {fileDataType} from '../interface'
+
+let opfsRoot: Promise<FileSystemDirectoryHandle> | undefined = undefined
+
+function getOpfsRoot(): Promise<FileSystemDirectoryHandle> {
+    if (!opfsRoot) {
+        opfsRoot = navigator.storage.getDirectory()
+    }
+    return opfsRoot
+}
+
+export default class OpfsFile implements FileSystem {
+    #name: string = ''
+    #handle: FileSystemFileHandle | undefined
+
+    constructor(name: string){
+        this.#name = name
+    }
+
+    async getHandle(): Promise<FileSystemFileHandle> {
+        if (!this.#handle) {
+            this.#handle = await (await getOpfsRoot()).getFileHandle(this.#name, { create: true })
+        }
+        return this.#handle
+    }
+
+    async write(data: fileDataType): Promise<boolean> {
+        try {
+            const writable = await (await this.getHandle()).createWritable()
+            await writable.write(data)
+            await writable.close()
+            return true
+        } catch (error) {
+            console.error(error)
+            return false
+        }
+    }
+
+    async read(): Promise<File>{
+        return (await this.getHandle()).getFile()
+    }
+
+    async remove(): Promise<void> {
+        return (await getOpfsRoot()).removeEntry(this.#name)
+    }
+}

package/helper/index.ts

@@ -1,4 +1,3 @@
-import { nanoid } from 'nanoid'
 import urlDownloadTask from '../task/urlDownloadTask'
 import { fileTypeFromBuffer } from 'file-type'
 
@@ -57,7 +56,7 @@ export async function fileTypeByBuffer(buffer: Uint8Array|ArrayBuffer|Blob): Pro
 }
 
 export function generateId(): string {
-    return nanoid()
+    return crypto.randomUUID()
 }
 
 export type fileArrayBufferData = {
@@ -67,7 +66,6 @@ export type fileArrayBufferData = {
 
 export async function filesReaderArrayBuffer(files: File[]): Promise<fileArrayBufferData[]> {
     const awaits = []
-    files.forEach
     for (const file of files) {
         awaits.push(new Promise(async (resolve, reject) => {
             try {

package/index.ts

@@ -18,4 +18,14 @@ export function WorkerGeneral(concurrency?: number): ReplaceInterface {
 
 export function WorkerSign(concurrency?: number): ReplaceInterface {
   return workerSign(concurrency)
+}
+
+type signFun = (data: any) => Promise<string>;
+
+export default (concurrency?: number, signFn?: signFun): ReplaceInterface => {
+  if (concurrency) {
+    return signFn ? workerSign(concurrency) : workerGeneral(concurrency)
+  }else {
+    return signFn ? sign() : general()
+  }
 }

package/package.json

@@ -1,31 +1,29 @@
 {
   "name": "template-replacement",
   "description": "模板文件替换",
-  "version": "3.0.8",
+  "version": "3.2.0",
   "author": "fushiliang <994301536@qq.com>",
-  "license": "ISC",
   "type": "module",
   "main": "index.ts",
   "scripts": {
     "build": "npx vite build --config vite.config.ts"
   },
   "dependencies": {
-    "@types/crypto-js": "^4.2.2",
     "@types/streamsaver": "^2.0.5",
-    "axios": "^1.7.9",
+    "axios": "^1.10.0",
     "fflate": "^0.8.2",
     "file-type": "^19.6.0",
-    "nanoid": "^4.0.2",
+    "rollup-plugin-terser": "^7.0.2",
     "streamsaver": "^2.0.6",
-    "template-replacement-core-wasm": "^1.0.0",
-    "template-replacement-sign-core-wasm": "^1.0.1",
+    "template-replacement-core-wasm": "^1.1.1",
+    "template-replacement-sign-core-wasm": "^1.1.1",
     "vite-plugin-wasm-pack": "^0.1.12"
   },
   "devDependencies": {
-    "@types/js-md5": "^0.7.2",
-    "typescript": "^5.7.3",
-    "vite": "^6.1.0",
-    "vite-plugin-dts": "^4.5.0"
+    "terser": "^5.43.1",
+    "typescript": "^5.8.3",
+    "vite": "^6.3.5",
+    "vite-plugin-dts": "^4.5.4"
   },
   "keywords": [
     "template-replacement"

package/pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+onlyBuiltDependencies:
+  - esbuild

package/replace/base.ts

@@ -29,8 +29,8 @@ export default class Base implements Interface{
         for (const file of files) {
             tasks.push(new Promise<void>(async (resolve, reject) => {
                 const buffer = await file.getBuffer()
-                if (buffer && (await file.type()) !== fileTypes.unknown) {
-                    data[file.name] = await this.#core.extract_one_file_variable_names(buffer)
+                if (buffer && (file.isDecode || (await file.type()) !== fileTypes.unknown)) {
+                    data[file.name] = await this.#core.extract_one_file_variable_names(buffer, file.isDecode)
                 }
                 resolve()
             }))
@@ -48,8 +48,8 @@ export default class Base implements Interface{
         for (const file of files) {
             tasks.push(new Promise<void>(async (resolve, reject) => {
                 const buffer = await file.getBuffer()
-                if (buffer && (await file.type()) !== fileTypes.unknown) {
-                    let medias = await this.#core.extract_one_file_medias(buffer)
+                if (buffer && (file.isDecode || (await file.type()) !== fileTypes.unknown)) {
+                    let medias = await this.#core.extract_one_file_medias(buffer, file.isDecode)
                     data[file.name] = []
                     if (medias && Array.isArray(medias)) {
                         medias.forEach(m => {
@@ -69,7 +69,7 @@ export default class Base implements Interface{
         return data
     }
 
-    async handle(paramsData: paramsData, files: Uint8Array[]): Promise<Uint8Array[]> {
+    async handle(paramsData: paramsData, files: Uint8Array[], isDecode: boolean = false): Promise<Uint8Array[]> {
         return []
     }
 
@@ -82,43 +82,70 @@ export default class Base implements Interface{
             files = this.#files
         }
 
-        const fileData: { names: string[], uint8Arrays: Uint8Array[] } = {
-            names: [],
-            uint8Arrays: [],
-        }
-
+        //等待文件加载完成
         const tasks = []
         for (const file of files) {
-            tasks.push(new Promise<Uint8Array|undefined>(async (resolve, reject) => {
-                resolve(file.getBuffer())
-            }))
+            tasks.push(file.getBuffer())
         }
         await Promise.all(tasks)
 
+        const fileMap: { decode: { names: string[], uint8Arrays: Uint8Array[] }, noDecode: { names: string[], uint8Arrays: Uint8Array[] }} = {
+            //需要解密的文件
+            decode: {
+                names: [],
+                uint8Arrays: [],
+            },
+            //不需要解密的文件
+            noDecode: {
+                names: [],
+                uint8Arrays: [],
+            }
+        };
+
+        //整理出需要解密和不需要解密的文件
         for (const file of files) {
-            if (file.uint8Array) {
-                fileData.names.push(file.name)
-                fileData.uint8Arrays.push(file.uint8Array)
+            if (!file.uint8Array) {
+                continue;
+            }
+            if (file.isDecode) {
+                fileMap.decode.names.push(file.name)
+                fileMap.decode.uint8Arrays.push(file.uint8Array)
+            } else {
+                fileMap.noDecode.names.push(file.name)
+                fileMap.noDecode.uint8Arrays.push(file.uint8Array)
             }
         }
+        //分别处理需要解密和不需要解密的文件
+        const res = await Promise.all([
+            this._execute(params, fileMap.noDecode.names, fileMap.noDecode.uint8Arrays, false),
+            this._execute(params, fileMap.decode.names, fileMap.decode.uint8Arrays, true),
+        ])
 
-        if(!fileData.uint8Arrays.length) {
-            return {}
+        return {
+            ...res[0],
+            ...res[1],
         }
+    }
 
-        const res = await this.handle(params, fileData.uint8Arrays)
-        const finishStatusCount = {
-            success: 0,
-            total: fileData.uint8Arrays.length
-        } //完成状态统计
+    async _execute(params: paramsData, names: string[], uint8Arrays: Uint8Array[], isDecode: boolean = false): Promise<Record<string, Uint8Array>> {
         const resData: Record<string, Uint8Array> = {}
-
+        if (!uint8Arrays.length) {
+            return resData
+        }
+        const res = await this.handle(params, uint8Arrays, isDecode)
         res.forEach((file, i) => {
             if (file.length) {
-                resData[fileData.names[i]] = file
-                finishStatusCount.success++
+                resData[names[i]] = file
             }
         })
         return resData
     }
+
+    async fileEncrypt(file: Uint8Array): Promise<Uint8Array> {
+        return await this.#core.file_encrypt(file)
+    }
+
+    async filesEncrypt(files: (Uint8Array)[]): Promise<(Uint8Array)[]> {
+        return await this.#core.files_encrypt(files)
+    }
 }

package/replace/general.ts

@@ -7,8 +7,8 @@ export default class General extends Base {
         super(core())
     }
 
-    async handle(paramsData: paramsData, files: Uint8Array[]): Promise<Uint8Array[]> {
+    async handle(paramsData: paramsData, files: Uint8Array[], isDecode: boolean = false): Promise<Uint8Array[]> {
       const [params, mediaBuffers] = await paramsData.toReplaceParams()
-      return replace_batch(params, mediaBuffers, files)
+      return replace_batch(params, mediaBuffers, files, isDecode)
     }
 }

package/replace/interface.ts

@@ -26,4 +26,9 @@ export default interface ReplaceInterface {
     //执行替换任务
     execute(params: paramsData, files: Temp[] | undefined): Promise<Record<string, Uint8Array>>
 
+    //文件加密
+    fileEncrypt(file: Uint8Array): Promise<Uint8Array>
+
+    //文件批量加密
+    filesEncrypt(files: (Uint8Array)[]): Promise<(Uint8Array)[]>
 }

package/replace/sign.ts

@@ -7,14 +7,14 @@ export default class Sign extends Base {
         super(core())
     }
 
-    async handle(paramsData: paramsData, files: Uint8Array[]): Promise<Uint8Array[]> {
+    async handle(paramsData: paramsData, files: Uint8Array[], isDecode: boolean = false): Promise<Uint8Array[]> {
         paramsData.add_media = add_media
         const [params] = await paramsData.toReplaceParams()
 
         const addFileTasks: Promise<number>[] = []
         files.forEach((file, i) => {
             addFileTasks.push(new Promise<number>(async resolve => {
-                resolve(await add_template(file))
+                resolve(await add_template(file, isDecode))
             }))
         })
 

package/task/urlDownloadTask.ts

@@ -1,5 +1,16 @@
 import axios, { AxiosProgressEvent } from "axios"
-import db from "../db/index"
+import file from "../fileSystem"
+
+async function hashString(str: string): Promise<string> {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(str);
+    const hashBuffer = await window.crypto.subtle.digest("SHA-1", data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    const hashHex = hashArray
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join("");
+    return hashHex;
+}
 
 export default class urlDownloadTask {
     urls: string[]
@@ -21,18 +32,17 @@ export default class urlDownloadTask {
     }
 
     async getUrlData(url: string): Promise<Blob|undefined> {
-        const data = await db.getDataByKey<Blob>(url)
-        if (data && data.data) {
-            return data.data
+        const hash = await hashString(url)
+        const fileObj = file(hash)
+        const data = await fileObj.read()
+        if (data.size) {
+            return data
         }
         const getData = await this.download(url)
         if (!getData) {
             return undefined
         }
-        db.putData<Blob>({
-            url: url,
-            data: getData,
-        })
+        fileObj.write(getData)
         return getData
     }
 

package/temp/index.ts

@@ -19,13 +19,17 @@ export enum status {
 export type transmitFileInfo = {
     name: string,
     uint8Array: Uint8Array,
+    isDecode: boolean,
 }
 
+//将传递的文件信息转为模板对象
 export function transmitFileInfoToTemp(data: transmitFileInfo) {
     if (!data.uint8Array || !data.name) {
         throw new Error("模板文件信息错误")
     }
-    return new Temp(undefined, undefined, data.uint8Array, data.name)
+    const temp = new Temp(undefined, undefined, data.uint8Array, data.name)
+    temp.isDecode = data.isDecode
+    return temp
 }
 
 export default class Temp implements TempInterface{
@@ -34,6 +38,7 @@ export default class Temp implements TempInterface{
     uint8Array?: Uint8Array
     url?: string
     status = status.waitLoad // 0文件待加载,1文件已加载,2完成替换,3替换失败
+    isDecode: boolean = false //文件是否被加密
 
     _output?: File|Blob
     _type?: fileTypes
@@ -107,7 +112,7 @@ export default class Temp implements TempInterface{
         }
         if (!this.blob) {
             if (this.uint8Array) {
-                this.blob = new Blob([ this.uint8Array ])
+                this.blob = new Blob([ this.uint8Array as BlobPart ])
             }else if (this.url) {
                 const [ blob ] = await urlsToFileBlobs([ this.url ])
                 if (blob) {
@@ -152,6 +157,7 @@ export default class Temp implements TempInterface{
         return {
             name: this.getName(),
             uint8Array: new Uint8Array(uint8Array.buffer.slice(0)),
+            isDecode: this.isDecode,
         }
     }
 }

package/vite.config.ts

@@ -1,6 +1,7 @@
 import { defineConfig } from 'vite';
 import wasmPack from 'vite-plugin-wasm-pack';
 import dts from 'vite-plugin-dts';
+import { terser } from 'rollup-plugin-terser';
 
 export default defineConfig({
   plugins: [
@@ -18,9 +19,20 @@ export default defineConfig({
       fileName: (format, entryName) => `${entryName}.js`,
       formats: ['es'],
     },
+    minify:"terser",
     rollupOptions: {
+      plugins: [terser({
+        format: {
+          // 取消代码注释
+          comments: false,
+        },
+        mangle: {
+          keep_classnames: false,
+          reserved: [],
+        },
+      })],
       output: {
-        entryFileNames: info => {
+        entryFileNames: (info: { facadeModuleId: string; }) => {
           const modules = info.facadeModuleId?.split('/')
           if (!modules?.length || modules?.length < 2) {
             return '[name].js'

package/worker/child/agency.ts

@@ -75,4 +75,13 @@ export default class implements ReplaceInterface {
     return this.replace.execute(new paramsData(text, media), files)
   }
 
+  //文件加密
+  fileEncrypt(file: Uint8Array): Promise<Uint8Array> {
+    return this.replace.fileEncrypt(file)
+  }
+
+  //文件批量加密
+  filesEncrypt(files: (Uint8Array)[]): Promise<(Uint8Array)[]> {
+    return this.replace.filesEncrypt(files)
+  }
 }

package/worker/child/base.ts

@@ -2,7 +2,6 @@ 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;
@@ -13,6 +12,8 @@ const allowCallMethodNames: Partial<Record<methodKeys<ReplaceInterface>, boolean
   extractVariables: true,
   extractMedias: true,
   execute: true,
+  filesEncrypt: true,
+  fileEncrypt: true,
 }
 
 const tasks: Record<string, Function> = {} = {}
@@ -44,6 +45,7 @@ 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]) {
@@ -71,6 +73,15 @@ addEventListener('message', async event => {
                     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({
@@ -79,10 +90,11 @@ addEventListener('message', async event => {
               replyId: callData.replyId,
               result: res
             }
-          }, { transfer })
+          }, transfer.length ? { transfer } : undefined)
         }
         break;
       case messageTypes.methodCallReply:
+        // 方法调用的返回数据
         tasks[data?.data?.replyId](data?.data?.result)
         delete tasks[data?.data?.replyId]
     }

package/worker/main/index.ts

@@ -16,7 +16,7 @@ const allowCallMethodNames: Partial<Record<methodKeys<ReplaceInterface>, boolean
 // 分片最小任务数量
 const chunkMinNum = 20
 
-export default class WorkerReplace implements ReplaceInterface{
+export default class WorkerReplace implements ReplaceInterface {
   #files: Temp[] = []
   #dispatcher: DispatcherInterface
   #tasks: Record<string, Function> = {}
@@ -92,19 +92,19 @@ export default class WorkerReplace implements ReplaceInterface{
         method,
         params
       }
-    }, { transfer })
+    }, transfer.length ? { transfer } :  undefined)
     return new Promise((resolve, reject) => {
       this.#tasks[replyId] = resolve
     })
   }
 
   //分片
-  #chunk<T>(files: T[], chunkPackage?: (chunkData:T[]) => any): any[] {
+  #chunk<T>(files: T[], chunkPackage?: (chunkData: T[]) => any): (T[] | ((chunkData: T[]) => 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 {
+      const chunkSize = Math.ceil(files.length / (Math.round(files.length / chunkMinNum)))
+      chunks = splitArrayIntoChunks<T>(files, chunkSize)
+    } else {
       chunks = [files]
     }
     if (chunkPackage) {
@@ -119,7 +119,7 @@ export default class WorkerReplace implements ReplaceInterface{
     if (!files) {
       files = this.#files
     }
-    const tasks: Promise<transmitFileInfo|undefined>[] = []
+    const tasks: Promise<transmitFileInfo | undefined>[] = []
     files.forEach(file => {
       tasks.push(file.getTransmitFileInfo())
     })
@@ -127,25 +127,26 @@ export default class WorkerReplace implements ReplaceInterface{
     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>>{
+  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}
+      return { ...accumulator, ...current }
     }, {})
   }
 
+  addTempFile(tempFile: Temp): void {
+    this.#files.push(tempFile)
+  }
+
   async extractVariables(files: Temp[] | undefined): Promise<Record<string, string[]>> {
     const fileData = await this.#getTempFileData(files)
     const chunks = this.#chunk(fileData, chunkData => {
@@ -173,4 +174,19 @@ export default class WorkerReplace implements ReplaceInterface{
     })
     return this.#chunkCall('execute', chunks)
   }
+
+  async fileEncrypt(file: Uint8Array): Promise<Uint8Array> {
+    return await this.#call('fileEncrypt', [file])
+  }
+
+  async filesEncrypt(files: Uint8Array[]): Promise<Uint8Array[]> {
+    const chunks = this.#chunk<Uint8Array>(files) as (Uint8Array[])[]
+
+    const tasks: Promise<Uint8Array[]>[] = []
+    chunks.forEach(chunk => {
+      tasks.push(this.#call('filesEncrypt', [chunk]))
+    })
+    const tasksRes = await Promise.all(tasks)
+    return tasksRes.flat()
+  }
 }

package/db/index.ts

@@ -1,5 +0,0 @@
-import indexedDBCache from './indexedDBCache'
-
-const db = new indexedDBCache()
-
-export default db