@portone/docx-editor 0.3.0 → 0.5.0

package/dist/docx/importPolicy.js

@@ -0,0 +1,190 @@
+// src/docx/importPolicy.ts
+import { M_NS, W_NS } from "../ooxml/names.js";
+import {
+  COMMENT_RANGE_MARKERS,
+  PERMISSION_MARKERS,
+  RANGE_MARKERS
+} from "../ooxml/rangeMarkers.js";
+var MODEL = { tier: "model" };
+var HIDDEN_MARKER = {
+  tier: "marker",
+  display: "hidden",
+  guarded: true
+};
+var IGNORABLE = {
+  tier: "ignorable",
+  display: "hidden",
+  guarded: false
+};
+function chip(tier) {
+  return { tier, display: "chip", guarded: false };
+}
+var RUN_CHIP = chip("runContent");
+var INLINE_CHIP = chip("inline");
+var BLOCK_CHIP = chip("block");
+var FIELD_PIECE = {
+  tier: "runContent",
+  display: "chip",
+  guarded: true
+};
+function clarkName(el) {
+  return `{${el.namespaceURI ?? ""}}${el.localName}`;
+}
+function wml(localName) {
+  return `{${W_NS}}${localName}`;
+}
+function rules(entries) {
+  return new Map(
+    entries.flatMap(
+      ([names, policy]) => names.map((name) => [wml(name), policy])
+    )
+  );
+}
+var REVISION_CONTAINERS = ["ins", "del", "moveFrom", "moveTo"];
+var MATH = [`{${M_NS}}oMath`, `{${M_NS}}oMathPara`];
+var RUN_LEVEL = rules([
+  [["rPr", "t", "br", "tab", "drawing"], MODEL],
+  [["commentReference", "footnoteReference", "endnoteReference"], MODEL],
+  [["lastRenderedPageBreak"], IGNORABLE],
+  [["softHyphen"], { tier: "runContent", display: "hidden", guarded: false }],
+  [
+    ["noBreakHyphen"],
+    { tier: "runContent", display: "text", text: "\u2011", guarded: false }
+  ],
+  [["cr"], { tier: "runContent", display: "break", guarded: false }],
+  // §17.16.18: a complex field is the begin, the instruction and the end read in order, so a
+  // piece taken away leaves the rest saying something the file never said
+  [["fldChar", "instrText", "delInstrText"], FIELD_PIECE],
+  [
+    [
+      "sym",
+      "ptab",
+      "pgNum",
+      "pict",
+      "object",
+      "ruby",
+      "contentPart",
+      "annotationRef",
+      "footnoteRef",
+      "endnoteRef",
+      "separator",
+      "continuationSeparator",
+      "delText",
+      "dayShort",
+      "monthShort",
+      "yearShort",
+      "dayLong",
+      "monthLong",
+      "yearLong"
+    ],
+    RUN_CHIP
+  ]
+]);
+var PARAGRAPH_CHILDREN = [
+  [RANGE_MARKERS, HIDDEN_MARKER],
+  [PERMISSION_MARKERS, HIDDEN_MARKER],
+  [["proofErr"], IGNORABLE],
+  [REVISION_CONTAINERS, INLINE_CHIP],
+  [["fldSimple", "smartTag", "customXml", "dir", "bdo", "subDoc"], INLINE_CHIP]
+];
+var PARAGRAPH_LEVEL = new Map([
+  ...rules([
+    [["pPr", "r", "hyperlink", "sdt"], MODEL],
+    [COMMENT_RANGE_MARKERS, MODEL],
+    ...PARAGRAPH_CHILDREN
+  ]),
+  ...MATH.map((name) => [name, INLINE_CHIP])
+]);
+var WRAPPER_LEVEL = new Map([
+  ...rules([
+    [["r", "hyperlink"], MODEL],
+    [COMMENT_RANGE_MARKERS, MODEL],
+    [["sdt"], INLINE_CHIP],
+    ...PARAGRAPH_CHILDREN
+  ]),
+  ...MATH.map((name) => [name, INLINE_CHIP])
+]);
+var BLOCK_CHILDREN = [
+  [["p", "tbl"], MODEL],
+  [RANGE_MARKERS, HIDDEN_MARKER],
+  [COMMENT_RANGE_MARKERS, HIDDEN_MARKER],
+  [PERMISSION_MARKERS, HIDDEN_MARKER],
+  [["proofErr"], IGNORABLE],
+  [REVISION_CONTAINERS, BLOCK_CHIP],
+  [["sdt", "customXml", "altChunk"], BLOCK_CHIP]
+];
+var BODY_LEVEL = new Map([
+  ...rules([...BLOCK_CHILDREN, [["sectPr"], BLOCK_CHIP]]),
+  ...MATH.map((name) => [name, BLOCK_CHIP])
+]);
+var CELL_LEVEL = new Map([
+  ...rules([...BLOCK_CHILDREN, [["tcPr"], MODEL]]),
+  ...MATH.map((name) => [name, BLOCK_CHIP])
+]);
+var TABLE_LEVEL = rules([
+  [["tblPr", "tblGrid", "tr"], MODEL],
+  [RANGE_MARKERS, HIDDEN_MARKER],
+  [COMMENT_RANGE_MARKERS, HIDDEN_MARKER],
+  [PERMISSION_MARKERS, HIDDEN_MARKER],
+  [["proofErr"], IGNORABLE]
+]);
+var ROW_LEVEL = rules([
+  [["tblPrEx", "trPr", "tc", "sdt"], MODEL],
+  [RANGE_MARKERS, HIDDEN_MARKER],
+  [COMMENT_RANGE_MARKERS, HIDDEN_MARKER],
+  [PERMISSION_MARKERS, HIDDEN_MARKER],
+  [["proofErr"], IGNORABLE]
+]);
+var WML_POLICY = {
+  r: RUN_LEVEL,
+  p: PARAGRAPH_LEVEL,
+  wrapper: WRAPPER_LEVEL,
+  body: BODY_LEVEL,
+  tc: CELL_LEVEL,
+  tbl: TABLE_LEVEL,
+  tr: ROW_LEVEL
+};
+var LEVEL_PRESERVATION = {
+  r: RUN_CHIP,
+  p: INLINE_CHIP,
+  wrapper: INLINE_CHIP,
+  body: BLOCK_CHIP,
+  tc: BLOCK_CHIP
+};
+function defaultPreservation(level) {
+  return LEVEL_PRESERVATION[level];
+}
+var LEVEL_DEFAULTS = {
+  ...LEVEL_PRESERVATION,
+  tbl: { tier: "demote" },
+  tr: { tier: "demote" }
+};
+function policyFor(el, level) {
+  return WML_POLICY[level].get(clarkName(el)) ?? LEVEL_DEFAULTS[level];
+}
+function runContentText(el) {
+  const policy = policyFor(el, "r");
+  if (policy.tier === "model") {
+    switch (el.localName) {
+      case "t":
+        return el.textContent ?? "";
+      case "tab":
+        return "	";
+      case "br":
+        return "\n";
+      // A drawing and the three annotation references draw something that is not text
+      default:
+        return null;
+    }
+  }
+  if (policy.tier === "demote") return null;
+  if (policy.display === "break") return "\n";
+  return policy.display === "text" ? policy.text ?? null : null;
+}
+export {
+  WML_POLICY,
+  clarkName,
+  defaultPreservation,
+  policyFor,
+  runContentText
+};

package/dist/docx/importPreserved.d.ts

@@ -0,0 +1,30 @@
+/**
+ * One element kept exactly as it came, at whatever level of the document it stood.
+ *
+ * `./importPolicy` says what an element is worth keeping as; this is where that answer becomes a
+ * node. Every level has a node of its own - inside a run, beside the runs of a paragraph, and in
+ * the place of a block - so the three readers build them the same way and cannot drift apart in
+ * what a chip shows or which fragments a guard answers for.
+ */
+import type { Mark, Node as PMNode } from "prosemirror-model";
+import { type DemotionPolicy, type ElementPolicy, type PreservationRule, type PreservingLevel } from "./importPolicy";
+/**
+ * The rule an element is kept under.
+ *
+ * The level's own narrowest preservation stands in wherever the table said `model` and the reader
+ * could not read the element after all, so a structure it could not take apart costs that element
+ * and no more.
+ */
+export declare function preservationOf(policy: ElementPolicy | DemotionPolicy, level: PreservingLevel): PreservationRule;
+/** One child of a run kept as it came, wearing the run mark so it goes back inside that run */
+export declare function buildPreservedRunContent(el: Element, marks: readonly Mark[], rule: PreservationRule): PMNode;
+/** One child of a paragraph, or of a wrapper inside it, kept as it came */
+export declare function buildPreservedInline(el: Element, wrappers: readonly Mark[], rule: PreservationRule): PMNode;
+/**
+ * One block kept as it came, standing where it stood.
+ *
+ * A body block is one of the fragments the session holds, so it names that fragment and the bytes
+ * it arrived as go back out untouched. A block inside a cell was never a fragment of its own, so
+ * it carries its XML along with it.
+ */
+export declare function buildPreservedBlock(el: Element, srcId: string | null, level: "body" | "tc"): PMNode;

package/dist/docx/importPreserved.js

@@ -0,0 +1,54 @@
+// src/docx/importPreserved.ts
+import { serializeXml } from "../ooxml/xml.js";
+import { docxSchema } from "../schema/index.js";
+import {
+  defaultPreservation,
+  policyFor
+} from "./importPolicy.js";
+function preservedText(el, rule) {
+  if (rule.display === "text") return rule.text ?? null;
+  if (rule.display !== "chip") return null;
+  return el.textContent === "" ? null : el.textContent ?? null;
+}
+function preservedAttrs(el, rule) {
+  return {
+    xml: serializeXml(el),
+    element: el.localName,
+    display: rule.display,
+    text: preservedText(el, rule),
+    guarded: rule.guarded
+  };
+}
+function preservationOf(policy, level) {
+  return policy.tier === "model" || policy.tier === "demote" ? defaultPreservation(level) : policy;
+}
+function buildPreservedRunContent(el, marks, rule) {
+  return docxSchema.nodes.rawRunContent.create(
+    preservedAttrs(el, rule),
+    null,
+    marks
+  );
+}
+function buildPreservedInline(el, wrappers, rule) {
+  return docxSchema.nodes.rawInline.create(
+    preservedAttrs(el, rule),
+    null,
+    wrappers
+  );
+}
+function buildPreservedBlock(el, srcId, level) {
+  const rule = preservationOf(policyFor(el, level), level);
+  return docxSchema.nodes.rawBlock.create({
+    xml: srcId === null ? serializeXml(el) : null,
+    srcId,
+    name: el.nodeName,
+    display: rule.display,
+    guarded: rule.guarded
+  });
+}
+export {
+  buildPreservedBlock,
+  buildPreservedInline,
+  buildPreservedRunContent,
+  preservationOf
+};

package/dist/docx/importTable.d.ts

@@ -3,7 +3,7 @@
  * values for display. Unsupported grids return null so the caller can preserve their source XML.
  */
 import type { Node as PMNode } from "prosemirror-model";
-import { type StyleTable } from "./formatting";
+import { type FormattingContext } from "./formatting";
 import { type ImportSources } from "./importParagraph";
 /** Moves a `<w:tbl>` into a table node. null if it cannot be modelled */
-export declare function buildTable(el: Element, srcId: string | null, sources?: ImportSources, styles?: StyleTable, defaultTableStyleId?: string | null): PMNode | null;
+export declare function buildTable(el: Element, srcId: string | null, sources?: ImportSources, context?: FormattingContext): PMNode | null;

package/dist/docx/importTable.js

@@ -1,8 +1,4 @@
 // src/docx/importTable.ts
-import {
-  toCellMargins,
-  toInsideBorders
-} from "../model/format.js";
 import { childValue, wAttr } from "../ooxml/units.js";
 import {
   attrString,
@@ -13,29 +9,45 @@ import {
 import { docxSchema } from "../schema/index.js";
 import {
   layerTableFormat,
-  NO_STYLES
+  NO_FORMATTING,
+  styledParagraph,
+  tableStyleAttrs,
+  tableStyleFor
 } from "./formatting.js";
 import {
   buildParagraph,
   NO_IMPORT_SOURCES
 } from "./importParagraph.js";
+import { policyFor } from "./importPolicy.js";
+import { buildPreservedBlock } from "./importPreserved.js";
 import { readSdtWrapper } from "./sdt.js";
 import {
-  cellBorderDefaults,
-  gridEdgesOf,
+  cellConditionsOf,
+  cellDefaultsFor,
+  layerBandSizes,
   layerCellMargins,
   layerInsideBorders,
+  NO_BAND_SIZES,
   NO_CELL_MARGINS,
   NO_INSIDE_BORDERS,
+  readBandSizes,
   readCellFormat,
   readCellMarginsOf,
   readGridCols,
   readInsideBorders,
   readRowFormat,
   readTableFormat,
+  readTableLook,
   readTableWidth,
   tblStyleIdOf
 } from "./tableFormatting.js";
+function isTransparent(el, level) {
+  const tier = policyFor(el, level).tier;
+  return tier === "marker" || tier === "ignorable";
+}
+function takeGathered(gathered) {
+  return gathered.length === 0 ? null : gathered.splice(0).join("");
+}
 function readGridSpan(tcPr) {
   const value = tcPr ? childValue(tcPr, "gridSpan") : null;
   const parsed = value === null ? null : Number.parseInt(value, 10);
@@ -64,27 +76,45 @@ function readSdtCell(el) {
     }
   };
 }
+function trailCell(cells, gathered) {
+  const xml = takeGathered(gathered);
+  if (xml === null) return true;
+  const last = cells.at(-1);
+  if (!last || last.vMerge === "continue") return false;
+  last.trailingXml = (last.trailingXml ?? "") + xml;
+  return true;
+}
 function readRow(el) {
   const cells = [];
+  const gathered = [];
   let tblPrEx = null;
+  let leadingXml = null;
   for (const child of elementChildren(el)) {
     if (child.localName === "trPr") continue;
     if (child.localName === "tblPrEx") {
       tblPrEx = child;
       continue;
     }
+    if (isTransparent(child, "tr")) {
+      gathered.push(serializeXml(child));
+      continue;
+    }
     const sdt = child.localName === "sdt" ? readSdtCell(child) : null;
     if (!sdt && child.localName !== "tc") return null;
+    if (cells.length === 0) leadingXml = takeGathered(gathered);
+    else if (!trailCell(cells, gathered)) return null;
     const tc = sdt ? sdt.el : child;
     const tcPr = childByLocalName(tc, "tcPr");
     cells.push({
       el: tc,
       gridSpan: readGridSpan(tcPr),
       vMerge: readVerticalMerge(tcPr),
-      control: sdt ? sdt.control : null
+      control: sdt ? sdt.control : null,
+      trailingXml: null
     });
   }
-  return cells.length > 0 ? { el, tblPrEx, cells } : null;
+  if (cells.length === 0 || !trailCell(cells, gathered)) return null;
+  return { el, tblPrEx, cells, leadingXml, trailingXml: null };
 }
 function gridRevisionXml(grid) {
   const revision = childByLocalName(grid, "tblGridChange");
@@ -104,6 +134,8 @@ function readTableParts(el) {
   let tblGrid = null;
   let gridChange = null;
   const rows = [];
+  const gathered = [];
+  let leadingXml = null;
   for (const child of elementChildren(el)) {
     if (child.localName === "tblPr") {
       tblPr = child;
@@ -114,12 +146,22 @@ function readTableParts(el) {
       gridChange = gridRevisionXml(child);
       continue;
     }
+    if (isTransparent(child, "tbl")) {
+      gathered.push(serializeXml(child));
+      continue;
+    }
     if (child.localName !== "tr") return null;
     const row = readRow(child);
     if (!row) return null;
+    const previous = rows.at(-1);
+    if (previous) previous.trailingXml = takeGathered(gathered);
+    else leadingXml = takeGathered(gathered);
     rows.push(row);
   }
-  return rows.length > 0 ? { tblPr, tblGrid, gridChange, rows } : null;
+  const last = rows.at(-1);
+  if (!last) return null;
+  last.trailingXml = takeGathered(gathered);
+  return { tblPr, tblGrid, gridChange, rows, leadingXml };
 }
 function resolveVerticalMerges(rows, width) {
   const drafts = [];
@@ -141,7 +183,8 @@ function resolveVerticalMerges(rows, width) {
           col,
           colspan: cell.gridSpan,
           rowspan: 1,
-          control: cell.control
+          control: cell.control,
+          trailingXml: cell.trailingXml
         };
         rowDrafts.push(draft);
         if (cell.vMerge === "restart") next.set(col, draft);
@@ -162,37 +205,31 @@ function gridWidthOf(rows) {
   const first = widths[0];
   return widths.every((width) => width === first) ? first : null;
 }
-function buildCellBlock(el, sources) {
+function buildCellBlock(el, sources, context, placement) {
   if (el.localName === "p") {
-    const paragraph = buildParagraph(el, null, sources);
-    if (paragraph) return paragraph;
+    return styledParagraph(
+      buildParagraph(el, null, sources),
+      context,
+      placement
+    );
   }
-  return docxSchema.nodes.rawBlock.create({
-    xml: serializeXml(el),
-    name: el.nodeName
-  });
+  return buildPreservedBlock(el, null, "tc");
 }
-function cellBorderDefaultsFor(draft, lines) {
-  return cellBorderDefaults(
-    gridEdgesOf(
-      {
-        top: draft.row,
-        bottom: draft.row + draft.rowspan,
-        left: draft.col,
-        right: draft.col + draft.colspan
-      },
-      lines
-    ),
-    lines.outer,
-    lines.inside
-  );
+function cellRect(draft) {
+  return {
+    top: draft.row,
+    bottom: draft.row + draft.rowspan,
+    left: draft.col,
+    right: draft.col + draft.colspan
+  };
 }
-function buildCell(draft, lines, sources) {
+function buildCell(draft, table, sources, context) {
   const tcPr = childByLocalName(draft.el, "tcPr");
+  const defaults = cellDefaultsFor(cellRect(draft), table.grid, table.sources);
   const blocks = [];
   for (const child of elementChildren(draft.el)) {
     if (child.localName === "tcPr") continue;
-    blocks.push(buildCellBlock(child, sources));
+    blocks.push(buildCellBlock(child, sources, context, defaults.placement));
   }
   if (blocks.length === 0) return null;
   return docxSchema.nodes.tableCell.create(
@@ -203,22 +240,19 @@ function buildCell(draft, lines, sources) {
       tcAttrs: attrString(draft.el),
       tcPr: tcPr ? serializeXml(tcPr) : null,
       tcW: readTableWidth(tcPr, "tcW"),
-      format: readCellFormat(
-        tcPr,
-        cellBorderDefaultsFor(draft, lines),
-        lines.margins
-      ),
+      format: readCellFormat(tcPr, defaults),
       sdtPrefix: draft.control?.prefix ?? null,
       sdtContentsLocked: draft.control?.contentsLocked ?? false,
-      sdtDeletionLocked: draft.control?.deletionLocked ?? false
+      sdtDeletionLocked: draft.control?.deletionLocked ?? false,
+      trailingXml: draft.trailingXml
     },
     blocks
   );
 }
-function buildRow(row, drafts, lines, sources) {
+function buildRow(row, drafts, table, sources, context) {
   const cells = [];
   for (const draft of drafts) {
-    const cell = buildCell(draft, lines, sources);
+    const cell = buildCell(draft, table, sources, context);
     if (!cell) return null;
     cells.push(cell);
   }
@@ -228,16 +262,14 @@ function buildRow(row, drafts, lines, sources) {
       trAttrs: attrString(row.el),
       tblPrEx: row.tblPrEx ? serializeXml(row.tblPrEx) : null,
       trPr: trPr ? serializeXml(trPr) : null,
-      format: readRowFormat(trPr)
+      format: readRowFormat(trPr),
+      leadingXml: row.leadingXml,
+      trailingXml: row.trailingXml
     },
     cells
   );
 }
-function tableStyleOf(tblPr, styles, defaultTableStyleId) {
-  const styleId = tblStyleIdOf(tblPr);
-  return (styleId !== null ? styles.get(styleId) : void 0) ?? (defaultTableStyleId !== null ? styles.get(defaultTableStyleId) : void 0);
-}
-function buildTable(el, srcId, sources = NO_IMPORT_SOURCES, styles = NO_STYLES, defaultTableStyleId = null) {
+function buildTable(el, srcId, sources = NO_IMPORT_SOURCES, context = NO_FORMATTING) {
   const parts = readTableParts(el);
   if (!parts) return null;
   const gridCols = readGridCols(parts.tblGrid);
@@ -246,27 +278,38 @@ function buildTable(el, srcId, sources = NO_IMPORT_SOURCES, styles = NO_STYLES,
   if (gridCols.length > 0 && gridCols.length !== width) return null;
   const drafts = resolveVerticalMerges(parts.rows, width);
   if (!drafts) return null;
-  const style = tableStyleOf(parts.tblPr, styles, defaultTableStyleId);
+  const styleId = tblStyleIdOf(parts.tblPr);
+  const style = tableStyleFor(styleId, context);
   const tableFormat = layerTableFormat(
     style?.table ?? {},
     readTableFormat(parts.tblPr)
   );
-  const lines = {
-    rows: parts.rows.length,
-    cols: width,
-    outer: tableFormat,
-    inside: layerInsideBorders(
-      style?.tableInside ?? NO_INSIDE_BORDERS,
-      readInsideBorders(parts.tblPr)
-    ),
-    margins: layerCellMargins(
-      style?.tableCellMargins ?? NO_CELL_MARGINS,
-      readCellMarginsOf(parts.tblPr, "tblCellMar")
-    )
+  const bands = layerBandSizes(
+    style?.tableBands ?? NO_BAND_SIZES,
+    readBandSizes(parts.tblPr)
+  );
+  const conditions = cellConditionsOf(style?.tableConditions ?? {});
+  const table = {
+    grid: { rows: parts.rows.length, cols: width },
+    sources: {
+      outer: tableFormat,
+      inside: layerInsideBorders(
+        style?.tableInside ?? NO_INSIDE_BORDERS,
+        readInsideBorders(parts.tblPr)
+      ),
+      margins: layerCellMargins(
+        style?.tableCellMargins ?? NO_CELL_MARGINS,
+        readCellMarginsOf(parts.tblPr, "tblCellMar")
+      ),
+      look: readTableLook(parts.tblPr),
+      bands,
+      conditions,
+      styleId
+    }
   };
   const rows = [];
   for (const [index, row] of parts.rows.entries()) {
-    const built = buildRow(row, drafts[index], lines, sources);
+    const built = buildRow(row, drafts[index], table, sources, context);
     if (!built) return null;
     rows.push(built);
   }
@@ -278,10 +321,8 @@ function buildTable(el, srcId, sources = NO_IMPORT_SOURCES, styles = NO_STYLES,
       tblW: readTableWidth(parts.tblPr, "tblW"),
       gridCols,
       gridChange: parts.gridChange,
-      format: tableFormat,
-      // The cells need these again whenever an edit derives their display values afresh
-      styleInside: toInsideBorders(style?.tableInside),
-      styleCellMargins: toCellMargins(style?.tableCellMargins)
+      leadingXml: parts.leadingXml,
+      ...tableStyleAttrs(parts.tblPr, context)
     },
     rows
   );