@portone/docx-editor 0.2.0 → 0.3.0

package/dist/numbering/parseNumbering.js

@@ -1,7 +1,17 @@
 // src/numbering/parseNumbering.ts
+import {
+  ST_DecimalNumber,
+  ST_SignedTwipsMeasure,
+  ST_TwipsMeasure
+} from "../ooxml/simpleTypes.js";
 import { readTabStopDirectives } from "../ooxml/tabStops.js";
-import { childValue, round, wAttr } from "../ooxml/units.js";
-import { childByLocalName, elementChildren, parseXml } from "../ooxml/xml.js";
+import { childValue, twipsToPt, wAttr } from "../ooxml/units.js";
+import {
+  childByLocalName,
+  elementChildren,
+  parseXml,
+  withXmlParser
+} from "../ooxml/xml.js";
 var NUMBER_FORMATS = [
   "decimal",
   "bullet",
@@ -10,11 +20,6 @@ var NUMBER_FORMATS = [
   "lowerRoman"
 ];
 var EMPTY_NUMBERING = { lists: /* @__PURE__ */ new Map() };
-function toInteger(value) {
-  if (value === null) return null;
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) ? parsed : null;
-}
 function isNumberFormat(value) {
   return NUMBER_FORMATS.some((format) => format === value);
 }
@@ -22,13 +27,17 @@ function indentOf(lvl) {
   const pPr = childByLocalName(lvl, "pPr");
   const ind = pPr ? childByLocalName(pPr, "ind") : null;
   if (!ind) return null;
-  const startTwips = toInteger(wAttr(ind, "start") ?? wAttr(ind, "left"));
-  const endTwips = toInteger(wAttr(ind, "end") ?? wAttr(ind, "right"));
+  const startTwips = ST_SignedTwipsMeasure.parse(
+    wAttr(ind, "start") ?? wAttr(ind, "left")
+  );
+  const endTwips = ST_SignedTwipsMeasure.parse(
+    wAttr(ind, "end") ?? wAttr(ind, "right")
+  );
   const indent = {
     startTwips,
     endTwips,
-    hangingTwips: toInteger(wAttr(ind, "hanging")),
-    firstLineTwips: toInteger(wAttr(ind, "firstLine"))
+    hangingTwips: ST_TwipsMeasure.parse(wAttr(ind, "hanging")),
+    firstLineTwips: ST_TwipsMeasure.parse(wAttr(ind, "firstLine"))
   };
   const empty = startTwips === null && endTwips === null && indent.hangingTwips === null && indent.firstLineTwips === null;
   return empty ? null : indent;
@@ -38,9 +47,6 @@ var NO_LEVEL_INDENT = {
   endPt: null,
   textIndentPt: null
 };
-function twipsToPt(twips) {
-  return twips === null ? null : round(twips / 20);
-}
 function levelIndentPt(indent) {
   if (!indent) return NO_LEVEL_INDENT;
   const hangingPt = twipsToPt(indent.hangingTwips);
@@ -57,7 +63,7 @@ function readLevel(lvl) {
   return {
     format: isNumberFormat(format) ? format : "decimal",
     text: childValue(lvl, "lvlText") ?? "",
-    start: toInteger(childValue(lvl, "start")) ?? 1,
+    start: ST_DecimalNumber.parse(childValue(lvl, "start")) ?? 1,
     indent: indentOf(lvl),
     ...tabStops.length === 0 ? {} : { tabStops }
   };
@@ -66,23 +72,27 @@ function readLevels(parent) {
   const levels = /* @__PURE__ */ new Map();
   for (const child of elementChildren(parent)) {
     if (child.localName !== "lvl") continue;
-    const ilvl = toInteger(wAttr(child, "ilvl"));
+    const ilvl = ST_DecimalNumber.parse(wAttr(child, "ilvl"));
     if (ilvl !== null) levels.set(ilvl, readLevel(child));
   }
   return levels;
 }
 function readList(num, abstractLevels) {
-  const abstractNumId = toInteger(childValue(num, "abstractNumId"));
+  const abstractNumId = ST_DecimalNumber.parse(
+    childValue(num, "abstractNumId")
+  );
   if (abstractNumId === null) return null;
   const levels = new Map(abstractLevels.get(abstractNumId) ?? []);
   for (const child of elementChildren(num)) {
     if (child.localName !== "lvlOverride") continue;
-    const ilvl = toInteger(wAttr(child, "ilvl"));
+    const ilvl = ST_DecimalNumber.parse(wAttr(child, "ilvl"));
     if (ilvl === null) continue;
     const replacement = childByLocalName(child, "lvl");
     const base = replacement ? readLevel(replacement) : levels.get(ilvl);
     if (!base) continue;
-    const startOverride = toInteger(childValue(child, "startOverride"));
+    const startOverride = ST_DecimalNumber.parse(
+      childValue(child, "startOverride")
+    );
     levels.set(
       ilvl,
       startOverride === null ? base : { ...base, start: startOverride }
@@ -90,19 +100,22 @@ function readList(num, abstractLevels) {
   }
   return { levels };
 }
-function parseNumbering(xml) {
+function parseNumbering(xml, options) {
   if (xml === null) return EMPTY_NUMBERING;
+  return withXmlParser(options?.xmlParser, () => readNumbering(xml));
+}
+function readNumbering(xml) {
   const root = parseXml(xml).documentElement;
   const abstractLevels = /* @__PURE__ */ new Map();
   for (const child of elementChildren(root)) {
     if (child.localName !== "abstractNum") continue;
-    const id = toInteger(wAttr(child, "abstractNumId"));
+    const id = ST_DecimalNumber.parse(wAttr(child, "abstractNumId"));
     if (id !== null) abstractLevels.set(id, readLevels(child));
   }
   const lists = /* @__PURE__ */ new Map();
   for (const child of elementChildren(root)) {
     if (child.localName !== "num") continue;
-    const numId = toInteger(wAttr(child, "numId"));
+    const numId = ST_DecimalNumber.parse(wAttr(child, "numId"));
     const list = numId === null ? null : readList(child, abstractLevels);
     if (numId !== null && list) lists.set(numId, list);
   }

package/dist/numbering/writeNumbering.d.ts

@@ -1,10 +1,9 @@
 /**
  * Splices the definitions of newly started lists into the original numbering.xml.
  *
- * Not one character of the original is altered; new elements are merely slotted in at
- * two places.
- * OOXML requires the definitions (`abstractNum`) to come before the numbers (`num`), so
- * the definitions go in front of the first number and the numbers go at the very end.
+ * Not one character of the original is altered; new elements are merely slotted in.
+ * OOXML requires the definitions (`abstractNum`) to come before the numbers (`num`), and
+ * `CHILD_ORDER.numbering` is what places each where it belongs among what the part holds.
  */
 /**
  * numbering.xml with a standard template definition added for every list number.

package/dist/numbering/writeNumbering.js

@@ -1,18 +1,8 @@
 // src/numbering/writeNumbering.ts
-import { DocxExportError } from "../ooxml/errors.js";
+import { splicePart } from "../ooxml/partSplice.js";
 import { wAttr } from "../ooxml/units.js";
 import { elementChildren, parseXml } from "../ooxml/xml.js";
 import { abstractNumXml, listKindOf, numXml } from "./listTemplate.js";
-function openTagAt(xml, name) {
-  const match = new RegExp(`<(?:[A-Za-z_][\\w.-]*:)?${name}[\\s/>]`).exec(xml);
-  return match ? match.index : null;
-}
-function closeTagAt(xml, name) {
-  const matches = Array.from(
-    xml.matchAll(new RegExp(`</(?:[A-Za-z_][\\w.-]*:)?${name}\\s*>`, "g"))
-  );
-  return matches.at(-1)?.index ?? null;
-}
 function maxAbstractNumId(xml) {
   let max = 0;
   for (const child of elementChildren(parseXml(xml).documentElement)) {
@@ -24,25 +14,24 @@ function maxAbstractNumId(xml) {
 }
 function addListDefinitions(xml, numIds) {
   if (numIds.length === 0) return xml;
-  const rootEnd = closeTagAt(xml, "numbering");
-  if (rootEnd === null) {
-    throw new DocxExportError(
-      "malformed-xml",
-      "no closing tag found in numbering.xml"
-    );
-  }
-  const numsAt = openTagAt(xml, "numIdMacAtCleanup") ?? rootEnd;
-  const definitionsAt = openTagAt(xml, "num") ?? numsAt;
   const firstAbstractNumId = maxAbstractNumId(xml) + 1;
   const additions = [...numIds].sort((a, b) => a - b).map((numId, index) => ({
     numId,
     abstractNumId: firstAbstractNumId + index
   }));
-  const definitions = additions.map(
-    (added) => abstractNumXml(added.abstractNumId, listKindOf(added.numId))
-  ).join("");
-  const nums = additions.map((added) => numXml(added.numId, added.abstractNumId)).join("");
-  return xml.slice(0, definitionsAt) + definitions + xml.slice(definitionsAt, numsAt) + nums + xml.slice(numsAt);
+  return splicePart(xml, {
+    root: "numbering",
+    insert: [
+      ...additions.map((added) => ({
+        name: "abstractNum",
+        xml: abstractNumXml(added.abstractNumId, listKindOf(added.numId))
+      })),
+      ...additions.map((added) => ({
+        name: "num",
+        xml: numXml(added.numId, added.abstractNumId)
+      }))
+    ]
+  });
 }
 export {
   addListDefinitions

package/dist/ooxml/childOrder.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The order the children of one element go in, per parent.
+ *
+ * A writer that swaps one child of a formatting fragment has to put a child that was not there
+ * into the spot the format lays down, and `wml.xsd` is what lays it down. Each entry below names
+ * the complex type it mirrors, and `childOrder.test.ts` reads that type out of the committed
+ * schema and compares it, so an entry cannot drift from the format it claims to follow.
+ *
+ * Where the type is a sequence the order is the schema's and nothing else. Where it is a choice
+ * the schema fixes no order among the alternatives, so the order here is this package's
+ * convention: the schema's own document order. Mutually exclusive alternatives (a content
+ * control's type, a cell's markup record) are listed in that same order, since only one of them
+ * can ever stand there.
+ *
+ * A name is the local part alone, as `Props` carries it, which is also how the two children
+ * `w:settings` takes from other namespaces (`m:mathPr`, `sl:schemaLibrary`) are spelled here.
+ */
+interface ChildOrder {
+    readonly type: string;
+    readonly order: readonly string[];
+}
+export declare const CHILD_ORDER: Readonly<Record<string, ChildOrder>>;
+/**
+ * The order the children of this parent go in.
+ *
+ * A nested parent is asked for first (`pPr/rPr` is CT_ParaRPr, which puts a track-change record
+ * ahead of what a run's own `w:rPr` holds), so naming the enclosing element is what picks the
+ * right one of two entries for the same element name.
+ *
+ * Throws for a parent no entry covers, because a writer editing an element this registry has
+ * never seen would otherwise place its children by nothing at all.
+ */
+export declare function childOrderOf(name: string, parent?: string): readonly string[];
+export {};