@json-to-office/core-docx 7.3.1 → 7.4.0

package/dist/index.js

@@ -2930,7 +2930,7 @@ var init_chartText = __esm({
 });
 
 // src/renderers/docxjs/docxSubpath.ts
-function docxSubpath(specifier, component, importer) {
+function docxSubpath(specifier, component, importer, since = "9.8.0") {
   let module;
   let failure;
   let loading;
@@ -2954,7 +2954,7 @@ function docxSubpath(specifier, component, importer) {
         const { reason } = failure;
         const detail = reason instanceof Error ? reason.message : String(reason);
         throw new Error(
-          `The docx \`${component}\` component needs docx 9.8.0 or later: the \`${specifier}\` entry could not be loaded (${detail})`
+          `The docx \`${component}\` component needs docx ${since} or later: the \`${specifier}\` entry could not be loaded (${detail})`
         );
       }
       throw new Error(
@@ -3551,8 +3551,19 @@ function emitBlock(block2, resources = /* @__PURE__ */ new Map()) {
       return assertNever2(block2, "DocxIrBlock");
   }
 }
+function emitOutsideBody(emit) {
+  const was = outsideBody;
+  outsideBody = true;
+  try {
+    return emit();
+  } finally {
+    outsideBody = was;
+  }
+}
 function emitToc(block2) {
-  return new ThemedTableOfContents(block2.alias ?? "Table of Contents", {
+  const cached = outsideBody && block2.cachedEntries?.length;
+  const Field = cached ? ThemedTableOfContents : TableOfContents;
+  return new Field(block2.alias ?? "Table of Contents", {
     ...block2.hyperlink !== void 0 ? { hyperlink: block2.hyperlink } : {},
     ...block2.headingRange ? {
       headingStyleRange: `${block2.headingRange.from}-${block2.headingRange.to}`
@@ -3565,7 +3576,7 @@ function emitToc(block2) {
       pageNumbersEntryLevelsRange: block2.omitPageNumbersForLevels.map((range) => `${range.from}-${range.to}`).join(",")
     } : {},
     ...block2.entrySeparator !== void 0 ? { entryAndPageNumberSeparator: block2.entrySeparator } : {},
-    ...block2.cachedEntries?.length ? {
+    ...cached ? {
       cachedEntries: block2.cachedEntries.map((entry) => ({
         title: entry.text,
         level: entry.level
@@ -3688,7 +3699,7 @@ function emitBorder(border3) {
     ...border3.spacePoints !== void 0 ? { space: border3.spacePoints } : {}
   };
 }
-var ALIGNMENT2, PAGE_FIELDS, isSequenceField, WRAP_TYPE, ThemedTableOfContents, VERTICAL_ALIGN, TABLE_ANCHOR, HORIZONTAL_POSITION, VERTICAL_POSITION;
+var ALIGNMENT2, PAGE_FIELDS, isSequenceField, WRAP_TYPE, ThemedTableOfContents, outsideBody, VERTICAL_ALIGN, TABLE_ANCHOR, HORIZONTAL_POSITION, VERTICAL_POSITION;
 var init_emit = __esm({
   "src/renderers/docxjs/emit.ts"() {
     "use strict";
@@ -3714,6 +3725,7 @@ var init_emit = __esm({
     Object.defineProperty(ThemedTableOfContents.prototype, "getTabStopsForLevel", {
       value: () => []
     });
+    outsideBody = false;
     VERTICAL_ALIGN = {
       top: VerticalAlign.TOP,
       center: VerticalAlign.CENTER,
@@ -3901,6 +3913,318 @@ var init_styles2 = __esm({
   }
 });
 
+// src/renderers/docxjs/pageNumbers.ts
+import {
+  Tab as Tab2
+} from "docx";
+function needsPageNumbers(ir) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (value) => {
+    if (typeof value !== "object" || value === null) return false;
+    if (ArrayBuffer.isView(value) || seen.has(value)) return false;
+    seen.add(value);
+    if (Array.isArray(value)) return value.some(visit);
+    if (value.kind === "toc") return true;
+    return Object.values(value).some(visit);
+  };
+  return ir.sections.some((section2) => visit(section2.children));
+}
+async function createPageNumberEstimator(ir) {
+  await layout.load();
+  const cached = cachedContentsEntries(ir);
+  const separators = contentsSeparators(ir);
+  const estimate = layout.loaded() ? layout.get().estimatePageNumbersWith({ guess: true }) : void 0;
+  return (body, context) => {
+    renumberContentsBookmarks(body);
+    restoreEntryNumbers(body, cached, separators);
+    dropContentsEntryTabs(body);
+    writeSeparatorTabs(body, context);
+    endContentsInLastEntry(body);
+    if (!estimate) {
+      unavailable(
+        `the \`docx/layout\` entry could not be loaded (${failureOf(() => layout.get())})`
+      );
+      return { bookmarks: /* @__PURE__ */ new Map() };
+    }
+    try {
+      const estimated = estimate(body, context);
+      if (complete(estimated)) clearUpdateFields(context.file);
+      return estimated;
+    } catch (error) {
+      unavailable(error instanceof Error ? error.message : String(error));
+      return { bookmarks: /* @__PURE__ */ new Map() };
+    }
+  };
+}
+function unavailable(reason) {
+  reportWarning(
+    "toc",
+    PAGE_NUMBERS_UNAVAILABLE,
+    `The table of contents is written without page numbers: laying the pages out failed (${reason}). Word fills them in when it updates the fields on open.`
+  );
+}
+function failureOf(get) {
+  try {
+    get();
+    return "unknown";
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+function complete(estimated) {
+  return estimated.pageCount !== void 0 && (estimated.guesses ?? []).length === 0;
+}
+function clearUpdateFields(file) {
+  const root = file?.Settings?.root;
+  if (!root) return;
+  const at = root.findIndex(
+    (element) => element?.rootKey === "w:updateFields"
+  );
+  if (at >= 0) root.splice(at, 1);
+}
+function isContentsField(sdt) {
+  let found = false;
+  const visit = (element) => {
+    if (found) return;
+    if (nameOf(element) === "w:instrText") {
+      found = childrenOf(element).some(
+        (child) => typeof child === "string" && /^\s*TOC\b/.test(child)
+      );
+      return;
+    }
+    childrenOf(element).forEach(visit);
+  };
+  visit(sdt);
+  return found;
+}
+function contentsFields(body) {
+  const found = [];
+  const visit = (element) => {
+    const name = nameOf(element);
+    if (name === void 0 || name === "_attr") return;
+    if (name === "w:sdt" && isContentsField(element)) {
+      found.push(element);
+      return;
+    }
+    childrenOf(element).forEach(visit);
+  };
+  visit(body);
+  return found;
+}
+function entryParagraphs(field) {
+  return childrenOf(field).filter((content) => nameOf(content) === "w:sdtContent").flatMap(
+    (content) => childrenOf(content).filter((paragraph2) => nameOf(paragraph2) === "w:p")
+  );
+}
+function dropContentsEntryTabs(body) {
+  for (const field of contentsFields(body)) {
+    for (const paragraph2 of entryParagraphs(field)) {
+      for (const properties of childrenOf(paragraph2)) {
+        if (nameOf(properties) !== "w:pPr") continue;
+        properties["w:pPr"] = childrenOf(properties).filter(
+          (child) => nameOf(child) !== "w:tabs"
+        );
+      }
+    }
+  }
+}
+function endContentsInLastEntry(body) {
+  for (const field of contentsFields(body)) {
+    for (const content of childrenOf(field)) {
+      if (nameOf(content) !== "w:sdtContent") continue;
+      const paragraphs = childrenOf(content);
+      const last = paragraphs[paragraphs.length - 1];
+      const entry = paragraphs[paragraphs.length - 2];
+      if (nameOf(last) !== "w:p" || nameOf(entry) !== "w:p") continue;
+      const runs = childrenOf(last);
+      const onlyTheEnd = runs.length === 1 && nameOf(runs[0]) === "w:r" && childrenOf(runs[0]).every(
+        (child) => nameOf(child) === "w:fldChar" && attributesOf(child)?.["w:fldCharType"] === "end"
+      );
+      const entries = paragraphs.filter(
+        (paragraph2) => textNodes(paragraph2).length > 0
+      );
+      if (!onlyTheEnd || entries.length < 2 || textNodes(entry).length === 0)
+        continue;
+      childrenOf(entry).push(runs[0]);
+      paragraphs.pop();
+    }
+  }
+}
+function writeSeparatorTabs(body, context) {
+  const tab = () => new Tab2().prepForXml(context);
+  const visit = (element) => {
+    const name = nameOf(element);
+    if (name === void 0 || name === "_attr") return;
+    if (name === "w:r") {
+      const children = childrenOf(element);
+      children.forEach((child, index) => {
+        if (nameOf(child) !== "w:t") return;
+        const text = childrenOf(child).filter(
+          (part) => typeof part === "string"
+        );
+        if (text.length === 1 && text[0] === "	") children[index] = tab();
+      });
+      return;
+    }
+    childrenOf(element).forEach(visit);
+  };
+  for (const field of contentsFields(body))
+    entryParagraphs(field).forEach(visit);
+}
+function textNodes(element) {
+  const name = nameOf(element);
+  if (name === void 0 || name === "_attr" || name === "w:instrText")
+    return [];
+  const children = childrenOf(element);
+  if (name === "w:t")
+    return children.flatMap(
+      (child, index) => typeof child === "string" ? [{ parent: children, index }] : []
+    );
+  return children.flatMap(textNodes);
+}
+function contentsSeparators(ir) {
+  const separators = [];
+  const visit = (value) => {
+    if (typeof value !== "object" || value === null) return;
+    if (ArrayBuffer.isView(value)) return;
+    if (Array.isArray(value)) {
+      value.forEach(visit);
+      return;
+    }
+    if (value.kind === "toc") {
+      separators.push(value.entrySeparator);
+      return;
+    }
+    Object.values(value).forEach(visit);
+  };
+  for (const section2 of ir.sections) visit(section2.children);
+  return separators;
+}
+function cachedContentsEntries(ir) {
+  const fields = [];
+  const visit = (value) => {
+    if (typeof value !== "object" || value === null) return;
+    if (ArrayBuffer.isView(value)) return;
+    if (Array.isArray(value)) {
+      value.forEach(visit);
+      return;
+    }
+    if (value.kind === "toc") {
+      const toc = value;
+      fields.push(toc.cachedEntries?.map((entry) => entry.text));
+      return;
+    }
+    Object.values(value).forEach(visit);
+  };
+  for (const section2 of ir.sections) visit(section2.children);
+  return fields;
+}
+function restoreEntryNumbers(body, cached, separators = []) {
+  contentsFields(body).forEach((field, index) => {
+    const texts = cached[index];
+    const paragraphs = entryParagraphs(field).filter(
+      (paragraph2) => textNodes(paragraph2).length > 0
+    );
+    if (!texts || texts.length !== paragraphs.length) return;
+    paragraphs.forEach((paragraph2, entry) => {
+      const nodes = textNodes(paragraph2);
+      let title = nodes.map(({ parent, index: at }) => parent[at]).join("");
+      const separator = separators[index];
+      if (separator && title.endsWith(separator))
+        title = title.slice(0, -separator.length);
+      const text = texts[entry];
+      if (title === "" || text === title || !text.endsWith(title)) return;
+      const [first] = nodes;
+      first.parent[first.index] = text.slice(0, text.length - title.length) + first.parent[first.index];
+    });
+  });
+}
+function renumberContentsBookmarks(body) {
+  const names = /* @__PURE__ */ new Map();
+  const paragraphs = (element) => {
+    const name = nameOf(element);
+    if (name === void 0 || name === "_attr") return;
+    if (name !== "w:p") {
+      childrenOf(element).forEach(paragraphs);
+      return;
+    }
+    const children = childrenOf(element);
+    for (const start of children) {
+      if (nameOf(start) !== "w:bookmarkStart") continue;
+      const attributes = attributesOf(start);
+      const old = attributes?.["w:name"];
+      if (typeof old !== "string" || !CONTENTS_BOOKMARK.test(old)) continue;
+      const ordinal = names.size + 1;
+      const renamed2 = `_Toc${ordinal}`;
+      const id = CONTENTS_BOOKMARK_ID_BASE + ordinal;
+      names.set(old, renamed2);
+      const oldId = attributes["w:id"];
+      attributes["w:name"] = renamed2;
+      attributes["w:id"] = id;
+      const end = [...children].reverse().find(
+        (child) => nameOf(child) === "w:bookmarkEnd" && String(attributesOf(child)?.["w:id"]) === String(oldId)
+      );
+      if (end) attributesOf(end)["w:id"] = id;
+    }
+  };
+  paragraphs(body);
+  if (names.size === 0) return;
+  const references = (element) => {
+    const name = nameOf(element);
+    if (name === void 0) return;
+    if (name === "w:hyperlink") {
+      const attributes = attributesOf(element);
+      const anchor = attributes?.["w:anchor"];
+      if (typeof anchor === "string" && names.has(anchor))
+        attributes["w:anchor"] = names.get(anchor);
+    }
+    if (name === "w:instrText") {
+      const children = childrenOf(element);
+      children.forEach((child, index) => {
+        if (typeof child !== "string") return;
+        children[index] = child.replace(
+          /\b(PAGEREF\s+)(_Toc\d+)\b/g,
+          (match, field, bookmark) => names.has(bookmark) ? `${field}${names.get(bookmark)}` : match
+        );
+      });
+      element[name] = children;
+      return;
+    }
+    if (name === "_attr") return;
+    childrenOf(element).forEach(references);
+  };
+  references(body);
+}
+function attributesOf(element) {
+  const attributes = childrenOf(element).find(
+    (child) => nameOf(child) === "_attr"
+  );
+  return attributes?._attr;
+}
+var PAGE_NUMBERS_UNAVAILABLE, layout, nameOf, childrenOf, CONTENTS_BOOKMARK_ID_BASE, CONTENTS_BOOKMARK;
+var init_pageNumbers = __esm({
+  "src/renderers/docxjs/pageNumbers.ts"() {
+    "use strict";
+    init_generationContext();
+    init_docxSubpath();
+    PAGE_NUMBERS_UNAVAILABLE = "W_DOCX_PAGE_NUMBERS_UNAVAILABLE";
+    layout = docxSubpath(
+      "docx/layout",
+      "toc",
+      () => import("docx/layout"),
+      "9.9.0"
+    );
+    nameOf = (element) => typeof element === "object" && element !== null && !Array.isArray(element) ? Object.keys(element)[0] : void 0;
+    childrenOf = (element) => {
+      const name = nameOf(element);
+      const content = name === void 0 ? void 0 : element[name];
+      return Array.isArray(content) ? content : content === void 0 ? [] : [content];
+    };
+    CONTENTS_BOOKMARK_ID_BASE = 3e6;
+    CONTENTS_BOOKMARK = /^_Toc\d+$/;
+  }
+});
+
 // src/utils/normalizeTextCase.ts
 function normalizeTextCase(zip) {
   let changed = false;
@@ -4682,7 +5006,8 @@ function createDocxJsRenderer() {
           )
         });
       }
-      const document = buildDocument(ir, resources);
+      const pageNumbers = needsPageNumbers(ir) ? await createPageNumberEstimator(ir) : void 0;
+      const document = buildDocument(ir, resources, pageNumbers);
       const packed = await Packer.toBuffer(document);
       const fixed = fixFloatingImageIdsInBuffer(packed);
       const repaired = markers ? repairDrawingGroupsInBuffer(fixed, markers) : fixed;
@@ -4700,13 +5025,12 @@ function createDocxJsRenderer() {
     }
   };
 }
-function buildDocument(ir, resources = /* @__PURE__ */ new Map()) {
+function buildDocument(ir, resources = /* @__PURE__ */ new Map(), pageNumbers) {
   return new Document({
+    ...pageNumbers ? { pageNumbers } : {},
     styles: emitStyles(ir.styles),
     ...ir.theme ? { theme: themeOptions(ir.theme) } : {},
-    sections: ir.sections.map(
-      (section2, index) => sectionOptions(section2, resources, index === ir.sections.length - 1)
-    ),
+    sections: ir.sections.map((section2) => sectionOptions(section2, resources)),
     ...coreProperties(ir),
     features: {
       updateFields: ir.settings.updateFields,
@@ -4725,8 +5049,8 @@ function buildDocument(ir, resources = /* @__PURE__ */ new Map()) {
           author: comment.author,
           ...comment.initials ? { initials: comment.initials } : {},
           date: new Date(comment.date),
-          children: comment.children.map(
-            (block2) => emitBlock(block2, resources)
+          children: emitOutsideBody(
+            () => comment.children.map((block2) => emitBlock(block2, resources))
           ),
           ...comment.parentId !== void 0 ? { parentId: comment.parentId } : {},
           ...comment.resolved !== void 0 ? { resolved: comment.resolved } : {}
@@ -4754,8 +5078,8 @@ function noteBodies(notes, resources) {
   const bodies = {};
   for (const note of notes) {
     bodies[String(note.id)] = {
-      children: note.children.map(
-        (block2) => emitBlock(block2, resources)
+      children: emitOutsideBody(
+        () => note.children.map((block2) => emitBlock(block2, resources))
       )
     };
   }
@@ -4916,7 +5240,7 @@ function collectImagePlacements(ir) {
   }
   return { placements, drawingGroups };
 }
-function sectionOptions(section2, resources, closesDocument = false) {
+function sectionOptions(section2, resources) {
   const { page, columns } = section2.properties;
   const options = {
     properties: {
@@ -4955,7 +5279,7 @@ function sectionOptions(section2, resources, closesDocument = false) {
         }
       } : {}
     },
-    children: sectionChildren(section2, resources, closesDocument)
+    children: sectionChildren(section2, resources)
   };
   const headers = chromeSlots(section2.headers, Header, resources);
   if (headers) options.headers = headers;
@@ -4969,7 +5293,9 @@ function chromeSlots(set, Part, resources) {
   for (const slot of ["default", "first", "even"]) {
     const part = set[slot];
     if (part) {
-      out[slot] = new Part({ children: partChildren(part, resources) });
+      out[slot] = new Part({
+        children: emitOutsideBody(() => partChildren(part, resources))
+      });
     }
   }
   return Object.keys(out).length > 0 ? out : void 0;
@@ -4977,10 +5303,10 @@ function chromeSlots(set, Part, resources) {
 function partChildren(part, resources) {
   return part.children.map((block2) => emitBlock(block2, resources));
 }
-function sectionChildren(section2, resources, closesDocument = false) {
+function sectionChildren(section2, resources) {
   const blocks = section2.children.map((block2) => emitBlock(block2, resources));
   const bookmark = section2.bookmark;
-  const endsInFrame = closesDocument && lastBlockIsFrame(section2);
+  const endsInFrame = lastBlockIsFrame(section2);
   if (!bookmark && !endsInFrame) return blocks;
   const out = [...blocks];
   if (bookmark?.opens) {
@@ -5033,6 +5359,7 @@ var init_docxjs = __esm({
     "use strict";
     init_styles2();
     init_charts();
+    init_pageNumbers();
     init_imageUtils();
     init_packageDocument();
     init_fixFloatingImageIds();
@@ -6219,7 +6546,7 @@ function sectionChildren2(value, ctx, closesDocument = false) {
   const blocks = value.children.map((child) => block(child, ctx));
   const last = value.children[value.children.length - 1];
   const bookmark = value.bookmark;
-  if (bookmark?.closes && last?.kind !== "paragraph" || closesDocument && last?.kind === "paragraph" && last.frame !== void 0)
+  if (bookmark?.closes && last?.kind !== "paragraph" || last?.kind === "paragraph" && last.frame !== void 0 && (closesDocument || !bookmark?.closes))
     blocks.push({
       paragraph: {
         children: [],
@@ -10300,9 +10627,9 @@ function schemeHex(token, theme) {
 // src/ir/compiler.ts
 var CONTENT_BOOKMARK_ID_BASE = 2e6;
 var SINGLE_LINE_TWIPS = 240;
-function compileDocument(structure, layout, warnings = [], images = /* @__PURE__ */ new Map(), options = {}) {
+function compileDocument(structure, layout2, warnings = [], images = /* @__PURE__ */ new Map(), options = {}) {
   const styles = createDocumentStyles(structure.theme, structure.language);
-  const outline = collectOutline(layout, warnings);
+  const outline = collectOutline(layout2, warnings);
   const ctx = {
     theme: structure.theme,
     themeName: structure.themeName,
@@ -10337,10 +10664,10 @@ function compileDocument(structure, layout, warnings = [], images = /* @__PURE__
   };
   ctx.features.require("paragraphs", "sections");
   ctx.features.require("styles", "styles");
-  if (layout.sections.length > 1) ctx.features.require("sections", "sections");
-  const ordinals = computeSectionOrdinals(layout.sections);
-  const chrome = resolveSectionChrome(layout.sections);
-  const sections = layout.sections.map(
+  if (layout2.sections.length > 1) ctx.features.require("sections", "sections");
+  const ordinals = computeSectionOrdinals(layout2.sections);
+  const chrome = resolveSectionChrome(layout2.sections);
+  const sections = layout2.sections.map(
     (section2, index) => compileSection(section2, index, ordinals[index], chrome[index], ctx)
   );
   if (ctx.hasResolvedComment && !ctx.comments.some((comment) => comment.parentId !== void 0)) {
@@ -10418,9 +10745,9 @@ function separateFromTables(blocks, bodyAfterTwips) {
     }
   }
 }
-function collectOutline(layout, warnings) {
+function collectOutline(layout2, warnings) {
   try {
-    return collectDocumentOutline(layout.sections);
+    return collectDocumentOutline(layout2.sections);
   } catch (error) {
     warnings.push({
       component: "document",
@@ -12966,13 +13293,19 @@ function compileTableRow(row, columnTwips, spacing, baseStyle, scope) {
     ...scope.cantSplit !== void 0 ? { cantSplit: scope.cantSplit } : {}
   };
 }
+var NORMAL_TABLE_CELL_MARGINS = {
+  topTwips: 0,
+  bottomTwips: 0,
+  leftTwips: 108,
+  rightTwips: 108
+};
 function compileTableCell(cell, columnTwips, spacing, baseStyle, keepNext, partScope, rowRevision, markRevision) {
-  const margins = !cell.missing && cell.padding ? {
+  const margins = cell.missing ? void 0 : cell.padding ? {
     topTwips: pointsToTwips2(cell.padding.top),
     bottomTwips: pointsToTwips2(cell.padding.bottom),
     leftTwips: pointsToTwips2(cell.padding.left),
     rightTwips: pointsToTwips2(cell.padding.right)
-  } : void 0;
+  } : NORMAL_TABLE_CELL_MARGINS;
   const scope = {
     ...partScope,
     measureTwips: cellMeasureTwips(columnTwips, margins)
@@ -13477,8 +13810,8 @@ function hasPageBreak(component) {
   }
   return false;
 }
-function getColumnSettings(layout) {
-  switch (layout) {
+function getColumnSettings(layout2) {
+  switch (layout2) {
     case "multi-column":
       return {
         count: 2,
@@ -15921,19 +16254,19 @@ async function compileDocumentScoped(document, options, warnings) {
     context.themeName,
     resolveGenerationDate(options)
   );
-  const layout = applyLayout(
+  const layout2 = applyLayout(
     structure.sections,
     context.theme,
     context.themeName
   );
   const images = await loadImageResources(
-    layout.sections.flatMap((section2) => [
+    layout2.sections.flatMap((section2) => [
       ...section2.components,
       ...Array.isArray(section2.header) ? section2.header : [],
       ...Array.isArray(section2.footer) ? section2.footer : []
     ])
   );
-  const compiled = compileDocument(structure, layout, warnings, images, {
+  const compiled = compileDocument(structure, layout2, warnings, images, {
     // A caller that collects nothing still needs to hear about a dropped
     // value, so warnings go to the console when there is no collector.
     echoWarnings: options.warnings === void 0