mintdoc 0.1.0

package/dist/index.mjs

@@ -0,0 +1,447 @@
+// src/core/lexer.ts
+function tokenize(xml) {
+  const tokens = [];
+  const tagRegex = /\{([^}]+)\}/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = tagRegex.exec(xml)) !== null) {
+    if (match.index > lastIndex) {
+      tokens.push({ type: "xml", content: xml.slice(lastIndex, match.index) });
+    }
+    const raw = match[0];
+    const inner = match[1].trim();
+    tokens.push(classifyTag(inner, raw));
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < xml.length) {
+    tokens.push({ type: "xml", content: xml.slice(lastIndex) });
+  }
+  return tokens;
+}
+function classifyTag(inner, raw) {
+  if (inner === ":else") {
+    return { type: "condition-else", raw };
+  }
+  if (inner === "/if") {
+    return { type: "condition-close", raw };
+  }
+  if (inner.startsWith("/")) {
+    return { type: "loop-close", name: inner.slice(1).trim(), raw };
+  }
+  if (inner.startsWith("#if ")) {
+    return { type: "condition-open", expression: inner.slice(4).trim(), raw };
+  }
+  if (inner.startsWith("#")) {
+    return { type: "loop-open", name: inner.slice(1).trim(), raw };
+  }
+  const parts = inner.split("|").map((p) => p.trim());
+  const name = parts[0];
+  const formatters = parts.slice(1);
+  return { type: "variable", name, formatters, raw };
+}
+
+// src/core/parser.ts
+function parse(tokens) {
+  const { nodes, index } = parseNodes(tokens, 0, null);
+  if (index < tokens.length) {
+    const unexpected = tokens[index];
+    throw new MintdocParseError(
+      `Unexpected closing tag "${unexpected.raw ?? ""}" without a matching opening tag.`
+    );
+  }
+  return nodes;
+}
+function parseNodes(tokens, start, closingTag) {
+  const nodes = [];
+  let i = start;
+  while (i < tokens.length) {
+    const token = tokens[i];
+    switch (token.type) {
+      case "xml":
+        nodes.push({ type: "text", content: token.content });
+        i++;
+        break;
+      case "variable":
+        nodes.push({
+          type: "variable",
+          name: token.name,
+          formatters: token.formatters
+        });
+        i++;
+        break;
+      case "loop-open": {
+        const loopName = token.name;
+        const children = parseNodes(tokens, i + 1, loopName);
+        const closer = tokens[children.index];
+        if (!closer || closer.type !== "loop-close") {
+          throw new MintdocParseError(
+            `Unclosed loop "{#${loopName}}". Add a matching "{/${loopName}}" tag.`
+          );
+        }
+        if (closer.type === "loop-close" && closer.name !== loopName) {
+          throw new MintdocParseError(
+            `Mismatched loop tags: opened "{#${loopName}}" but closed with "{/${closer.name}}".`
+          );
+        }
+        nodes.push({ type: "loop", name: loopName, children: children.nodes });
+        i = children.index + 1;
+        break;
+      }
+      case "condition-open": {
+        const expression = token.expression;
+        const trueBranch = parseNodes(tokens, i + 1, "if");
+        let trueChildren = trueBranch.nodes;
+        let falseChildren = [];
+        let endIndex = trueBranch.index;
+        const next = tokens[endIndex];
+        if (next && next.type === "condition-else") {
+          const falseBranch = parseNodes(tokens, endIndex + 1, "if");
+          falseChildren = falseBranch.nodes;
+          endIndex = falseBranch.index;
+        }
+        const closerToken = tokens[endIndex];
+        if (!closerToken || closerToken.type !== "condition-close") {
+          throw new MintdocParseError(
+            `Unclosed condition "{#if ${expression}}". Add a matching "{/if}" tag.`
+          );
+        }
+        nodes.push({
+          type: "condition",
+          expression,
+          trueChildren,
+          falseChildren
+        });
+        i = endIndex + 1;
+        break;
+      }
+      // Closing / else tokens signal the end of the current nesting level
+      case "loop-close":
+      case "condition-close":
+      case "condition-else":
+        return { nodes, index: i };
+      default:
+        i++;
+    }
+  }
+  if (closingTag !== null) {
+    throw new MintdocParseError(
+      `Unexpected end of template. Missing closing tag for "{#${closingTag}}".`
+    );
+  }
+  return { nodes, index: i };
+}
+var MintdocParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MintdocParseError";
+  }
+};
+
+// src/utils/expressions.ts
+function resolveValue(path, data) {
+  if (data == null || typeof data !== "object") {
+    return path === "." ? data : void 0;
+  }
+  if (path === ".") {
+    const record = data;
+    return "." in record ? record["."] : data;
+  }
+  const parts = path.split(".");
+  let current = data;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function isTruthy(value) {
+  if (Array.isArray(value)) return value.length > 0;
+  return Boolean(value);
+}
+
+// src/utils/xml.ts
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function mergeRuns(xml) {
+  const wtRegex = /<w:t(\s[^>]*)?>([^]*?)<\/w:t>/g;
+  const matches = [];
+  let m;
+  while ((m = wtRegex.exec(xml)) !== null) {
+    matches.push({
+      fullMatch: m[0],
+      attrs: m[1] || "",
+      content: m[2],
+      index: m.index
+    });
+  }
+  if (matches.length === 0) return xml;
+  const newContents = /* @__PURE__ */ new Map();
+  let i = 0;
+  while (i < matches.length) {
+    const content = newContents.get(i) ?? matches[i].content;
+    const openCount = countChar(content, "{");
+    const closeCount = countChar(content, "}");
+    if (openCount > closeCount) {
+      let merged = content;
+      let j = i + 1;
+      while (j < matches.length) {
+        const nextContent = newContents.get(j) ?? matches[j].content;
+        merged += nextContent;
+        newContents.set(j, "");
+        const opens = countChar(merged, "{");
+        const closes = countChar(merged, "}");
+        if (closes >= opens) break;
+        j++;
+      }
+      newContents.set(i, merged);
+    }
+    i++;
+  }
+  if (newContents.size === 0) return xml;
+  let result = "";
+  let cursor = 0;
+  for (let k = 0; k < matches.length; k++) {
+    const mt = matches[k];
+    if (!newContents.has(k)) {
+      result += xml.slice(cursor, mt.index + mt.fullMatch.length);
+      cursor = mt.index + mt.fullMatch.length;
+      continue;
+    }
+    result += xml.slice(cursor, mt.index);
+    const attrs = mt.attrs;
+    const preserveSpace = attrs.includes('xml:space="preserve"') ? "" : ' xml:space="preserve"';
+    result += `<w:t${attrs}${preserveSpace}>${newContents.get(k)}</w:t>`;
+    cursor = mt.index + mt.fullMatch.length;
+  }
+  result += xml.slice(cursor);
+  return result;
+}
+function promoteTableLoopTags(xml) {
+  const trRegex = /<w:tr\b[^>]*>[\s\S]*?<\/w:tr>/g;
+  return xml.replace(trRegex, (rowXml) => {
+    const openRegex = /\{#(?!if[\s}])([\w.]+)\}/g;
+    const closeRegex = /\{\/(?!if\})([\w.]+)\}/g;
+    const opens = [];
+    const closes = [];
+    let match;
+    while ((match = openRegex.exec(rowXml)) !== null) opens.push(match[1]);
+    while ((match = closeRegex.exec(rowXml)) !== null) closes.push(match[1]);
+    if (opens.length === 1 && closes.length === 1 && opens[0] === closes[0]) {
+      const name = opens[0];
+      const cleaned = rowXml.replace(`{#${name}}`, "").replace(`{/${name}}`, "");
+      return `{#${name}}${cleaned}{/${name}}`;
+    }
+    return rowXml;
+  });
+}
+function countChar(str, char) {
+  let count = 0;
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === char) count++;
+  }
+  return count;
+}
+
+// src/core/renderer.ts
+function render(nodes, data, formatters) {
+  let output = "";
+  for (const node of nodes) {
+    switch (node.type) {
+      case "text":
+        output += node.content;
+        break;
+      case "variable":
+        output += renderVariable(node.name, node.formatters, data, formatters);
+        break;
+      case "loop":
+        output += renderLoop(node.name, node.children, data, formatters);
+        break;
+      case "condition":
+        output += renderCondition(
+          node.expression,
+          node.trueChildren,
+          node.falseChildren,
+          data,
+          formatters
+        );
+        break;
+    }
+  }
+  return output;
+}
+function renderVariable(name, fmtNames, data, formatters) {
+  let value = resolveValue(name, data);
+  for (const fmtName of fmtNames) {
+    const fn = formatters[fmtName];
+    if (!fn) {
+      throw new MintdocRenderError(
+        `Unknown formatter "${fmtName}". Check your template and available formatters.`
+      );
+    }
+    value = fn(value);
+  }
+  if (value == null) return "";
+  return escapeXml(String(value));
+}
+function renderLoop(name, children, data, formatters) {
+  const collection = resolveValue(name, data);
+  if (!Array.isArray(collection)) {
+    if (collection == null) return "";
+    throw new MintdocRenderError(
+      `Loop "{#${name}}" expects an array but received ${typeof collection}.`
+    );
+  }
+  let output = "";
+  for (let i = 0; i < collection.length; i++) {
+    const item = collection[i];
+    const scope = createLoopScope(data, item, i, collection.length);
+    output += render(children, scope, formatters);
+  }
+  return output;
+}
+function renderCondition(expression, trueChildren, falseChildren, data, formatters) {
+  const value = resolveValue(expression, data);
+  if (isTruthy(value)) {
+    return render(trueChildren, data, formatters);
+  }
+  return render(falseChildren, data, formatters);
+}
+function createLoopScope(parentData, item, index, length) {
+  const base = {
+    ...parentData,
+    ".": item,
+    "@index": index,
+    "@first": index === 0,
+    "@last": index === length - 1
+  };
+  if (item !== null && typeof item === "object" && !Array.isArray(item)) {
+    Object.assign(base, item);
+  }
+  return base;
+}
+var MintdocRenderError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MintdocRenderError";
+  }
+};
+
+// src/utils/zip.ts
+import PizZip from "pizzip";
+function openZip(buffer) {
+  return new PizZip(buffer);
+}
+function getFile(zip, path) {
+  const file = zip.file(path);
+  if (!file) return null;
+  return file.asText();
+}
+function setFile(zip, path, content) {
+  zip.file(path, content);
+}
+function generateZip(zip) {
+  return zip.generate({
+    type: "nodebuffer",
+    compression: "DEFLATE",
+    compressionOptions: { level: 9 }
+  });
+}
+
+// src/formats/docx.ts
+var TEMPLATE_TARGETS = [
+  "word/document.xml",
+  // Headers & footers (Word uses numbered names)
+  ...Array.from({ length: 3 }, (_, i) => `word/header${i + 1}.xml`),
+  ...Array.from({ length: 3 }, (_, i) => `word/footer${i + 1}.xml`)
+];
+function processDocx(buffer, data, formatters) {
+  const zip = openZip(buffer);
+  for (const target of TEMPLATE_TARGETS) {
+    const xml = getFile(zip, target);
+    if (xml === null) continue;
+    const processed = processXml(xml, data, formatters);
+    setFile(zip, target, processed);
+  }
+  return generateZip(zip);
+}
+function processXml(xml, data, formatters) {
+  const merged = mergeRuns(xml);
+  const promoted = promoteTableLoopTags(merged);
+  const tokens = tokenize(promoted);
+  const ast = parse(tokens);
+  return render(ast, data, formatters);
+}
+
+// src/plugins/formatters.ts
+var builtinFormatters = {
+  uppercase: (value) => String(value ?? "").toUpperCase(),
+  lowercase: (value) => String(value ?? "").toLowerCase(),
+  capitalize: (value) => {
+    const str = String(value ?? "");
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+};
+
+// src/plugins/plugin-api.ts
+function collectFormatters(plugins, extraFormatters) {
+  const merged = { ...builtinFormatters };
+  for (const plugin of plugins) {
+    if (plugin.formatters) {
+      Object.assign(merged, plugin.formatters);
+    }
+  }
+  if (extraFormatters) {
+    Object.assign(merged, extraFormatters);
+  }
+  return merged;
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+var Mintdoc = class {
+  constructor() {
+    this.plugins = [];
+    this.extraFormatters = {};
+  }
+  /**
+   * Register a plugin (adds formatters, tag handlers, etc.).
+   */
+  use(plugin) {
+    this.plugins.push(plugin);
+    return this;
+  }
+  /**
+   * Register one or more custom formatters.
+   */
+  addFormatters(formatters) {
+    Object.assign(this.extraFormatters, formatters);
+    return this;
+  }
+  /**
+   * Render a .docx template with the given data.
+   *
+   * @param template - The .docx file as a Buffer, ArrayBuffer or Uint8Array.
+   * @param data     - The data object to inject into the template.
+   * @returns A Buffer containing the rendered .docx file.
+   */
+  render(template, data) {
+    const formatters = collectFormatters(this.plugins, this.extraFormatters);
+    return processDocx(template, data, formatters);
+  }
+};
+function render2(template, data, options) {
+  const formatters = collectFormatters(
+    options?.plugins ?? [],
+    options?.formatters
+  );
+  return processDocx(template, data, formatters);
+}
+export {
+  Mintdoc,
+  MintdocParseError,
+  MintdocRenderError,
+  VERSION,
+  render2 as render
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/lexer.ts","../src/core/parser.ts","../src/utils/expressions.ts","../src/utils/xml.ts","../src/core/renderer.ts","../src/utils/zip.ts","../src/formats/docx.ts","../src/plugins/formatters.ts","../src/plugins/plugin-api.ts","../src/index.ts"],"sourcesContent":["import type { Token } from \"./types\";\n\n/**\n * Tokenize an XML string that has already been through run-merging.\n *\n * Splits the XML into a flat list of tokens:\n *   - `xml`             — raw XML content (not a template tag)\n *   - `variable`        — {varName} or {varName | formatter}\n *   - `loop-open`       — {#collection}\n *   - `loop-close`      — {/collection}\n *   - `condition-open`  — {#if expression}\n *   - `condition-else`  — {:else}\n *   - `condition-close` — {/if}\n */\nexport function tokenize(xml: string): Token[] {\n  const tokens: Token[] = [];\n  const tagRegex = /\\{([^}]+)\\}/g;\n  let lastIndex = 0;\n  let match: RegExpExecArray | null;\n\n  while ((match = tagRegex.exec(xml)) !== null) {\n    // Push any XML content before this tag\n    if (match.index > lastIndex) {\n      tokens.push({ type: \"xml\", content: xml.slice(lastIndex, match.index) });\n    }\n\n    const raw = match[0];\n    const inner = match[1].trim();\n    tokens.push(classifyTag(inner, raw));\n\n    lastIndex = match.index + match[0].length;\n  }\n\n  // Push any remaining XML after the last tag\n  if (lastIndex < xml.length) {\n    tokens.push({ type: \"xml\", content: xml.slice(lastIndex) });\n  }\n\n  return tokens;\n}\n\n/**\n * Classify the inner content of a template tag into the correct token type.\n */\nfunction classifyTag(inner: string, raw: string): Token {\n  // {:else}\n  if (inner === \":else\") {\n    return { type: \"condition-else\", raw };\n  }\n\n  // {/if}\n  if (inner === \"/if\") {\n    return { type: \"condition-close\", raw };\n  }\n\n  // {/collection}\n  if (inner.startsWith(\"/\")) {\n    return { type: \"loop-close\", name: inner.slice(1).trim(), raw };\n  }\n\n  // {#if expression}\n  if (inner.startsWith(\"#if \")) {\n    return { type: \"condition-open\", expression: inner.slice(4).trim(), raw };\n  }\n\n  // {#collection}\n  if (inner.startsWith(\"#\")) {\n    return { type: \"loop-open\", name: inner.slice(1).trim(), raw };\n  }\n\n  // {variable | formatter1 | formatter2}\n  const parts = inner.split(\"|\").map((p) => p.trim());\n  const name = parts[0];\n  const formatters = parts.slice(1);\n\n  return { type: \"variable\", name, formatters, raw };\n}\n","import type { ASTNode, Token } from \"./types\";\n\n/**\n * Parse a flat token list into an AST (tree of nodes).\n *\n * Structural tags ({#loop}, {#if}, {:else}, {/…}) define nesting.\n * Throws descriptive errors on mismatched or unclosed tags.\n */\nexport function parse(tokens: Token[]): ASTNode[] {\n  const { nodes, index } = parseNodes(tokens, 0, null);\n\n  if (index < tokens.length) {\n    const unexpected = tokens[index];\n    throw new MintdocParseError(\n      `Unexpected closing tag \"${(unexpected as { raw?: string }).raw ?? \"\"}\" without a matching opening tag.`,\n    );\n  }\n\n  return nodes;\n}\n\n// ---------------------------------------------------------------------------\n// Internal recursive descent parser\n// ---------------------------------------------------------------------------\n\ninterface ParseResult {\n  nodes: ASTNode[];\n  index: number;\n}\n\nfunction parseNodes(\n  tokens: Token[],\n  start: number,\n  closingTag: string | null,\n): ParseResult {\n  const nodes: ASTNode[] = [];\n  let i = start;\n\n  while (i < tokens.length) {\n    const token = tokens[i];\n\n    switch (token.type) {\n      case \"xml\":\n        nodes.push({ type: \"text\", content: token.content });\n        i++;\n        break;\n\n      case \"variable\":\n        nodes.push({\n          type: \"variable\",\n          name: token.name,\n          formatters: token.formatters,\n        });\n        i++;\n        break;\n\n      case \"loop-open\": {\n        const loopName = token.name;\n        const children = parseNodes(tokens, i + 1, loopName);\n\n        // Verify the closing tag matches\n        const closer = tokens[children.index];\n        if (!closer || closer.type !== \"loop-close\") {\n          throw new MintdocParseError(\n            `Unclosed loop \"{#${loopName}}\". Add a matching \"{/${loopName}}\" tag.`,\n          );\n        }\n        if (closer.type === \"loop-close\" && closer.name !== loopName) {\n          throw new MintdocParseError(\n            `Mismatched loop tags: opened \"{#${loopName}}\" but closed with \"{/${closer.name}}\".`,\n          );\n        }\n\n        nodes.push({ type: \"loop\", name: loopName, children: children.nodes });\n        i = children.index + 1;\n        break;\n      }\n\n      case \"condition-open\": {\n        const expression = token.expression;\n        const trueBranch = parseNodes(tokens, i + 1, \"if\");\n\n        let trueChildren = trueBranch.nodes;\n        let falseChildren: ASTNode[] = [];\n        let endIndex = trueBranch.index;\n\n        const next = tokens[endIndex];\n\n        if (next && next.type === \"condition-else\") {\n          // Parse the else branch\n          const falseBranch = parseNodes(tokens, endIndex + 1, \"if\");\n          falseChildren = falseBranch.nodes;\n          endIndex = falseBranch.index;\n        }\n\n        const closerToken = tokens[endIndex];\n        if (!closerToken || closerToken.type !== \"condition-close\") {\n          throw new MintdocParseError(\n            `Unclosed condition \"{#if ${expression}}\". Add a matching \"{/if}\" tag.`,\n          );\n        }\n\n        nodes.push({\n          type: \"condition\",\n          expression,\n          trueChildren,\n          falseChildren,\n        });\n        i = endIndex + 1;\n        break;\n      }\n\n      // Closing / else tokens signal the end of the current nesting level\n      case \"loop-close\":\n      case \"condition-close\":\n      case \"condition-else\":\n        return { nodes, index: i };\n\n      default:\n        i++;\n    }\n  }\n\n  // If we expected a closing tag but reached end of tokens\n  if (closingTag !== null) {\n    throw new MintdocParseError(\n      `Unexpected end of template. Missing closing tag for \"{#${closingTag}}\".`,\n    );\n  }\n\n  return { nodes, index: i };\n}\n\n// ---------------------------------------------------------------------------\n// Error class\n// ---------------------------------------------------------------------------\n\nexport class MintdocParseError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"MintdocParseError\";\n  }\n}\n","/**\n * Resolve a dot-notation path against a data object.\n *\n * Examples:\n *   resolveValue(\"name\", { name: \"Alice\" }) → \"Alice\"\n *   resolveValue(\"company.name\", { company: { name: \"Acme\" } }) → \"Acme\"\n *   resolveValue(\".\", currentItem) → currentItem\n */\nexport function resolveValue(path: string, data: unknown): unknown {\n  if (data == null || typeof data !== \"object\") {\n    return path === \".\" ? data : undefined;\n  }\n\n  // \".\" resolves to the special scope key set by loop iterations\n  if (path === \".\") {\n    const record = data as Record<string, unknown>;\n    return \".\" in record ? record[\".\"] : data;\n  }\n\n  const parts = path.split(\".\");\n  let current: unknown = data;\n\n  for (const part of parts) {\n    if (current == null || typeof current !== \"object\") return undefined;\n    current = (current as Record<string, unknown>)[part];\n  }\n\n  return current;\n}\n\n/**\n * Evaluate whether a value is \"truthy\" in the template sense.\n *\n * - `false`, `null`, `undefined`, `0`, `\"\"` → false\n * - Empty arrays `[]` → false\n * - Everything else → true\n */\nexport function isTruthy(value: unknown): boolean {\n  if (Array.isArray(value)) return value.length > 0;\n  return Boolean(value);\n}\n","/**\n * Escape special characters for safe insertion into XML text nodes.\n */\nexport function escapeXml(str: string): string {\n  return str\n    .replace(/&/g, \"&amp;\")\n    .replace(/</g, \"&lt;\")\n    .replace(/>/g, \"&gt;\")\n    .replace(/\"/g, \"&quot;\")\n    .replace(/'/g, \"&apos;\");\n}\n\n/**\n * Merge template tags that Word has split across multiple <w:t> runs.\n *\n * Word often breaks text like `{firstName}` into separate runs:\n *   <w:r><w:t>{first</w:t></w:r><w:r><w:t>Name}</w:t></w:r>\n *\n * This function detects unclosed `{` in a <w:t> element and pulls text from\n * subsequent <w:t> elements until the matching `}` is found, consolidating\n * the tag into a single <w:t>.\n */\nexport function mergeRuns(xml: string): string {\n  // Collect every <w:t ...>...</w:t> with its position\n  const wtRegex = /<w:t(\\s[^>]*)?>([^]*?)<\\/w:t>/g;\n\n  interface WtMatch {\n    fullMatch: string;\n    attrs: string;\n    content: string;\n    index: number;\n  }\n\n  const matches: WtMatch[] = [];\n  let m: RegExpExecArray | null;\n  while ((m = wtRegex.exec(xml)) !== null) {\n    matches.push({\n      fullMatch: m[0],\n      attrs: m[1] || \"\",\n      content: m[2],\n      index: m.index,\n    });\n  }\n\n  if (matches.length === 0) return xml;\n\n  // Track which matches need their content replaced\n  const newContents: Map<number, string> = new Map();\n\n  let i = 0;\n  while (i < matches.length) {\n    const content = newContents.get(i) ?? matches[i].content;\n    const openCount = countChar(content, \"{\");\n    const closeCount = countChar(content, \"}\");\n\n    if (openCount > closeCount) {\n      // Unclosed brace — pull text from the next <w:t> elements\n      let merged = content;\n      let j = i + 1;\n\n      while (j < matches.length) {\n        const nextContent = newContents.get(j) ?? matches[j].content;\n        merged += nextContent;\n        newContents.set(j, \"\");\n        const opens = countChar(merged, \"{\");\n        const closes = countChar(merged, \"}\");\n        if (closes >= opens) break;\n        j++;\n      }\n\n      newContents.set(i, merged);\n    }\n\n    i++;\n  }\n\n  // Rebuild the XML string with updated contents\n  if (newContents.size === 0) return xml;\n\n  let result = \"\";\n  let cursor = 0;\n\n  for (let k = 0; k < matches.length; k++) {\n    const mt = matches[k];\n    if (!newContents.has(k)) {\n      // No change — copy everything up to and including this match\n      result += xml.slice(cursor, mt.index + mt.fullMatch.length);\n      cursor = mt.index + mt.fullMatch.length;\n      continue;\n    }\n\n    // Copy everything before this match\n    result += xml.slice(cursor, mt.index);\n\n    // Write the updated <w:t> element\n    const attrs = mt.attrs;\n    const preserveSpace =\n      attrs.includes('xml:space=\"preserve\"') ? \"\" : ' xml:space=\"preserve\"';\n    result += `<w:t${attrs}${preserveSpace}>${newContents.get(k)}</w:t>`;\n    cursor = mt.index + mt.fullMatch.length;\n  }\n\n  // Append any remaining XML after the last match\n  result += xml.slice(cursor);\n\n  return result;\n}\n\n/**\n * Promote loop tags that are inside table cells to wrap the entire table row.\n *\n * When a user writes a loop inside a table (e.g. {#items} in the first cell\n * and {/items} in the last cell), the tags need to wrap the whole <w:tr>\n * element so that entire rows are duplicated — not just cell contents.\n *\n * Before: <w:tr><w:tc>..{#items}{name}..</w:tc><w:tc>..{price}{/items}..</w:tc></w:tr>\n * After:  {#items}<w:tr><w:tc>..{name}..</w:tc><w:tc>..{price}..</w:tc></w:tr>{/items}\n */\nexport function promoteTableLoopTags(xml: string): string {\n  // Match each table row (non-greedy — works for non-nested tables)\n  const trRegex = /<w:tr\\b[^>]*>[\\s\\S]*?<\\/w:tr>/g;\n\n  return xml.replace(trRegex, (rowXml) => {\n    // Find loop open tags (exclude conditions: {#if ...})\n    const openRegex = /\\{#(?!if[\\s}])([\\w.]+)\\}/g;\n    const closeRegex = /\\{\\/(?!if\\})([\\w.]+)\\}/g;\n\n    const opens: string[] = [];\n    const closes: string[] = [];\n\n    let match;\n    while ((match = openRegex.exec(rowXml)) !== null) opens.push(match[1]);\n    while ((match = closeRegex.exec(rowXml)) !== null) closes.push(match[1]);\n\n    // Only promote when a single loop wraps the row\n    if (\n      opens.length === 1 &&\n      closes.length === 1 &&\n      opens[0] === closes[0]\n    ) {\n      const name = opens[0];\n      const cleaned = rowXml\n        .replace(`{#${name}}`, \"\")\n        .replace(`{/${name}}`, \"\");\n      return `{#${name}}${cleaned}{/${name}}`;\n    }\n\n    return rowXml;\n  });\n}\n\nfunction countChar(str: string, char: string): number {\n  let count = 0;\n  for (let i = 0; i < str.length; i++) {\n    if (str[i] === char) count++;\n  }\n  return count;\n}\n","import type { ASTNode, FormatterMap } from \"./types\";\nimport { resolveValue, isTruthy } from \"../utils/expressions\";\nimport { escapeXml } from \"../utils/xml\";\n\n/**\n * Render an AST tree into a final XML string using the provided data\n * and formatters.\n */\nexport function render(\n  nodes: ASTNode[],\n  data: Record<string, unknown>,\n  formatters: FormatterMap,\n): string {\n  let output = \"\";\n\n  for (const node of nodes) {\n    switch (node.type) {\n      case \"text\":\n        output += node.content;\n        break;\n\n      case \"variable\":\n        output += renderVariable(node.name, node.formatters, data, formatters);\n        break;\n\n      case \"loop\":\n        output += renderLoop(node.name, node.children, data, formatters);\n        break;\n\n      case \"condition\":\n        output += renderCondition(\n          node.expression,\n          node.trueChildren,\n          node.falseChildren,\n          data,\n          formatters,\n        );\n        break;\n    }\n  }\n\n  return output;\n}\n\n// ---------------------------------------------------------------------------\n// Node renderers\n// ---------------------------------------------------------------------------\n\nfunction renderVariable(\n  name: string,\n  fmtNames: string[],\n  data: Record<string, unknown>,\n  formatters: FormatterMap,\n): string {\n  let value = resolveValue(name, data);\n\n  for (const fmtName of fmtNames) {\n    const fn = formatters[fmtName];\n    if (!fn) {\n      throw new MintdocRenderError(\n        `Unknown formatter \"${fmtName}\". Check your template and available formatters.`,\n      );\n    }\n    value = fn(value);\n  }\n\n  if (value == null) return \"\";\n  return escapeXml(String(value));\n}\n\nfunction renderLoop(\n  name: string,\n  children: ASTNode[],\n  data: Record<string, unknown>,\n  formatters: FormatterMap,\n): string {\n  const collection = resolveValue(name, data);\n\n  if (!Array.isArray(collection)) {\n    if (collection == null) return \"\";\n    throw new MintdocRenderError(\n      `Loop \"{#${name}}\" expects an array but received ${typeof collection}.`,\n    );\n  }\n\n  let output = \"\";\n\n  for (let i = 0; i < collection.length; i++) {\n    const item = collection[i];\n    const scope = createLoopScope(data, item, i, collection.length);\n    output += render(children, scope, formatters);\n  }\n\n  return output;\n}\n\nfunction renderCondition(\n  expression: string,\n  trueChildren: ASTNode[],\n  falseChildren: ASTNode[],\n  data: Record<string, unknown>,\n  formatters: FormatterMap,\n): string {\n  const value = resolveValue(expression, data);\n\n  if (isTruthy(value)) {\n    return render(trueChildren, data, formatters);\n  }\n  return render(falseChildren, data, formatters);\n}\n\n// ---------------------------------------------------------------------------\n// Scope helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Create a child scope for a loop iteration.\n *\n * - Parent data remains accessible (inner properties shadow outer ones).\n * - `.` refers to the current item.\n * - `@index` is the 0-based iteration index.\n * - `@first` / `@last` are booleans.\n */\nfunction createLoopScope(\n  parentData: Record<string, unknown>,\n  item: unknown,\n  index: number,\n  length: number,\n): Record<string, unknown> {\n  const base: Record<string, unknown> = {\n    ...parentData,\n    \".\": item,\n    \"@index\": index,\n    \"@first\": index === 0,\n    \"@last\": index === length - 1,\n  };\n\n  if (item !== null && typeof item === \"object\" && !Array.isArray(item)) {\n    Object.assign(base, item as Record<string, unknown>);\n  }\n\n  return base;\n}\n\n// ---------------------------------------------------------------------------\n// Error class\n// ---------------------------------------------------------------------------\n\nexport class MintdocRenderError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"MintdocRenderError\";\n  }\n}\n","import PizZip from \"pizzip\";\n\n/**\n * Open a .docx (or any Office Open XML) buffer as a PizZip instance.\n */\nexport function openZip(buffer: Buffer | ArrayBuffer | Uint8Array): PizZip {\n  return new PizZip(buffer);\n}\n\n/**\n * Read a file inside the ZIP archive as a UTF-8 string.\n * Returns `null` if the file does not exist.\n */\nexport function getFile(zip: PizZip, path: string): string | null {\n  const file = zip.file(path);\n  if (!file) return null;\n  return file.asText();\n}\n\n/**\n * Write (or overwrite) a file inside the ZIP archive.\n */\nexport function setFile(zip: PizZip, path: string, content: string): void {\n  zip.file(path, content);\n}\n\n/**\n * Generate the ZIP as a Node.js Buffer.\n */\nexport function generateZip(zip: PizZip): Buffer {\n  return zip.generate({\n    type: \"nodebuffer\",\n    compression: \"DEFLATE\",\n    compressionOptions: { level: 9 },\n  });\n}\n","import type { FormatterMap } from \"../core/types\";\nimport { tokenize } from \"../core/lexer\";\nimport { parse } from \"../core/parser\";\nimport { render } from \"../core/renderer\";\nimport { mergeRuns, promoteTableLoopTags } from \"../utils/xml\";\nimport { openZip, getFile, setFile, generateZip } from \"../utils/zip\";\n\n/**\n * Files inside the .docx archive that can contain template tags.\n * We process document.xml first, then headers/footers.\n */\nconst TEMPLATE_TARGETS = [\n  \"word/document.xml\",\n  // Headers & footers (Word uses numbered names)\n  ...Array.from({ length: 3 }, (_, i) => `word/header${i + 1}.xml`),\n  ...Array.from({ length: 3 }, (_, i) => `word/footer${i + 1}.xml`),\n];\n\n/**\n * Process a .docx template buffer with the given data.\n *\n * Pipeline:\n *   1. Open the docx (ZIP)\n *   2. For each XML target: merge split runs → tokenize → parse → render\n *   3. Re-package the ZIP and return a Buffer\n */\nexport function processDocx(\n  buffer: Buffer | ArrayBuffer | Uint8Array,\n  data: Record<string, unknown>,\n  formatters: FormatterMap,\n): Buffer {\n  const zip = openZip(buffer);\n\n  for (const target of TEMPLATE_TARGETS) {\n    const xml = getFile(zip, target);\n    if (xml === null) continue;\n\n    const processed = processXml(xml, data, formatters);\n    setFile(zip, target, processed);\n  }\n\n  return generateZip(zip);\n}\n\n/**\n * Run the full template pipeline on a raw XML string.\n */\nfunction processXml(\n  xml: string,\n  data: Record<string, unknown>,\n  formatters: FormatterMap,\n): string {\n  const merged = mergeRuns(xml);\n  const promoted = promoteTableLoopTags(merged);\n  const tokens = tokenize(promoted);\n  const ast = parse(tokens);\n  return render(ast, data, formatters);\n}\n","import type { FormatterMap } from \"../core/types\";\n\n/**\n * Built-in formatters shipped with the free core.\n */\nexport const builtinFormatters: FormatterMap = {\n  uppercase: (value) => String(value ?? \"\").toUpperCase(),\n  lowercase: (value) => String(value ?? \"\").toLowerCase(),\n  capitalize: (value) => {\n    const str = String(value ?? \"\");\n    return str.charAt(0).toUpperCase() + str.slice(1);\n  },\n};\n","import type { MintdocPlugin, FormatterMap } from \"../core/types\";\nimport { builtinFormatters } from \"./formatters\";\n\n/**\n * Collect all formatters from registered plugins, merged on top of builtins.\n */\nexport function collectFormatters(\n  plugins: MintdocPlugin[],\n  extraFormatters?: FormatterMap,\n): FormatterMap {\n  const merged: FormatterMap = { ...builtinFormatters };\n\n  for (const plugin of plugins) {\n    if (plugin.formatters) {\n      Object.assign(merged, plugin.formatters);\n    }\n  }\n\n  if (extraFormatters) {\n    Object.assign(merged, extraFormatters);\n  }\n\n  return merged;\n}\n","import type { FormatterMap, MintdocPlugin, RenderOptions } from \"./core/types\";\nimport { processDocx } from \"./formats/docx\";\nimport { collectFormatters } from \"./plugins/plugin-api\";\n\nexport const VERSION = \"0.1.0\";\n\n/**\n * Mintdoc — modern document templating engine.\n *\n * @example\n * ```ts\n * import { Mintdoc } from \"mintdoc\";\n *\n * const doc = new Mintdoc();\n * const output = doc.render(templateBuffer, { name: \"Alice\" });\n * ```\n */\nexport class Mintdoc {\n  private plugins: MintdocPlugin[] = [];\n  private extraFormatters: FormatterMap = {};\n\n  /**\n   * Register a plugin (adds formatters, tag handlers, etc.).\n   */\n  use(plugin: MintdocPlugin): this {\n    this.plugins.push(plugin);\n    return this;\n  }\n\n  /**\n   * Register one or more custom formatters.\n   */\n  addFormatters(formatters: FormatterMap): this {\n    Object.assign(this.extraFormatters, formatters);\n    return this;\n  }\n\n  /**\n   * Render a .docx template with the given data.\n   *\n   * @param template - The .docx file as a Buffer, ArrayBuffer or Uint8Array.\n   * @param data     - The data object to inject into the template.\n   * @returns A Buffer containing the rendered .docx file.\n   */\n  render(\n    template: Buffer | ArrayBuffer | Uint8Array,\n    data: Record<string, unknown>,\n  ): Buffer {\n    const formatters = collectFormatters(this.plugins, this.extraFormatters);\n    return processDocx(template, data, formatters);\n  }\n}\n\n/**\n * Shorthand: render a template without creating an instance.\n *\n * @example\n * ```ts\n * import { render } from \"mintdoc\";\n *\n * const output = render(templateBuffer, { name: \"Alice\" });\n * ```\n */\nexport function render(\n  template: Buffer | ArrayBuffer | Uint8Array,\n  data: Record<string, unknown>,\n  options?: RenderOptions,\n): Buffer {\n  const formatters = collectFormatters(\n    options?.plugins ?? [],\n    options?.formatters,\n  );\n  return processDocx(template, data, formatters);\n}\n\n// Re-export public types\nexport type { MintdocPlugin, RenderOptions, FormatterMap } from \"./core/types\";\nexport { MintdocParseError } from \"./core/parser\";\nexport { MintdocRenderError } from \"./core/renderer\";\n"],"mappings":"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","names":["render"]}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "mintdoc",
+  "version": "0.1.0",
+  "description": "Mint perfect documents from templates. A modern document templating engine for .docx files.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "docx",
+    "template",
+    "templating",
+    "document",
+    "generation",
+    "word",
+    "office",
+    "openxml"
+  ],
+  "author": "Yourica",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Yourica/mintdoc.git"
+  },
+  "homepage": "https://github.com/Yourica/mintdoc#readme",
+  "dependencies": {
+    "fast-xml-parser": "^5.2.0",
+    "pizzip": "^3.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18"
+  }
+}