template-replacement 3.0.8

package/.workflow/publish_to_npmjs.yml

@@ -0,0 +1,26 @@
+version: '1.0'
+name: publish_to_npmjs
+displayName: 发布到npmjs
+triggers:
+  trigger: auto
+  push:
+    branches:
+      precise:
+        - master
+variables:
+  global:
+    - NODE_AUTH_TOKEN
+stages:
+  - name: compile
+    displayName: 发布
+    strategy: naturally
+    trigger: auto
+    steps:
+      - step: build@nodejs
+        name: publish_to_npmjs
+        displayName: 发布到npmjs
+        nodeVersion: 20.10.0
+        commands:
+          - echo //registry.npmjs.org/:_authToken=${NODE_AUTH_TOKEN} >> .npmrc
+          - npm publish
+        strategy: {}

package/core/base.ts

@@ -0,0 +1,54 @@
+export interface Interface {
+    await(): Promise<Interface>
+    add_template(file: Uint8Array): Promise<number>
+    add_media(file: Uint8Array): Promise<string>
+    extract_one_file_variable_names(data: Uint8Array): Promise<(string)[]>
+    extract_variable_names(files: (Uint8Array)[]): Promise<(string)[]>
+    extract_one_file_medias(data: Uint8Array): Promise<any>
+    extract_medias(files: (Uint8Array)[]): Promise<any>
+}
+
+export default class implements Interface {
+    module: any
+    awaitInit: Promise<void>
+
+    constructor(init: Promise<any>, module: any) {
+        this.awaitInit = init
+        this.module = module
+    }
+
+    async await(): Promise<Interface> {
+        await this.awaitInit
+        return this
+    }
+
+    async add_template(file: Uint8Array): Promise<number> {
+        await this.awaitInit
+        return this.module.add_template(file)
+    }
+
+    async add_media(file: Uint8Array): Promise<string> {
+        await this.awaitInit
+        return this.module.add_media(file)
+    }
+
+    async extract_one_file_variable_names(data: Uint8Array): Promise<(string)[]> {
+        await this.awaitInit
+        return this.module.extract_one_file_variable_names(data)
+    }
+
+    async extract_variable_names(files: (Uint8Array)[]): Promise<(string)[]> {
+        await this.awaitInit
+        return this.module.extract_variable_names(files)
+    }
+
+    async extract_one_file_medias(data: Uint8Array): Promise<any> {
+        await this.awaitInit
+        return this.module.extract_one_file_medias(data)
+    }
+
+    async extract_medias(files: (Uint8Array)[]): Promise<any> {
+        await this.awaitInit
+        return this.module.extract_medias(files)
+    }
+}

package/core/general.ts

@@ -0,0 +1,13 @@
+import init, * as core from 'template-replacement-core-wasm'
+import base from './base'
+export * from 'template-replacement-core-wasm'
+
+let awaitInit: Promise<any> | undefined
+
+export default () => {
+    if (!awaitInit) {
+        awaitInit = init()
+    }
+    return new base(awaitInit, core)
+}
+

package/core/sign.ts

@@ -0,0 +1,13 @@
+import init, * as core from 'template-replacement-sign-core-wasm'
+import base from './base'
+export * from 'template-replacement-sign-core-wasm'
+
+let awaitInit: Promise<any> | undefined
+
+export default () => {
+    if (!awaitInit) {
+        awaitInit = init()
+    }
+    return new base(awaitInit, core)
+}
+

package/db/index.ts

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

package/db/indexedDBCache.ts

@@ -0,0 +1,129 @@
+
+type templateData<T> = {
+    url: string
+    data: T
+}
+
+export default class indexedDBCache {
+    _initFinishCallBackFuns?: Function[] = [] //初始化完成回调
+    _isInitFinish: boolean = false  //是否初始化完成
+
+    _db?: IDBDatabase //数据库
+    _dbName: string = 'template_replacement' //数据库名
+    _dbversion: number  = 1 //数据库版本
+    _cacheTableName: string = 'templates' //表名
+    _tableMap: any = {} //表配置
+
+
+    // 构造函数
+    constructor() {
+        this.initDB()
+    }
+
+    initDB(): Promise<any> {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(this._dbName, this._dbversion) // 打开数据库
+            // 数据库初始化成功
+            request.onsuccess = (event) => {
+                this._db = request.result
+                this._isInitFinish = true
+                if (this._initFinishCallBackFuns) {
+                    try {
+                        for (const fun of this._initFinishCallBackFuns) {
+                            fun()
+                        }
+                    } catch (error) {
+                    }
+                    this._initFinishCallBackFuns = undefined
+                }
+                resolve(event)
+            }
+            // 数据库初始化失败
+            request.onerror = (event) => {
+                console.error(event)
+                reject(event)
+            }
+            // 数据库初次创建或更新时会触发
+            request.onupgradeneeded = (event) => {
+                let db = request.result
+                if (!db.objectStoreNames.contains(this._cacheTableName)) {
+                    db.createObjectStore(this._cacheTableName, {
+                        keyPath: 'url', // 设置主键
+                    })
+                }
+                resolve(event)
+            }
+        })
+    }
+
+    async awaitInit(): Promise<void> {
+        if(this._isInitFinish || !this._initFinishCallBackFuns) {
+            return
+        }
+        await new Promise((resolve, reject) => {
+            this._initFinishCallBackFuns?.push(resolve)
+        })
+    }
+
+    closeDB(): void {
+        this._db?.close()
+    }
+
+    async store(mode?: IDBTransactionMode): Promise<IDBObjectStore> {
+        await this.awaitInit()
+        const db = this._db as IDBDatabase
+        const transaction = db.transaction(this._cacheTableName, mode)
+        return transaction.objectStore(this._cacheTableName)
+    }
+
+    /**
+     * @description : 更新数据
+     * @param        {Object} params 添加到数据库中的数据 { url: 文件地址, data: 文件blob }
+     * @return       {*}
+     */
+    putData<T>(params: templateData<T>): Promise<any> {
+        return new Promise(async (resolve, reject) => {
+            const response = (await this.store('readwrite')).put(params)
+            // 操作成功
+            response.onsuccess = (event) => {
+                resolve(event)
+            }
+            // 操作失败
+            response.onerror = (event) => {
+                reject(event)
+            }
+        })
+    }
+
+    // 通过主键读取数据
+    getDataByKey<T>(key: string): Promise<templateData<T>> {
+        return new Promise(async (resolve, reject) => {
+            // 通过主键读取数据
+            const request = (await this.store()).get(key)
+            // 操作成功
+            request.onsuccess = () => {
+                resolve(request.result)
+            }
+            // 操作失败
+            request.onerror = (event) => {
+                reject(event)
+            }
+        })
+    }
+
+    // 清空数据库数据
+    clearDB(): Promise<any> {
+        return new Promise(async (resolve, reject) => {
+            const response = (await this.store('readwrite')).clear()
+            // 操作成功
+            response.onsuccess = (event) => {
+                resolve(event)
+            }
+            // 操作失败
+            response.onerror = (event) => {
+                reject(event)
+            }
+        })
+    }
+
+}

package/dispatcher/general.ts

@@ -0,0 +1,6 @@
+import ReplaceInterface from '../replace/interface'
+import replace from '../dist/replace/general'
+
+export default (): ReplaceInterface => {
+    return new replace()
+}

package/dispatcher/sign.ts

@@ -0,0 +1,6 @@
+import ReplaceInterface from '../replace/interface'
+import replace from '../dist/replace/sign'
+
+export default (): ReplaceInterface => {
+    return new replace()
+}

package/dispatcher/workerGeneral.ts

@@ -0,0 +1,7 @@
+import ReplaceInterface from '../replace/interface'
+import WorkerReplace from '../worker/main'
+import replace from '../dist/main/general'
+
+export default (concurrency?: number): ReplaceInterface => {
+    return new WorkerReplace(new replace(concurrency))
+}

package/dispatcher/workerSign.ts

@@ -0,0 +1,7 @@
+import ReplaceInterface from '../replace/interface'
+import WorkerReplace from '../worker/main'
+import replace from '../dist/main/sign'
+
+export default (concurrency?: number): ReplaceInterface => {
+    return new WorkerReplace(new replace(concurrency))
+}

package/dist/base-CC-6cmrq.js

@@ -0,0 +1,189 @@
+var m = (i) => {
+  throw TypeError(i);
+};
+var f = (i, t, a) => t.has(i) || m("Cannot " + a);
+var c = (i, t, a) => (f(i, t, "read from private field"), a ? a.call(i) : t.get(i)), _ = (i, t, a) => t.has(i) ? m("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(i) : t.set(i, a), y = (i, t, a, e) => (f(i, t, "write to private field"), e ? e.call(i, a) : t.set(i, a), a);
+class b {
+  //表配置
+  // 构造函数
+  constructor() {
+    this._initFinishCallBackFuns = [], this._isInitFinish = !1, this._dbName = "template_replacement", this._dbversion = 1, this._cacheTableName = "templates", this._tableMap = {}, this.initDB();
+  }
+  initDB() {
+    return new Promise((t, a) => {
+      const e = indexedDB.open(this._dbName, this._dbversion);
+      e.onsuccess = (s) => {
+        if (this._db = e.result, this._isInitFinish = !0, this._initFinishCallBackFuns) {
+          try {
+            for (const n of this._initFinishCallBackFuns)
+              n();
+          } catch {
+          }
+          this._initFinishCallBackFuns = void 0;
+        }
+        t(s);
+      }, e.onerror = (s) => {
+        console.error(s), a(s);
+      }, e.onupgradeneeded = (s) => {
+        let n = e.result;
+        n.objectStoreNames.contains(this._cacheTableName) || n.createObjectStore(this._cacheTableName, {
+          keyPath: "url"
+          // 设置主键
+        }), t(s);
+      };
+    });
+  }
+  async awaitInit() {
+    this._isInitFinish || !this._initFinishCallBackFuns || await new Promise((t, a) => {
+      var e;
+      (e = this._initFinishCallBackFuns) == null || e.push(t);
+    });
+  }
+  closeDB() {
+    var t;
+    (t = this._db) == null || t.close();
+  }
+  async store(t) {
+    return await this.awaitInit(), this._db.transaction(this._cacheTableName, t).objectStore(this._cacheTableName);
+  }
+  /**
+   * @description : 更新数据
+   * @param        {Object} params 添加到数据库中的数据 { url: 文件地址, data: 文件blob }
+   * @return       {*}
+   */
+  putData(t) {
+    return new Promise(async (a, e) => {
+      const s = (await this.store("readwrite")).put(t);
+      s.onsuccess = (n) => {
+        a(n);
+      }, s.onerror = (n) => {
+        e(n);
+      };
+    });
+  }
+  // 通过主键读取数据
+  getDataByKey(t) {
+    return new Promise(async (a, e) => {
+      const s = (await this.store()).get(t);
+      s.onsuccess = () => {
+        a(s.result);
+      }, s.onerror = (n) => {
+        e(n);
+      };
+    });
+  }
+  // 清空数据库数据
+  clearDB() {
+    return new Promise(async (t, a) => {
+      const e = (await this.store("readwrite")).clear();
+      e.onsuccess = (s) => {
+        t(s);
+      }, e.onerror = (s) => {
+        a(s);
+      };
+    });
+  }
+}
+new b();
+var w = /* @__PURE__ */ ((i) => (i.word = "word", i.excel = "excel", i.unknown = "unknown", i))(w || {}), o, u;
+class x {
+  constructor(t) {
+    _(this, o, []);
+    _(this, u);
+    y(this, u, t);
+  }
+  addTempFile(t) {
+    c(this, o).push(t);
+  }
+  clear() {
+    c(this, o).length = 0;
+  }
+  async extractVariables(t) {
+    t || (t = c(this, o));
+    const a = {}, e = [];
+    for (const s of t)
+      e.push(new Promise(async (n, d) => {
+        const r = await s.getBuffer();
+        r && await s.type() !== w.unknown && (a[s.name] = await c(this, u).extract_one_file_variable_names(r)), n();
+      }));
+    return await Promise.all(e), a;
+  }
+  async extractMedias(t) {
+    t || (t = c(this, o));
+    const a = {}, e = [];
+    for (const s of t)
+      e.push(new Promise(async (n, d) => {
+        const r = await s.getBuffer();
+        if (r && await s.type() !== w.unknown) {
+          let h = await c(this, u).extract_one_file_medias(r);
+          a[s.name] = [], h && Array.isArray(h) && h.forEach((l) => {
+            l.id && l.data && a[s.name].push({
+              id: l.id,
+              data: new Uint8Array(l.data)
+            });
+          });
+        }
+        n();
+      }));
+    return await Promise.all(e), a;
+  }
+  async handle(t, a) {
+    return [];
+  }
+  async sign(t) {
+    return "";
+  }
+  async execute(t, a) {
+    a || (a = c(this, o));
+    const e = {
+      names: [],
+      uint8Arrays: []
+    }, s = [];
+    for (const r of a)
+      s.push(new Promise(async (h, l) => {
+        h(r.getBuffer());
+      }));
+    await Promise.all(s);
+    for (const r of a)
+      r.uint8Array && (e.names.push(r.name), e.uint8Arrays.push(r.uint8Array));
+    if (!e.uint8Arrays.length)
+      return {};
+    const n = await this.handle(t, e.uint8Arrays);
+    e.uint8Arrays.length;
+    const d = {};
+    return n.forEach((r, h) => {
+      r.length && (d[e.names[h]] = r);
+    }), d;
+  }
+}
+o = new WeakMap(), u = new WeakMap();
+class B {
+  constructor(t, a) {
+    this.awaitInit = t, this.module = a;
+  }
+  async await() {
+    return await this.awaitInit, this;
+  }
+  async add_template(t) {
+    return await this.awaitInit, this.module.add_template(t);
+  }
+  async add_media(t) {
+    return await this.awaitInit, this.module.add_media(t);
+  }
+  async extract_one_file_variable_names(t) {
+    return await this.awaitInit, this.module.extract_one_file_variable_names(t);
+  }
+  async extract_variable_names(t) {
+    return await this.awaitInit, this.module.extract_variable_names(t);
+  }
+  async extract_one_file_medias(t) {
+    return await this.awaitInit, this.module.extract_one_file_medias(t);
+  }
+  async extract_medias(t) {
+    return await this.awaitInit, this.module.extract_medias(t);
+  }
+}
+export {
+  x as B,
+  B as b
+};

package/dist/general.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/index-BkwrGCka.js

@@ -0,0 +1,61 @@
+var g = (r) => {
+  throw TypeError(r);
+};
+var p = (r, s, t) => s.has(r) || g("Cannot " + t);
+var e = (r, s, t) => (p(r, s, "read from private field"), t ? t.call(r) : s.get(r)), n = (r, s, t) => s.has(r) ? g("Cannot add the same private member more than once") : s instanceof WeakSet ? s.add(r) : s.set(r, t), a = (r, s, t, o) => (p(r, s, "write to private field"), o ? o.call(r, t) : s.set(r, t), t), k = (r, s, t) => (p(r, s, "access private method"), t);
+var l = (r, s, t, o) => ({
+  set _(f) {
+    a(r, s, f, t);
+  },
+  get _() {
+    return e(r, s, o);
+  }
+});
+var i, c, u, h, d, y;
+class v {
+  constructor(s, t) {
+    n(this, d);
+    n(this, i);
+    n(this, c, 0);
+    n(this, u, []);
+    n(this, h, []);
+    if (a(this, i, Number(t)), !e(this, i) || e(this, i) < 1)
+      try {
+        a(this, i, navigator.hardwareConcurrency < 8 ? navigator.hardwareConcurrency : 8);
+      } catch {
+      }
+    (!e(this, i) || e(this, i) < 1) && a(this, i, 1);
+    for (let o = 0; o < e(this, i); o++)
+      k(this, d, y).call(this, s);
+  }
+  concurrency() {
+    return e(this, i);
+  }
+  postMessage(s, t) {
+    e(this, u)[++l(this, c)._] || a(this, c, 0), e(this, u)[e(this, c)].postMessage(s, t);
+  }
+  addListener(s) {
+    e(this, h).push(s);
+  }
+  removeListener(s) {
+    for (const t in e(this, h))
+      if (e(this, h)[t] == s) {
+        e(this, h).splice(t, 1);
+        return;
+      }
+  }
+}
+i = new WeakMap(), c = new WeakMap(), u = new WeakMap(), h = new WeakMap(), d = new WeakSet(), y = function(s) {
+  const t = new s();
+  t.onmessage = async (o) => {
+    const f = [];
+    for (const w of e(this, h))
+      f.push(w(o));
+    (await Promise.all(f)).forEach((w) => {
+      w && t.postMessage(w);
+    });
+  }, e(this, u).push(t);
+};
+export {
+  v as w
+};