template-replacement 3.3.3 → 3.4.0

package/replace/base.ts

@@ -1,236 +1,217 @@
-import Interface, { media } from './interface';
-import { Interface as CoreInterface } from '../core/base';
-import paramsData from './paramsData';
-import Temp from '../temp';
-import { fileTypes } from '../helper';
-
-export default class Base implements Interface{
-    #files: Temp[] = []
-    #core: CoreInterface
-
-    constructor(core: CoreInterface) {
-        this.#core = core
+import Interface, { media } from './interface'
+import { AsyncCoreInterface } from '../core/base'
+import paramsData from './paramsData'
+import Temp from '../temp'
+import { fileTypes } from '../helper'
+
+export type filesTidyResultItem = {
+  names: string[]
+  uint8Arrays: Uint8Array[]
+}
+
+export type filesTidyResult = {
+  //需要解密的文件
+  decode: filesTidyResultItem,
+  //不需要解密的文件
+  noDecode: filesTidyResultItem
+}
+
+//整理模板文件
+async function tempFilesTidy(files: Temp[] = []): Promise<filesTidyResult> {
+  //等待文件加载完成
+  const tasks = []
+  for (const file of files) {
+    tasks.push(file.getBuffer())
+  }
+  await Promise.all(tasks)
+
+  const result: filesTidyResult = {
+    decode: {
+      names: [],
+      uint8Arrays: [],
+    },
+    noDecode: {
+      names: [],
+      uint8Arrays: [],
+    },
+  }
+
+  //整理出需要解密和不需要解密的文件
+  for (const file of files) {
+    if (!file.uint8Array) {
+      continue
     }
-
-    addTempFile(tempFile: Temp){
-        this.#files.push(tempFile)
+    if (file.isDecode) {
+      result.decode.names.push(file.name)
+      result.decode.uint8Arrays.push(file.uint8Array)
+    } else {
+      result.noDecode.names.push(file.name)
+      result.noDecode.uint8Arrays.push(file.uint8Array)
     }
-
-    clear(): void {
-        this.#files.length = 0
+  }
+  return result
+}
+
+export default class Base implements Interface {
+  #files: Temp[] = []
+  #core: AsyncCoreInterface
+
+  constructor(core: AsyncCoreInterface) {
+    this.#core = core
+  }
+
+  addTempFile(tempFile: Temp) {
+    this.#files.push(tempFile)
+  }
+
+  clear(): void {
+    this.#files.length = 0
+  }
+
+  //提取单个文件内的所有变量
+  async extractOneFileVariables(variables: Record<string, string[]>, file: Temp): Promise<void> {
+    const buffer = await file.getBuffer()
+    if (!buffer) {
+      return
     }
-
-    async extractVariables(files: Temp[] | undefined): Promise<Record<string, string[]>> {
-        if (!files) {
-            files = this.#files
-        }
-        const data: Record<string, string[]> = {}
-        const tasks = []
-        for (const file of files) {
-            tasks.push(new Promise<void>(async resolve => {
-                try {
-                    const buffer = await file.getBuffer()
-                    if (buffer && (file.isDecode || (await file.type()) !== fileTypes.unknown)) {
-                        data[file.name] = await this.#core.extract_one_file_variable_names(buffer, file.isDecode)
-                    }
-                    resolve()
-                } catch (error) {
-                    console.error(error)
-                }
-            }))
-        }
-        await Promise.all(tasks)
-        return data
+    if ((await file.type()) === fileTypes.unknown && !file.isDecode) {
+      return
     }
-
-    async extractMedias(files: Temp[] | undefined): Promise<Record<string, media[]>> {
-        if (!files) {
-            files = this.#files
-        }
-        const data: Record<string, media[]> = {}
-        const tasks = []
-        for (const file of files) {
-            tasks.push(new Promise<void>(async resolve => {
-                try {
-                    const buffer = await file.getBuffer()
-                    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)) {
-                            for (const m of medias) {
-                                if (m.id && m.data) {
-                                    data[file.name].push({
-                                        id: m.id,
-                                        data: new Uint8Array(m.data)
-                                    })
-                                }
-                            }
-                        }
-                    }
-                    resolve()
-                } catch (error) {
-                    console.error(error)
-                }
-            }))
-        }
-        await Promise.all(tasks)
-        return data
+    variables[file.name] = await this.#core.extract_one_file_variable_names(
+      buffer,
+      file.isDecode,
+    )
+  }
+
+  //提取多个文件内的所有变量
+  async extractVariables(
+    files: Temp[] | undefined,
+  ): Promise<Record<string, string[]>> {
+    if (!files) {
+      files = this.#files
     }
-
-    async handle(paramsData: paramsData, files: Uint8Array[], isDecode: boolean = false): Promise<Uint8Array[]> {
-        return []
+    const variables: Record<string, string[]> = {}
+    const tasks = []
+    for (const file of files) {
+      tasks.push(this.extractOneFileVariables(variables, file))
     }
-    async handleMultipleParams(paramsData: paramsData[], files: Uint8Array[], isDecode: boolean = false): Promise<Uint8Array[]> {
-        return []
+    await Promise.allSettled(tasks)
+    return variables
+  }
+
+  //提取单个文件内的所有媒体文件
+  async extractOneFileMedias(medias: Record<string, media[]>, file: Temp): Promise<void> {
+    const buffer = await file.getBuffer()
+    if (!buffer) {
+      return
     }
-
-    async sign(data: any): Promise<string> {
-        return ""
+    if ((await file.type()) === fileTypes.unknown && !file.isDecode) {
+      return
     }
-
-    async execute(params: paramsData, files: Temp[] | undefined): Promise<Record<string, Uint8Array>> {
-        if (!files) {
-            files = this.#files
-        }
-
-        //等待文件加载完成
-        const tasks = []
-        for (const file of files) {
-            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) {
-                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),
-        ])
-
-        return {
-            ...res[0],
-            ...res[1],
-        }
+    const res = await this.#core.extract_one_file_medias(
+      buffer,
+      file.isDecode,
+    )
+    medias[file.name] = []
+    if (!Array.isArray(res)) {
+      return
     }
-
-    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)
-        for (let index = 0; index < res.length; index++) {
-            const file = res[index]
-            if (file.length) {
-                resData[names[index]] = file
-            }
-        }
-        return resData
+    for (const { id, data } of res) {
+      if (id && data) {
+        medias[file.name].push({
+          id: id,
+          data: new Uint8Array(data),
+        })
+      }
     }
-
-    async executeMultipleParams(paramsList: paramsData[], files: Temp[] | undefined): Promise<Record<string, Uint8Array>[]> {
-        if (!files) {
-            files = this.#files
-        }
-
-        //等待文件加载完成
-        const tasks = []
-        for (const file of files) {
-            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) {
-                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._executeMultipleParams(paramsList, fileMap.noDecode.names, fileMap.noDecode.uint8Arrays, false),
-            this._executeMultipleParams(paramsList, fileMap.decode.names, fileMap.decode.uint8Arrays, true),
-        ])
-
-        const result = []
-        for (let i = 0; i < res[0].length; i++) {
-            result.push({...res[0][i], ...res[1][i]})
-        }
-        return result
+  }
+
+  //提取多个文件内的所有媒体文件
+  async extractMedias(
+    files: Temp[] | undefined,
+  ): Promise<Record<string, media[]>> {
+    if (!files) {
+      files = this.#files
     }
-
-
-    async _executeMultipleParams(paramsList: paramsData[], names: string[], uint8Arrays: Uint8Array[], isDecode: boolean = false): Promise<Record<string, Uint8Array>[]> {
-        const result: Record<string, Uint8Array>[] = Array(paramsList.length) //整理出每一套参数的替换结果文件
-        if (!uint8Arrays.length) {
-            return result
-        }
-        const resFileList = await this.handleMultipleParams(paramsList, uint8Arrays, isDecode)
-
-        let resFileIndex = 0
-        for (let index = 0; index < paramsList.length; index++) {
-            const resultItem: Record<string, Uint8Array> = {}
-            for (const name of names) {
-                const file = resFileList[resFileIndex++]
-                if (file.length) {
-                    resultItem[name] = file
-                }
-            }
-            result[index] = resultItem
-        }
-        return result
+    const medias: Record<string, media[]> = {}
+    const tasks = []
+    for (const file of files) {
+      tasks.push(this.extractOneFileMedias(medias, file))
     }
-
-    fileEncrypt(file: Uint8Array): Promise<Uint8Array> {
-        return this.#core.file_encrypt(file)
+    await Promise.all(tasks)
+    return medias
+  }
+
+  async handle(
+    paramsData: paramsData,
+    files: Uint8Array[],
+    encode_files: Uint8Array[],
+  ): Promise<Uint8Array[]> {
+    return []
+  }
+
+  async handleMultipleParams(
+    paramsData: paramsData[],
+    files: Uint8Array[],
+    encode_files: Uint8Array[],
+  ): Promise<Uint8Array[]> {
+    return []
+  }
+
+  async sign(data: unknown): Promise<string> {
+    return ''
+  }
+
+  async execute(
+    params: paramsData,
+    files: Temp[] | undefined,
+  ): Promise<Record<string, Uint8Array>> {
+    const { noDecode, decode } = await tempFilesTidy(files ?? this.#files)
+    const res = await this.handle(params, noDecode.uint8Arrays, decode.uint8Arrays);
+    const result: Record<string, Uint8Array> = {}
+    let i = 0
+    for (const name of noDecode.names) {
+      result[name] = res[i++] ?? new Uint8Array()
     }
-
-    filesEncrypt(files: (Uint8Array)[]): Promise<(Uint8Array)[]> {
-        return this.#core.files_encrypt(files)
+    for (const name of decode.names) {
+      result[name] = res[i++] ?? new Uint8Array()
+    }
+    return result
+  }
+
+  async executeMultipleParams(
+    paramsList: paramsData[],
+    files: Temp[] | undefined,
+  ): Promise<Record<string, Uint8Array>[]> {
+    const { noDecode, decode } = await tempFilesTidy(files ?? this.#files)
+    const resFileList = await this.handleMultipleParams(paramsList, noDecode.uint8Arrays, decode.uint8Arrays);
+    const result: Record<string, Uint8Array>[] = Array(paramsList.length)
+
+    let resFileIndex = 0
+    for (let index = 0; index < paramsList.length; index++) {
+      const resultItem: Record<string, Uint8Array> = {}
+      for (const name of noDecode.names) {
+        const file = resFileList[resFileIndex++]
+        if (file.length) {
+          resultItem[name] = file
+        }
+      }
+      for (const name of decode.names) {
+        const file = resFileList[resFileIndex++]
+        if (file.length) {
+          resultItem[name] = file
+        }
+      }
+      result[index] = resultItem
     }
-}
+    return result
+  }
+
+  async fileEncrypt(file: Uint8Array): Promise<Uint8Array> {
+    return this.#core.file_encrypt(file)
+  }
+
+  async filesEncrypt(files: Uint8Array[]): Promise<Uint8Array[]> {
+    return this.#core.files_encrypt(files)
+  }
+}

package/replace/general.ts

@@ -1,28 +1,48 @@
-import Base from './base';
-import core, { replace_batch, replace_batch_multiple_params } from '../core/general'
-import paramsData, { replaceParams } from './paramsData';
-
+import Base from './base'
+import core, {
+  replace_batch,
+  replace_batch_multiple_params
+} from '../core/general'
+import paramsData, { replaceParams } from './paramsData'
 export default class General extends Base {
-    constructor() {
-        super(core())
-    }
+  constructor() {
+    super(core())
+  }
 
-    async handle(paramsData: paramsData, files: Uint8Array[], isDecode: boolean = false): Promise<Uint8Array[]> {
-      const [params, mediaBuffers] = await paramsData.toReplaceParams()
-      return replace_batch(params, mediaBuffers, files, isDecode)
-    }
+  async handle(
+    paramsData: paramsData,
+    files: Uint8Array[],
+    encode_files: Uint8Array[],
+  ): Promise<Uint8Array[]> {
+    const [params, mediaBuffers] = await paramsData.toReplaceParams()
+    return replace_batch(params, mediaBuffers, files, encode_files)
+  }
 
-    async handleMultipleParams(paramsList: paramsData[], files: Uint8Array[], isDecode: boolean = false): Promise<Uint8Array[]> {
-      const mediaBuffers: Uint8Array[] = [],
-            newParamsListTasks: Promise<replaceParams>[] = []
-      for (const paramsData of paramsList) {
-        newParamsListTasks.push(new Promise<replaceParams>((resolve, reject) => {
-          paramsData.toReplaceParams(mediaBuffers).then(([params]) => {
-            resolve(params)
-          }).catch(reject)
-        }))
-      }
-      const newParamsList = await Promise.all(newParamsListTasks)
-      return replace_batch_multiple_params(newParamsList, mediaBuffers, files, isDecode)
+  async handleMultipleParams(
+    paramsList: paramsData[],
+    files: Uint8Array[],
+    encode_files: Uint8Array[],
+  ): Promise<Uint8Array[]> {
+    const mediaBuffers: Uint8Array[] = [],
+      newParamsListTasks: Promise<replaceParams>[] = []
+    for (const paramsData of paramsList) {
+      newParamsListTasks.push(
+        new Promise<replaceParams>((resolve, reject) => {
+          paramsData
+            .toReplaceParams(mediaBuffers)
+            .then(([params]) => {
+              resolve(params)
+            })
+            .catch(reject)
+        }),
+      )
     }
-}
+    const newParamsList = await Promise.all(newParamsListTasks)
+    return replace_batch_multiple_params(
+      newParamsList,
+      mediaBuffers,
+      files,
+      encode_files,
+    )
+  }
+}