template-replacement 3.1.0 → 3.2.0

package/README.md

@@ -0,0 +1,178 @@
+### 文件变量替换
+[demo地址](https://gitee.com/zvc/template-replacement-demo)
+
+目前支持替换DOCX和XLSX类型的文件，对应的文件MIME信息为：
+application/vnd.openxmlformats-officedocument.wordprocessingml.document
+application/vnd.openxmlformats-officedocument.wordprocessingml.template
+application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
+
+##### 已实现功能：
+- ✅ 支持DOCX和XLSX文件进行替换
+- ✅ 支持使用文件数据/文件下载地址替换
+- ✅ 文本=>文本替换
+- ✅ 文本=>图片替换
+- ✅ 媒体文件=>媒体文件替换（同类型）
+- ✅ 支持多线程处理
+- ✅ 变量提取
+- ✅ 媒体文件提取
+- ✅ 模板文件加密/替换加密模板（确保文件无法被第三方使用）
+##### 待实现功能：
+- 支持PPTX文件进行替换
+- 更多媒体类型替换
+- 支持更多媒体属性配置
+<br>
+
+#### 功能演示
+##### 一、实例化替换对象
+1、模板替换：
+``` javascript
+import tr from 'template-replacement'
+const replaceInstance = tr()
+```
+2、多线程模板替换：
+需要同时替换大量文件时使用
+``` javascript
+import tr from 'template-replacement'
+const worker = 4 //线程数量
+const replaceInstance = tr(worker)
+```
+3、模板替换并校验签名：
+需结合后端做签名校验，前端替换之前需要请求后端获取签名，不想让前端直接使用模板替换功能的场景可以用这个方式，可以确保每次模板替换都是经过后端授权验证的。
+``` javascript
+import tr from 'template-replacement'
+
+//  获取函数签名
+async function getSignature(data) {
+  /** 对data数据进行签名处理，可以请求后端获取签名或者通过其他方式生成签名，不要前端直接生成 */
+}
+
+const replaceInstance = tr(0, getSignature)
+```
+4、多线程模板替换并校验签名：
+``` javascript
+import tr from 'template-replacement'
+const worker = 4 //线程数量
+const replaceInstance = tr(worker, getSignature)
+```
+
+##### 二、添加模板
+支持对docx、xlsx格式的文件进行替换，支持传递File、Blob、Uint8Array类型的文件数据或者文件下载地址
+``` typescript
+import temp from 'template-replacement/temp'
+
+//文件名类型
+type fileName = string
+
+/**
+ * 1、实例化一个模板文件数据，file、url、uint8Array必须传一个
+ * file?: File|Blob 文件数据
+ * url?: string 文件下载地址
+ * uint8Array?: Uint8Array 文件数据
+ * name?: fileName 文件名，必须设置文件名且同一批次替换的文件中文件名不能重复,
+ *                 如果file传递了File数据默认按照File中的name属性作为文件名
+ */
+const tempFile = new temp(file, url, uint8Array, name)
+
+// 2、标记出加密的模板文件，未加密的文件跳过这一步
+tempFile.isDecode = true
+
+// 3、把模板文件加入到替换任务中
+//每次加一个，可多次添加
+replaceInstance.addTempFile(tempFile)
+
+// 4、清除所有模板文件
+replaceInstance.clear()
+```
+##### 三、批量提取模板中的媒体文件数据（不需要提取媒体文件数据时跳过这一步）
+``` typescript
+//媒体文件id，同一个媒体文件在一个模板中多次使用或在不同模板中的id相同
+type mediaID = string
+//媒体数据
+type Media = {
+  id: mediaID, // 媒体文件id
+  data: Uint8Array, // 媒体文件数据
+}
+type extractMediasResult = Record<fileName, Media[]>
+
+//tempFiles: temp[] 为模板文件数组
+const result: extractMediasResult = await replaceInstance.extractMedias(tempFiles)
+```
+##### 四、提取模板变量（不需要提取变量时跳过这一步）
+``` typescript
+/**
+ * 变量名，建议使用 ${name} 格式
+ * 理论上支持任意文本格式，为避免出现未知问题变量名最好使用中文或者英文字符
+ */
+type variableName = string
+type extractVariablesResult = Record<fileName, variableName[]>
+const result: extractVariablesResult = await replaceInstance.extractVariables()
+```
+
+##### 五、执行变量替换
+``` typescript
+import paramsData, { textData, mediaData } from 'template-replacement/replace/paramsData'
+import image from 'template-replacement/replace/image'
+
+//变量值
+type variableValue = string
+type textData = Record<variableName, variableValue|image>
+type mediaData = Record<mediaID, image>
+type executeResult = Record<fileName, Uint8Array>
+
+/**
+ * 替换的变量数据
+ * texts: textData 文本变量数据，将模板中的文本变量替换为指定文本或者媒体数据
+ * medias: mediaData 媒体变量数据，将模板中的媒体文件替换为指定媒体数据
+ */
+const params = new paramsData(texts, medias)
+const result: executeResult = await replaceInstance.execute(params)
+```
+
+
+##### 其他说明
+1、媒体文件替换，目前仅支持图片替换，其他文件类型暂不支持
+``` typescript
+import image from 'template-replacement/replace/image'
+
+/**
+ * file: Blob 媒体文件
+ */
+const media = new image(file)
+
+/**
+ * 设置图片的宽高（像素）
+ */
+media.setPxExtent(width: number, height: number)
+
+/**
+ * 设置图片的宽高（厘米）
+ */
+media.setCmExtent(width: number, height: number)
+```
+
+2、文件加密，需要防止被第三方获取到模板文件的场景可以使用。
+``` typescript
+
+// 加密后的文件数据，按照传入的文件顺序返回
+type filesEncryptResult = Uint8Array[]
+
+/**
+ * 批量加密文件
+ * buffers: Uint8Array[] 待加密的文件数据
+ */
+const result: filesEncryptResult = await replaceInstance.filesEncrypt(buffers)
+```
+
+3、模板对象部分属性说明
+``` typescript
+//template-replacement/temp
+class temp {
+    name: string = '' //文件名
+    blob?: File|Blob //文件数据
+    uint8Array?: Uint8Array //文件数据
+    url?: string //文件下载地址
+    status = status.waitLoad // 文件状态 0文件待加载,1文件已加载,2完成替换,3替换失败
+    isDecode: boolean = false //文件是否被加密
+}
+
+```

package/dist/base-dj-SYiQI.js

@@ -0,0 +1,193 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _e, _t;
+new class {
+  constructor() {
+    this._initFinishCallBackFuns = [], this._isInitFinish = false, this._dbName = "template_replacement", this._dbversion = 1, this._cacheTableName = "templates", this._tableMap = {}, this.initDB();
+  }
+  initDB() {
+    return new Promise((e2, t2) => {
+      const a2 = indexedDB.open(this._dbName, this._dbversion);
+      a2.onsuccess = (t3) => {
+        if (this._db = a2.result, this._isInitFinish = true, this._initFinishCallBackFuns) {
+          try {
+            for (const e3 of this._initFinishCallBackFuns) e3();
+          } catch (e3) {
+          }
+          this._initFinishCallBackFuns = void 0;
+        }
+        e2(t3);
+      }, a2.onerror = (e3) => {
+        console.error(e3), t2(e3);
+      }, a2.onupgradeneeded = (t3) => {
+        let i = a2.result;
+        i.objectStoreNames.contains(this._cacheTableName) || i.createObjectStore(this._cacheTableName, { keyPath: "url" }), e2(t3);
+      };
+    });
+  }
+  async awaitInit() {
+    !this._isInitFinish && this._initFinishCallBackFuns && await new Promise((e2, t2) => {
+      var _a;
+      (_a = this._initFinishCallBackFuns) == null ? void 0 : _a.push(e2);
+    });
+  }
+  closeDB() {
+    var _a;
+    (_a = this._db) == null ? void 0 : _a.close();
+  }
+  async store(e2) {
+    await this.awaitInit();
+    return this._db.transaction(this._cacheTableName, e2).objectStore(this._cacheTableName);
+  }
+  putData(e2) {
+    return new Promise(async (t2, a2) => {
+      const i = (await this.store("readwrite")).put(e2);
+      i.onsuccess = (e3) => {
+        t2(e3);
+      }, i.onerror = (e3) => {
+        a2(e3);
+      };
+    });
+  }
+  getDataByKey(e2) {
+    return new Promise(async (t2, a2) => {
+      const i = (await this.store()).get(e2);
+      i.onsuccess = () => {
+        t2(i.result);
+      }, i.onerror = (e3) => {
+        a2(e3);
+      };
+    });
+  }
+  deleteDataByKey(e2) {
+    return new Promise(async (t2, a2) => {
+      const i = (await this.store()).delete(e2);
+      i.onsuccess = () => {
+        t2();
+      }, i.onerror = (e3) => {
+        a2(e3);
+      };
+    });
+  }
+  clearDB() {
+    return new Promise(async (e2, t2) => {
+      const a2 = (await this.store("readwrite")).clear();
+      a2.onsuccess = (t3) => {
+        e2(t3);
+      }, a2.onerror = (e3) => {
+        t2(e3);
+      };
+    });
+  }
+}();
+var e = ((e2) => (e2.word = "word", e2.excel = "excel", e2.unknown = "unknown", e2))(e || {});
+class t {
+  constructor(e2) {
+    __privateAdd(this, _e, []);
+    __privateAdd(this, _t);
+    __privateSet(this, _t, e2);
+  }
+  addTempFile(e2) {
+    __privateGet(this, _e).push(e2);
+  }
+  clear() {
+    __privateGet(this, _e).length = 0;
+  }
+  async extractVariables(t2) {
+    t2 || (t2 = __privateGet(this, _e));
+    const a2 = {}, i = [];
+    for (const s of t2) i.push(new Promise(async (t3, i2) => {
+      const n = await s.getBuffer();
+      n && (s.isDecode || await s.type() !== e.unknown) && (a2[s.name] = await __privateGet(this, _t).extract_one_file_variable_names(n, s.isDecode)), t3();
+    }));
+    return await Promise.all(i), a2;
+  }
+  async extractMedias(t2) {
+    t2 || (t2 = __privateGet(this, _e));
+    const a2 = {}, i = [];
+    for (const s of t2) i.push(new Promise(async (t3, i2) => {
+      const n = await s.getBuffer();
+      if (n && (s.isDecode || await s.type() !== e.unknown)) {
+        let e2 = await __privateGet(this, _t).extract_one_file_medias(n, s.isDecode);
+        a2[s.name] = [], e2 && Array.isArray(e2) && e2.forEach((e3) => {
+          e3.id && e3.data && a2[s.name].push({ id: e3.id, data: new Uint8Array(e3.data) });
+        });
+      }
+      t3();
+    }));
+    return await Promise.all(i), a2;
+  }
+  async handle(e2, t2, a2 = false) {
+    return [];
+  }
+  async sign(e2) {
+    return "";
+  }
+  async execute(e2, t2) {
+    t2 || (t2 = __privateGet(this, _e));
+    const a2 = [];
+    for (const e3 of t2) a2.push(e3.getBuffer());
+    await Promise.all(a2);
+    const i = { decode: { names: [], uint8Arrays: [] }, noDecode: { names: [], uint8Arrays: [] } };
+    for (const e3 of t2) e3.uint8Array && (e3.isDecode ? (i.decode.names.push(e3.name), i.decode.uint8Arrays.push(e3.uint8Array)) : (i.noDecode.names.push(e3.name), i.noDecode.uint8Arrays.push(e3.uint8Array)));
+    const s = await Promise.all([this._execute(e2, i.noDecode.names, i.noDecode.uint8Arrays, false), this._execute(e2, i.decode.names, i.decode.uint8Arrays, true)]);
+    return { ...s[0], ...s[1] };
+  }
+  async _execute(e2, t2, a2, i = false) {
+    const s = {};
+    if (!a2.length) return s;
+    return (await this.handle(e2, a2, i)).forEach((e3, a3) => {
+      e3.length && (s[t2[a3]] = e3);
+    }), s;
+  }
+  async fileEncrypt(e2) {
+    return await __privateGet(this, _t).file_encrypt(e2);
+  }
+  async filesEncrypt(e2) {
+    return await __privateGet(this, _t).files_encrypt(e2);
+  }
+}
+_e = new WeakMap();
+_t = new WeakMap();
+class a {
+  constructor(e2, t2) {
+    this.awaitInit = e2, this.module = t2;
+  }
+  async await() {
+    return await this.awaitInit, this;
+  }
+  async add_template(e2, t2) {
+    return await this.awaitInit, this.module.add_template(e2, t2);
+  }
+  async add_media(e2) {
+    return await this.awaitInit, this.module.add_media(e2);
+  }
+  async extract_one_file_variable_names(e2, t2) {
+    return await this.awaitInit, this.module.extract_one_file_variable_names(e2, t2);
+  }
+  async extract_variable_names(e2, t2) {
+    return await this.awaitInit, this.module.extract_variable_names(e2, t2);
+  }
+  async extract_one_file_medias(e2, t2) {
+    return await this.awaitInit, this.module.extract_one_file_medias(e2, t2);
+  }
+  async extract_medias(e2, t2) {
+    return await this.awaitInit, this.module.extract_medias(e2, t2);
+  }
+  async file_encrypt(e2) {
+    return await this.awaitInit, this.module.file_encrypt(e2);
+  }
+  async files_encrypt(e2) {
+    await this.awaitInit;
+    return this.module.files_encrypt(e2);
+  }
+}
+export {
+  t as B,
+  a as b
+};

package/dist/index-BlAsmv2Q.js

@@ -0,0 +1,62 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var _r, _s, _e, _t, _r_instances, c_fn;
+class r {
+  constructor(r2, s) {
+    __privateAdd(this, _r_instances);
+    __privateAdd(this, _r);
+    __privateAdd(this, _s, 0);
+    __privateAdd(this, _e, []);
+    __privateAdd(this, _t, []);
+    if (__privateSet(this, _r, Number(s)), !__privateGet(this, _r) || __privateGet(this, _r) < 1) try {
+      __privateSet(this, _r, navigator.hardwareConcurrency < 8 ? navigator.hardwareConcurrency : 8);
+    } catch (r3) {
+    }
+    (!__privateGet(this, _r) || __privateGet(this, _r) < 1) && __privateSet(this, _r, 1);
+    for (let s2 = 0; s2 < __privateGet(this, _r); s2++) __privateMethod(this, _r_instances, c_fn).call(this, r2);
+  }
+  concurrency() {
+    return __privateGet(this, _r);
+  }
+  postMessage(r2, s) {
+    __privateGet(this, _e)[++__privateWrapper(this, _s)._] || __privateSet(this, _s, 0), __privateGet(this, _e)[__privateGet(this, _s)].postMessage(r2, s);
+  }
+  addListener(r2) {
+    __privateGet(this, _t).push(r2);
+  }
+  removeListener(r2) {
+    for (const s in __privateGet(this, _t)) if (__privateGet(this, _t)[s] == r2) return void __privateGet(this, _t).splice(s, 1);
+  }
+}
+_r = new WeakMap();
+_s = new WeakMap();
+_e = new WeakMap();
+_t = new WeakMap();
+_r_instances = new WeakSet();
+c_fn = function(r2) {
+  const s = new r2();
+  s.onmessage = async (r3) => {
+    const e = [];
+    for (const s2 of __privateGet(this, _t)) e.push(s2(r3));
+    (await Promise.all(e)).forEach((r4) => {
+      r4 && s.postMessage(r4);
+    });
+  }, __privateGet(this, _e).push(s);
+};
+export {
+  r as w
+};