@portone/docx-editor 0.2.1 → 0.4.0

package/dist/table/cellFormatting.js

@@ -8,9 +8,7 @@ import {
   NO_FILL,
   toCellFormat
 } from "../model/format.js";
-import { transactionAllowed } from "../schema/guards.js";
-import { isLockedCell } from "../schema/locks.js";
-import { editsShut } from "../schema/protectionState.js";
+import { editShut, guardedCommand } from "../schema/guards.js";
 import { cellDefaultsAt, tableCellSources } from "./gridBorders.js";
 function text(value) {
   return typeof value === "string" ? value : null;
@@ -40,8 +38,7 @@ function planChanges(rect, edit) {
     const next = editCellProps(
       text(cell.attrs.tcPr),
       edit(rect, pos),
-      cellDefaultsAt(rect.map, pos, sources),
-      sources.margins
+      cellDefaultsAt(rect.map, pos, sources)
     );
     if (!next) continue;
     changes.push({
@@ -52,19 +49,12 @@ function planChanges(rect, edit) {
   return changes;
 }
 function cellFormatCommand(edit) {
-  return (state, dispatch) => {
-    if (!pmIsInTable(state)) return false;
+  return guardedCommand((state) => {
+    if (!canSetCellFormatting(state)) return null;
     const rect = selectedRect(state);
-    if (rect.map.cellsInRect(rect).some((pos) => isLockedCell(rect.table.nodeAt(pos)))) {
-      return false;
-    }
     const changes = planChanges(rect, edit);
-    if (changes.length === 0) return false;
-    const transaction = applyChanges(state.tr, rect.tableStart, changes);
-    if (!transactionAllowed(transaction, state)) return false;
-    dispatch?.(transaction);
-    return true;
-  };
+    return changes.length === 0 ? null : applyChanges(state.tr, rect.tableStart, changes);
+  });
 }
 function shared(values) {
   const [first, ...rest] = values;
@@ -112,17 +102,18 @@ function selectedCells(state) {
   const cells = [];
   for (const pos of rect.map.cellsInRect(rect)) {
     const cell = rect.table.nodeAt(pos);
-    if (cell) cells.push(cell);
+    if (cell) cells.push({ node: cell, pos: rect.tableStart + pos });
   }
   return cells;
 }
 function cellFormats(state) {
-  return selectedCells(state).map((cell) => toCellFormat(cell.attrs.format));
+  return selectedCells(state).map(
+    ({ node }) => toCellFormat(node.attrs.format)
+  );
 }
 function canSetCellFormatting(state) {
-  if (editsShut(state)) return false;
   const cells = selectedCells(state);
-  return cells.length > 0 && cells.every((cell) => !isLockedCell(cell));
+  return cells.length > 0 && cells.every(({ pos }) => !editShut(state, { kind: "block", at: pos + 1 }));
 }
 function sharedValue(values) {
   const [first, ...rest] = values;

package/dist/table/commands.js

@@ -3,7 +3,7 @@ import {
   deleteTable as pmDeleteTable,
   isInTable as pmIsInTable
 } from "prosemirror-tables";
-import { transactionAllowed } from "../schema/guards.js";
+import { guardedCommand } from "../schema/guards.js";
 import {
   buildAddColumnAfterTransaction,
   buildAddColumnBeforeTransaction,
@@ -18,26 +18,22 @@ import {
 function isInTable(state) {
   return pmIsInTable(state);
 }
-function toCommand(build) {
-  return (state, dispatch) => {
-    const tr = build(state);
-    if (!tr || !transactionAllowed(tr, state)) return false;
-    dispatch?.(tr);
-    return true;
-  };
-}
-var addRowBefore = toCommand(
+var addRowBefore = guardedCommand(
   buildAddRowBeforeTransaction
 );
-var addRowAfter = toCommand(buildAddRowAfterTransaction);
-var deleteRow = toCommand(buildDeleteRowTransaction);
-var addColumnBefore = toCommand(
+var addRowAfter = guardedCommand(
+  buildAddRowAfterTransaction
+);
+var deleteRow = guardedCommand(
+  buildDeleteRowTransaction
+);
+var addColumnBefore = guardedCommand(
   buildAddColumnBeforeTransaction
 );
-var addColumnAfter = toCommand(
+var addColumnAfter = guardedCommand(
   buildAddColumnAfterTransaction
 );
-var deleteColumn = toCommand(
+var deleteColumn = guardedCommand(
   buildDeleteColumnTransaction
 );
 function buildDeleteTableTransaction(state) {
@@ -46,9 +42,15 @@ function buildDeleteTableTransaction(state) {
   pmDeleteTable(state, (tr) => captured.push(tr));
   return captured[0] ?? null;
 }
-var deleteTable = toCommand(buildDeleteTableTransaction);
-var mergeCells = toCommand(buildMergeCellsTransaction);
-var splitCell = toCommand(buildSplitCellTransaction);
+var deleteTable = guardedCommand(
+  buildDeleteTableTransaction
+);
+var mergeCells = guardedCommand(
+  buildMergeCellsTransaction
+);
+var splitCell = guardedCommand(
+  buildSplitCellTransaction
+);
 export {
   addColumnAfter,
   addColumnBefore,

package/dist/table/format.d.ts

@@ -2,6 +2,9 @@
  * Newly created cells and rows inherit only the formatting of the cell or row they
  * are based on. Values that have to be recomputed from the grid (colspan, rowspan,
  * colwidth) are not inherited.
+ *
+ * What that comes to per attr is `docx/cloning`, which answers the same question for a
+ * paragraph an edit makes out of another paragraph.
  */
 import type { Node as PMNode } from "prosemirror-model";
 import type { GridRect } from "../docx/tableFormatting";

package/dist/table/format.js

@@ -1,4 +1,5 @@
 // src/table/format.ts
+import { CLONE_POLICIES } from "../docx/cloning.js";
 function isNumberArray(value) {
   return Array.isArray(value) && value.every((entry) => typeof entry === "number");
 }
@@ -6,18 +7,11 @@ function colwidthOf(cell) {
   const value = cell.attrs.colwidth;
   return isNumberArray(value) ? value : null;
 }
-var INHERITED_CELL_ATTRS = ["tcAttrs", "tcPr", "tcW", "format"];
 function inheritCellAttrs(cell, overrides = {}) {
-  const attrs = {};
-  for (const key of INHERITED_CELL_ATTRS) attrs[key] = cell.attrs[key];
-  return { ...attrs, ...overrides };
+  return { ...CLONE_POLICIES.tableCell.attrs(cell, "copy"), ...overrides };
 }
-var INHERITED_ROW_ATTRS = ["trAttrs", "trPr", "format"];
 function inheritRowAttrs(row) {
-  if (!row) return null;
-  const attrs = {};
-  for (const key of INHERITED_ROW_ATTRS) attrs[key] = row.attrs[key];
-  return attrs;
+  return row ? CLONE_POLICIES.tableRow.attrs(row, "copy") : null;
 }
 export {
   colwidthOf,

package/dist/table/gridBorders.d.ts

@@ -1,42 +1,36 @@
 /**
- * The lines a cell draws because of where it sits in the grid, kept true after a structure edit.
+ * The lines and the fill a cell draws because of where it sits in the grid.
  *
  * Every line of a table is drawn by its cells (see `docx/tableFormatting`), so which line a side
- * falls back on depends on where in the grid the cell sits. A new cell inherits its neighbour's
- * formatting, which is what a background has to do but not a line: the row appended under the last
- * one would draw the table's outer line against the row above it, and deleting the last row would
- * leave the table with no line along its bottom.
+ * falls back on depends on where in the grid the cell sits, and so does which parts of the table
+ * style dress it. A new cell inherits its neighbour's formatting, which is what a background has to
+ * do but not a line: the row appended under the last one would draw the table's outer line against
+ * the row above it, and deleting the last row would leave the table with no line along its bottom.
+ * A row added under the header row is likewise no header row.
  *
  * So the cells of a table whose grid moved derive their display values again, along the same path
  * the import takes. What a cell wrote down itself lives in its `w:tcPr` and is read straight back
- * out of it, so only the share that came from the table can change.
+ * out of it, so only the share that came from the table can change. `cellFixes` says which cells
+ * carry the wrong lines and `sameFormattingInputs` whether anything they depend on moved; the
+ * deriver that runs them after an edit is `editor/plugins/tableDisplay`.
  */
 import type { Node as PMNode } from "prosemirror-model";
-import { Plugin } from "prosemirror-state";
-import { type CellBorderDefaults } from "../docx/tableFormatting";
-import { type CellMargins, type InsideBorders, type TableFormat } from "../model/format";
-import type { TableGridMap } from "./format";
+import { type CellDefaults, type TableCellSources } from "../docx/tableFormatting";
+import type { NodeAttrs, TableGridMap } from "./format";
 /**
- * What a table lays down for its cells to draw.
+ * What this table lays down for its cells to draw.
  * The values a table style laid down are not in the `tblPr`, so the table carries them separately.
+ * A node never changes once it is built, so what is read out of one is read once.
  */
-export interface TableCellSources {
-    outer: TableFormat | null;
-    inside: InsideBorders;
-    margins: CellMargins;
-}
 export declare function tableCellSources(table: PMNode): TableCellSources;
-/** The lines the cell at this position falls back on for the sides it draws no border of its own on */
-export declare function cellDefaultsAt(map: TableGridMap, pos: number, sources: TableCellSources): CellBorderDefaults;
-/** Derives shared-border display values before the first editor view is drawn. */
-export declare function withDerivedGridBorders(doc: PMNode): PMNode;
-/**
- * Keeps the derived lines current after a table's grid or border inputs change.
- *
- * The tables are paired up by the order they stand in. A document that gained or lost a whole table
- * pairs the ones after it with the wrong partner, which costs a derivation that changes no cell.
- *
- * No transaction of its own goes to the history: ProseMirror hands an appended transaction to the
- * history as part of the same event, so a single undo takes the edit and this correction back together.
- */
-export declare function gridBorders(): Plugin;
+/** What the cell at this position falls back on for everything it did not write down itself */
+export declare function cellDefaultsAt(map: TableGridMap, pos: number, sources: TableCellSources): CellDefaults;
+export interface CellFix {
+    /** The position of the cell within the table's content */
+    pos: number;
+    attrs: NodeAttrs;
+}
+/** The cells of this table whose display values do not match the spot they now sit in */
+export declare function cellFixes(table: PMNode): CellFix[];
+/** Whether everything the cells' lines are derived from reads the same in both tables */
+export declare function sameFormattingInputs(a: PMNode, b: PMNode): boolean;

package/dist/table/gridBorders.js

@@ -1,32 +1,39 @@
 // src/table/gridBorders.ts
-import { Plugin } from "prosemirror-state";
 import { TableMap } from "prosemirror-tables";
-import { Transform } from "prosemirror-transform";
 import {
-  cellBorderDefaults,
+  cellDefaultsFor,
   cellMarginsOf,
-  gridEdgesOf,
   insideBordersOf,
   layerCellMargins,
   layerInsideBorders,
-  NO_BORDER_DEFAULTS,
+  NO_BAND_SIZES,
+  NO_CELL_DEFAULTS,
   NO_CELL_MARGINS,
   NO_INSIDE_BORDERS,
-  readCellProps
+  NO_TABLE_STYLE_CONDITIONS,
+  readCellProps,
+  readTableLook,
+  tblStyleIdOf
 } from "../docx/tableFormatting.js";
 import {
   spanCount,
+  toBandSizes,
   toCellFormat,
   toCellMargins,
   toInsideBorders,
-  toTableFormat
+  toTableFormat,
+  toTableStyleConditions
 } from "../model/format.js";
+import { parsePropsXml } from "../ooxml/props.js";
 function text(value) {
   return typeof value === "string" ? value : null;
 }
 function tableCellSources(table) {
+  const known = sourcesByTable.get(table);
+  if (known) return known;
   const tblPr = text(table.attrs.tblPr);
-  return {
+  const props = tblPr === null ? null : parsePropsXml(tblPr);
+  const sources = {
     outer: toTableFormat(table.attrs.format),
     inside: layerInsideBorders(
       toInsideBorders(table.attrs.styleInside) ?? NO_INSIDE_BORDERS,
@@ -35,14 +42,23 @@ function tableCellSources(table) {
     margins: layerCellMargins(
       toCellMargins(table.attrs.styleCellMargins) ?? NO_CELL_MARGINS,
       cellMarginsOf(tblPr)
-    )
+    ),
+    look: readTableLook(props),
+    bands: toBandSizes(table.attrs.styleBands) ?? NO_BAND_SIZES,
+    conditions: toTableStyleConditions(table.attrs.styleConditions) ?? NO_TABLE_STYLE_CONDITIONS,
+    // The style the paragraphs inside resolve against; what it lays down for the cells is already
+    // in `styleConditions`
+    styleId: tblStyleIdOf(props)
   };
+  sourcesByTable.set(table, sources);
+  return sources;
 }
+var sourcesByTable = /* @__PURE__ */ new WeakMap();
 function cellDefaultsAt(map, pos, sources) {
-  return cellBorderDefaults(
-    gridEdgesOf(map.findCell(pos), { rows: map.height, cols: map.width }),
-    sources.outer,
-    sources.inside
+  return cellDefaultsFor(
+    map.findCell(pos),
+    { rows: map.height, cols: map.width },
+    sources
   );
 }
 var CELL_FORMAT_KEYS = [
@@ -108,16 +124,12 @@ function cellFixes(table) {
     const cell = table.nodeAt(pos);
     if (!cell) continue;
     const tcPr = text(cell.attrs.tcPr);
-    const format = readCellProps(
-      tcPr,
-      cellDefaultsAt(map, pos, sources),
-      sources.margins
-    );
+    const format = readCellProps(tcPr, cellDefaultsAt(map, pos, sources));
     cells.set(pos, {
       pos,
       attrs: cell.attrs,
       format: { ...format },
-      direct: readCellProps(tcPr, NO_BORDER_DEFAULTS)
+      direct: readCellProps(tcPr, NO_CELL_DEFAULTS)
     });
   }
   reconcileSharedBorders(map, cells);
@@ -129,14 +141,6 @@ function cellFixes(table) {
   }
   return fixes;
 }
-function tablesOf(doc) {
-  const tables = [];
-  doc.descendants((node, pos) => {
-    if (node.type.spec.tableRole === "table") tables.push({ pos, table: node });
-    return !node.isTextblock;
-  });
-  return tables;
-}
 function sameSpans(a, b) {
   return spanCount(a.attrs.colspan) === spanCount(b.attrs.colspan) && spanCount(a.attrs.rowspan) === spanCount(b.attrs.rowspan);
 }
@@ -154,39 +158,11 @@ function sameCellFormattingInputs(a, b) {
   );
 }
 function sameFormattingInputs(a, b) {
-  return sameGrid(a, b) && a.attrs.tblPr === b.attrs.tblPr && a.attrs.format === b.attrs.format && a.attrs.styleInside === b.attrs.styleInside && a.attrs.styleCellMargins === b.attrs.styleCellMargins && sameCellFormattingInputs(a, b);
-}
-function withDerivedGridBorders(doc) {
-  const transform = new Transform(doc);
-  for (const { pos, table } of tablesOf(doc)) {
-    for (const fix of cellFixes(table)) {
-      transform.setNodeMarkup(pos + 1 + fix.pos, null, fix.attrs);
-    }
-  }
-  return transform.doc;
-}
-function gridBorders() {
-  return new Plugin({
-    appendTransaction(transactions, oldState, newState) {
-      if (!transactions.some((transaction) => transaction.docChanged)) {
-        return null;
-      }
-      const before = tablesOf(oldState.doc);
-      const tr = newState.tr;
-      tablesOf(newState.doc).forEach(({ pos, table }, index) => {
-        const was = before[index]?.table;
-        if (was && sameFormattingInputs(was, table)) return;
-        for (const fix of cellFixes(table)) {
-          tr.setNodeMarkup(pos + 1 + fix.pos, null, fix.attrs);
-        }
-      });
-      return tr.docChanged ? tr : null;
-    }
-  });
+  return sameGrid(a, b) && a.attrs.tblPr === b.attrs.tblPr && a.attrs.format === b.attrs.format && a.attrs.styleInside === b.attrs.styleInside && a.attrs.styleCellMargins === b.attrs.styleCellMargins && a.attrs.styleConditions === b.attrs.styleConditions && a.attrs.styleBands === b.attrs.styleBands && sameCellFormattingInputs(a, b);
 }
 export {
   cellDefaultsAt,
-  gridBorders,
-  tableCellSources,
-  withDerivedGridBorders
+  cellFixes,
+  sameFormattingInputs,
+  tableCellSources
 };

package/dist/table/merge.d.ts

@@ -7,17 +7,13 @@ import type { EditorState, Transaction } from "prosemirror-state";
  * Whether several cells can be merged into one.
  * The selection has to be a rectangle spanning more than one cell, no merged cell may stick out
  * past that rectangle, and the guards have to let the merge through: a locked cell may not be
- * swallowed by another (`schema/locks`).
- *
- * The two queries are defined from the very transaction the commands run, so they cannot drift
- * from them. They live here rather than beside the commands because `./commands` imports these
- * builders, and the other way round would turn that import around.
+ * swallowed by another (`schema/guards`).
  */
 export declare function canMergeCells(state: EditorState): boolean;
 /**
  * Whether a split is possible. The cursor has to sit inside a cell that is merged horizontally or
  * vertically, and the guards have to let the split through: the cells a split makes would each
- * carry the original's lock, which is a lock planted in places it was never put (`schema/locks`).
+ * carry the original's lock, which is a lock planted in places it was never put (`schema/guards`).
  */
 export declare function canSplitCell(state: EditorState): boolean;
 /**

package/dist/table/merge.js

@@ -11,7 +11,7 @@ import {
   widthNumber,
   withWidthNumber
 } from "../model/format.js";
-import { transactionAllowed } from "../schema/guards.js";
+import { guardedCommand } from "../schema/guards.js";
 import { inheritCellAttrs } from "./format.js";
 import { cellWidthForGridCol, gridSpanWidth, tableGridCols } from "./widths.js";
 function tableAfter(tr, tableStart) {
@@ -24,13 +24,13 @@ function cellAt(rect, row, col) {
   const pos = rect.map.map[row * rect.map.width + col];
   return pos == null ? null : rect.table.nodeAt(pos);
 }
+var merging = guardedCommand(buildMergeCellsTransaction);
+var splitting = guardedCommand(buildSplitCellTransaction);
 function canMergeCells(state) {
-  const tr = buildMergeCellsTransaction(state);
-  return tr !== null && transactionAllowed(tr, state);
+  return merging(state);
 }
 function canSplitCell(state) {
-  const tr = buildSplitCellTransaction(state);
-  return tr !== null && transactionAllowed(tr, state);
+  return splitting(state);
 }
 function coveredWidthSum(rect, type) {
   let sum = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portone/docx-editor",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "A simple DOCX editor for React, built directly on OOXML.",
   "license": "Apache-2.0",
   "type": "module",
@@ -107,17 +107,21 @@
     "build:demo": "vite build --config demo/vite.config.ts",
     "dev:site": "pnpm --filter @portone/docx-editor-site dev",
     "build:site": "pnpm --filter @portone/docx-editor-site build",
-    "check": "pnpm lint && pnpm typecheck && pnpm test",
+    "check": "pnpm lint && pnpm typecheck && pnpm test && pnpm test:fixtures && pnpm test:site-release && pnpm check:demo-library",
     "typecheck": "tsc --noEmit && tsc --noEmit -p e2e && tsc --noEmit -p demo && pnpm --filter @portone/docx-editor-site typecheck",
     "lint": "pnpm biome check . --diagnostic-level=error",
     "test": "vitest run",
+    "test:fixtures": "node --test scripts/sanitize-fixture.test.mjs",
     "test:package": "vitest run --dir packaging --no-file-parallelism",
     "verify:package": "node scripts/verify-package.mjs",
+    "check:demo-library": "node scripts/demo-library-pin.mjs",
+    "pin:demo-library": "node scripts/demo-library-pin.mjs --write",
     "api:update": "pnpm build && node scripts/api-report.mjs --local",
     "spec": "node scripts/index-ooxml-spec.mjs",
     "changeset": "changeset",
     "changeset:version": "changeset version",
-    "test:e2e": "playwright test"
+    "test:e2e": "playwright test",
+    "test:site-release": "node --test scripts/site-release.test.mjs"
   },
   "types": "./dist/index.d.ts"
 }

package/dist/docx/comments/contentTypes.d.ts

@@ -1,7 +0,0 @@
-/** Declares a part an export adds in `[Content_Types].xml`, leaving the original text as it came. */
-/**
- * The content types part with an override for this part, or null when it already declares one.
- * `current` is the part as an earlier addition in the same export left it, so that two additions
- * do not each write over the other's declaration.
- */
-export declare function withContentType(parts: Map<string, Uint8Array>, partPath: string, contentType: string, current: Uint8Array | undefined): Uint8Array | null;

package/dist/docx/comments/contentTypes.js

@@ -1,38 +0,0 @@
-// src/docx/comments/contentTypes.ts
-import { DocxExportError } from "../../ooxml/errors.js";
-import { decodeUtf8, encodeUtf8 } from "../../ooxml/xml.js";
-import { CONTENT_TYPES_PATH } from "./constants.js";
-var TYPES_OPEN_TAG = /<(?:[\w.-]+:)?Types\b[^>]*>/;
-function withContentType(parts, partPath, contentType, current) {
-  const original = current ?? parts.get(CONTENT_TYPES_PATH);
-  if (!original) {
-    throw new DocxExportError(
-      "missing-content-types",
-      `cannot add a part to a package that has no ${CONTENT_TYPES_PATH}`
-    );
-  }
-  const { text, hadBom } = decodeUtf8(original);
-  const partName = `/${partPath}`;
-  if (new RegExp(
-    `<(?:[\\w.-]+:)?Override[^>]+PartName=["']${partName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']`,
-    "i"
-  ).test(text)) {
-    return null;
-  }
-  const open = TYPES_OPEN_TAG.exec(text);
-  if (!open) {
-    throw new DocxExportError(
-      "malformed-xml",
-      `${CONTENT_TYPES_PATH} has no Types element`
-    );
-  }
-  const rootName = /^<([^\s>]+)/.exec(open[0])?.[1] ?? "Types";
-  const separator = rootName.indexOf(":");
-  const prefix = separator < 0 ? "" : `${rootName.slice(0, separator)}:`;
-  const declaration = `<${prefix}Override PartName="${partName}" ContentType="${contentType}"/>`;
-  const at = open.index + open[0].length;
-  return encodeUtf8(text.slice(0, at) + declaration + text.slice(at), hadBom);
-}
-export {
-  withContentType
-};