@xignature/docx-editor 1.0.0

package/dist/chunk-QGDML3KL.mjs

@@ -0,0 +1,258 @@
+// src/core/utils/processTemplate.ts
+import PizZip from "pizzip";
+import Docxtemplater from "docxtemplater";
+function processTemplate(buffer, variables, options = {}) {
+  const result = processTemplateDetailed(buffer, variables, options);
+  return result.buffer;
+}
+function processTemplateDetailed(buffer, variables, options = {}) {
+  const { nullGetter = "keep", linebreaks = true, delimiters } = options;
+  const warnings = [];
+  const replacedVariables = [];
+  const unreplacedVariables = [];
+  try {
+    const zip = new PizZip(buffer);
+    const doc = new Docxtemplater(zip, {
+      paragraphLoop: true,
+      linebreaks,
+      // Handle undefined tags based on option
+      nullGetter: (part) => {
+        const varName = part.value || "";
+        if (nullGetter === "error") {
+          throw new Error(`Undefined variable: ${varName}`);
+        }
+        if (nullGetter === "empty") {
+          unreplacedVariables.push(varName);
+          return "";
+        }
+        unreplacedVariables.push(varName);
+        return `{${varName}}`;
+      },
+      // Custom delimiters if specified (docxtemplater uses single braces by default)
+      delimiters: delimiters ? { start: delimiters.start || "{", end: delimiters.end || "}" } : void 0
+    });
+    Object.keys(variables).forEach((key) => {
+      if (variables[key] !== void 0 && variables[key] !== null) {
+        replacedVariables.push(key);
+      }
+    });
+    doc.setData(variables);
+    doc.render();
+    const outputBuffer = doc.getZip().generate({
+      type: "arraybuffer",
+      compression: "DEFLATE",
+      compressionOptions: { level: 6 }
+    });
+    return {
+      buffer: outputBuffer,
+      replacedVariables,
+      unreplacedVariables,
+      warnings
+    };
+  } catch (error) {
+    throw formatTemplateError(error);
+  }
+}
+function processTemplateAsBlob(buffer, variables, options = {}) {
+  const resultBuffer = processTemplate(buffer, variables, options);
+  return new Blob([resultBuffer], {
+    type: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+  });
+}
+function processTemplateAndDownload(buffer, variables, filename = "document", options = {}) {
+  const blob = processTemplateAsBlob(buffer, variables, options);
+  downloadBlob(blob, `${filename}.docx`);
+}
+function getTemplateTags(buffer) {
+  try {
+    const zip = new PizZip(buffer);
+    const doc = new Docxtemplater(zip, {
+      paragraphLoop: true,
+      linebreaks: true
+    });
+    const fullText = doc.getFullText();
+    return extractTagsFromText(fullText);
+  } catch (error) {
+    throw formatTemplateError(error);
+  }
+}
+function validateTemplate(buffer) {
+  const errors = [];
+  let tags = [];
+  try {
+    const zip = new PizZip(buffer);
+    const doc = new Docxtemplater(zip, {
+      paragraphLoop: true,
+      linebreaks: true
+    });
+    const fullText = doc.getFullText();
+    tags = extractTagsFromText(fullText);
+    const unclosedTags = findUnclosedTags(fullText);
+    for (const tag of unclosedTags) {
+      errors.push({
+        message: `Unclosed tag: ${tag}`,
+        variable: tag,
+        type: "parse"
+      });
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      tags
+    };
+  } catch (error) {
+    errors.push(formatTemplateError(error));
+    return {
+      valid: false,
+      errors,
+      tags
+    };
+  }
+}
+function getMissingVariables(tags, variables) {
+  return tags.filter(
+    (tag) => !(tag in variables) || variables[tag] === void 0 || variables[tag] === null
+  );
+}
+function previewTemplate(buffer, variables) {
+  try {
+    const zip = new PizZip(buffer);
+    const doc = new Docxtemplater(zip, {
+      paragraphLoop: true,
+      linebreaks: true,
+      nullGetter: (part) => {
+        const varName = part.value || "";
+        return `[${varName}]`;
+      }
+    });
+    doc.setData(variables);
+    doc.render();
+    return doc.getFullText();
+  } catch (error) {
+    throw formatTemplateError(error);
+  }
+}
+function extractTagsFromText(text) {
+  const tags = [];
+  const regex = /\{([^{}]+)\}/g;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    const tag = match[1].trim();
+    if (tag && !tags.includes(tag)) {
+      tags.push(tag);
+    }
+  }
+  return tags.sort();
+}
+function findUnclosedTags(text) {
+  const unclosed = [];
+  let depth = 0;
+  let currentTag = "";
+  for (const char of text) {
+    if (char === "{") {
+      depth++;
+      currentTag = "";
+    } else if (char === "}") {
+      depth--;
+      if (depth < 0) {
+        depth = 0;
+      }
+    } else if (depth > 0) {
+      currentTag += char;
+    }
+  }
+  if (depth > 0 && currentTag.trim()) {
+    unclosed.push(currentTag.trim());
+  }
+  return unclosed;
+}
+function isDocxTemplaterError(error) {
+  return "properties" in error && typeof error.properties === "object";
+}
+function formatTemplateError(error) {
+  if (error instanceof Error) {
+    if (isDocxTemplaterError(error) && error.properties?.errors) {
+      const firstError = error.properties.errors[0];
+      return {
+        message: firstError?.message || "Template processing error",
+        variable: firstError?.properties?.tag,
+        type: "render",
+        originalError: error
+      };
+    }
+    if (error.message.includes("undefined")) {
+      const match = error.message.match(/undefined (?:variable|tag):\s*(\S+)/i);
+      return {
+        message: error.message,
+        variable: match ? match[1] : void 0,
+        type: "undefined",
+        originalError: error
+      };
+    }
+    if (error.message.includes("parse") || error.message.includes("unclosed") || error.message.includes("syntax")) {
+      return {
+        message: error.message,
+        type: "parse",
+        originalError: error
+      };
+    }
+    return {
+      message: error.message,
+      type: "unknown",
+      originalError: error
+    };
+  }
+  return {
+    message: String(error),
+    type: "unknown"
+  };
+}
+function downloadBlob(blob, filename) {
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}
+function processTemplateAdvanced(buffer, data, options = {}) {
+  const { linebreaks = true, delimiters } = options;
+  try {
+    const zip = new PizZip(buffer);
+    const doc = new Docxtemplater(zip, {
+      paragraphLoop: true,
+      linebreaks,
+      delimiters: delimiters ? { start: delimiters.start || "{", end: delimiters.end || "}" } : void 0
+    });
+    doc.setData(data);
+    doc.render();
+    return doc.getZip().generate({
+      type: "arraybuffer",
+      compression: "DEFLATE"
+    });
+  } catch (error) {
+    throw formatTemplateError(error);
+  }
+}
+function createTemplateProcessor(defaultOptions = {}) {
+  return (buffer, variables) => {
+    return processTemplate(buffer, variables, defaultOptions);
+  };
+}
+var processTemplate_default = processTemplate;
+
+export {
+  processTemplate,
+  processTemplateDetailed,
+  processTemplateAsBlob,
+  processTemplateAndDownload,
+  getTemplateTags,
+  validateTemplate,
+  getMissingVariables,
+  previewTemplate,
+  processTemplateAdvanced,
+  createTemplateProcessor,
+  processTemplate_default
+};