@vdhewei/xlsx-template-lib 1.4.3 → 1.5.0

package/dist/bin.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   ExprResolver
-} from "./chunk-2UQSPJKC.mjs";
+} from "./chunk-TC2FHOAF.mjs";
 
 // src/bin.ts
 import chalk from "chalk";

package/dist/{chunk-2UQSPJKC.mjs → chunk-TC2FHOAF.mjs}

@@ -3982,6 +3982,170 @@ var generateCommandsXlsxTemplateWithCompile = async function(data, values, compi
   await w.substituteAll(values);
   return w.generate(options);
 };
+var compileAll = async (buf, compileOpts, renderData) => {
+  if (compileOpts === void 0 || compileOpts.sheetName === "") {
+    return buf;
+  }
+  const result = await ExprResolver.compile(buf, compileOpts.sheetName, compileOpts);
+  if (result.errs !== void 0 && result.errs.length > 0) {
+    throw result.errs[0];
+  }
+  if (compileOpts.remove !== void 0 && compileOpts.remove === true) {
+    result.workbook = ExprResolver.removeUnExportSheets(result.workbook, compileOpts);
+  }
+  if (renderData !== void 0) {
+    autoRegisterAlias(renderData, result.configure);
+  }
+  return await ExprResolver.toBuffer(result.workbook);
+};
+
+// src/biz.ts
+import { extname as extname2 } from "path";
+import { clone } from "lodash";
+import AdmZip from "adm-zip";
+var XlsxRender = class _XlsxRender extends Workbook {
+  constructor(option) {
+    super(option);
+  }
+  static async create(data, option) {
+    const w = await super.parse(data, option);
+    w.setQueryFunctionHandler(commandExtendQuery);
+    const app = new _XlsxRender(option);
+    Object.assign(app, { ...w });
+    return app;
+  }
+  async render(values, sheetName) {
+    await this.substitute(sheetName, values);
+  }
+  getSheets() {
+    return this.sheets;
+  }
+};
+var ZipXlsxTemplateApp = class _ZipXlsxTemplateApp {
+  constructor(data) {
+    this.records = /* @__PURE__ */ new Map();
+    this.zipBuffer = data;
+    if (data !== void 0) {
+      this.xlsxEntries = this.parse(data);
+    }
+  }
+  loadZipBuffer(data) {
+    this.zipBuffer = data;
+    this.zip = new AdmZip(data);
+    this.xlsxEntries = this.parse(data);
+    return this;
+  }
+  parse(data) {
+    const zip = new AdmZip(data);
+    const result = /* @__PURE__ */ new Map();
+    const entries = zip.getEntries();
+    for (let fd of entries) {
+      if (fd.isDirectory) {
+        continue;
+      }
+      let ext = extname2(fd.entryName).substring(1).toLowerCase();
+      if (ext !== "xlsx") {
+        continue;
+      }
+      result.set(fd.entryName, fd.getData());
+    }
+    this.zip = zip;
+    return result;
+  }
+  getEntries() {
+    if (this.xlsxEntries !== void 0 && this.xlsxEntries.size > 0) {
+      return this.xlsxEntries;
+    } else {
+      if (this.zipBuffer !== void 0) {
+        return this.parse(this.zipBuffer);
+      }
+    }
+    return /* @__PURE__ */ new Map();
+  }
+  static async compileAll(files, renderData, compileOpts) {
+    const records = /* @__PURE__ */ new Map();
+    if (compileOpts !== void 0 && (compileOpts.sheetName === void 0 || compileOpts.sheetName === "")) {
+      compileOpts.sheetName = compileRuleSheetName;
+    }
+    let values = clone(renderData);
+    for (let [key, buf] of files.entries()) {
+      buf = await compileAll(buf, clone(compileOpts), clone(values));
+      records.set(key, buf);
+    }
+    return records;
+  }
+  async substituteAll(renderData, compileOpts, renderOpts) {
+    const files = await _ZipXlsxTemplateApp.compileAll(this.xlsxEntries, renderData, compileOpts);
+    for (const [k, buf] of files.entries()) {
+      const xlsx = await XlsxRender.create(buf, renderOpts);
+      await xlsx.substituteAll(renderData);
+      this.records.set(k, xlsx);
+    }
+    return this;
+  }
+  async generate(options) {
+    if (this.records === void 0 || this.records.size <= 0) {
+      return this.zipBuffer;
+    }
+    if (this.zip === void 0) {
+      this.zip = new AdmZip();
+    }
+    if (options === void 0 || options === null) {
+      options = {
+        type: "nodebuffer" /* NodeBuffer */,
+        compression: "DEFLATE",
+        compressionOptions: {
+          level: 9
+        }
+      };
+    }
+    for (const [key, xlsx] of this.records) {
+      const buf = await xlsx.generate(options);
+      let entry = this.zip.getEntry(key);
+      if (entry !== null) {
+        entry.setData(Buffer.from(buf));
+      } else {
+        this.zip.addFile(key, Buffer.from(buf));
+      }
+    }
+    return this.zip.toBuffer();
+  }
+  static async compileTo(data, opts, values) {
+    const zip = new AdmZip(data);
+    const entries = zip.getEntries();
+    let files = /* @__PURE__ */ new Map();
+    if (values === void 0) {
+      values = /* @__PURE__ */ new Map();
+    }
+    for (let fd of entries) {
+      if (fd.isDirectory) {
+        continue;
+      }
+      let ext = extname2(fd.entryName).substring(1).toLowerCase();
+      if (ext !== "xlsx") {
+        continue;
+      }
+      let buf = fd.getData();
+      if (opts.checker !== void 0) {
+        await opts.checker(buf, opts.options, values, opts.fileName || void 0);
+      }
+      files.set(fd.entryName, buf);
+    }
+    const compileOpts = new RuleMapOptions();
+    compileOpts.remove = true;
+    if (files.size > 0) {
+      files = await _ZipXlsxTemplateApp.compileAll(files, values, compileOpts);
+    } else {
+      throw new Error(`empty xlsx file zip file`);
+    }
+    if (files.size > 0) {
+      for (const [k, data2] of files.entries()) {
+        zip.getEntry(k).setData(data2);
+      }
+    }
+    return zip.toBuffer();
+  }
+};
 
 export {
   BufferType,
@@ -4027,6 +4191,9 @@ export {
   compileRuleSheetName,
   mergeMap,
   autoRegisterAlias,
-  generateCommandsXlsxTemplateWithCompile
+  generateCommandsXlsxTemplateWithCompile,
+  compileAll,
+  XlsxRender,
+  ZipXlsxTemplateApp
 };
-//# sourceMappingURL=chunk-2UQSPJKC.mjs.map
+//# sourceMappingURL=chunk-TC2FHOAF.mjs.map