@portone/docx-editor 0.2.0 → 0.2.1

package/dist/page/pageLayout.d.ts

@@ -10,6 +10,8 @@
  * document breaks at Letter's height and fits its tables to Letter's width.
  */
 import { type PageGeometry } from "../docx/pageGeometry";
+import type { MeasuredBlock, PageCut } from "./blockKinds";
+export type { MeasuredBlock };
 /** The paper measured in the pixels the sheet is drawn with */
 export interface PagePixels {
     /** The whole sheet, padding included */
@@ -45,44 +47,6 @@ export declare const A4_PAGE_PIXELS: PagePixels;
  * moment before a document is opened.
  */
 export declare function pageGeometryStyle(page: PagePixels): string;
-/** One body block as drawn on screen */
-export interface MeasuredBlock {
-    /** The position where this block starts in the document */
-    pos: number;
-    /** The height that naturally opens up between the previous block and this one */
-    gap: number;
-    height: number;
-    /** Set when the document records that a new page starts at this block */
-    breakBefore: boolean;
-    /**
-     * Every page break inside the block, in document order, each measured from the block's own top
-     * so that the block can be laid out wherever it lands.
-     * That top is the one the block would be drawn at with no space in it, so a space opened at one
-     * break shifts the ones after it.
-     */
-    breaks: readonly number[];
-    /** Row boundaries available when this block is an editable table */
-    table?: MeasuredTable;
-}
-/** A row that may start the continued part of a table */
-export interface TableBoundary {
-    /** The row's document position */
-    pos: number;
-    /** Its top measured from the table's natural top */
-    offset: number;
-}
-/** The measurements needed to continue a table without changing the document */
-export interface MeasuredTable {
-    boundaries: readonly TableBoundary[];
-    /** The smallest useful first piece: headers followed by one body row group */
-    firstPageMinimum: number;
-    repeatHeaderHeight: number;
-    /** Document positions of the contiguous header rows at the start of the table */
-    headerRows: readonly number[];
-    /** Changes when any projected header content or formatting changes */
-    headerSignature: string;
-    columns: number;
-}
 /** The space opened up at one page break, so that what follows it starts the next page */
 export interface BreakSpace {
     /** The position where the block holding the break starts */
@@ -148,8 +112,8 @@ export interface PageStart {
 export interface PageLayout {
     /** Only the blocks to be moved down to the next page */
     pushes: BlockPush[];
-    spaces: BreakSpace[];
-    tableContinuations: TableContinuation[];
+    /** Where the layout parted a block, and the space it opened before the continued piece */
+    cuts: PageCut[];
     splits: PageSplit[];
     /** One per page, the first page included */
     pages: PageStart[];
@@ -169,8 +133,9 @@ export interface PageLayoutInput {
  * blocks below it move down by the same amount.
  * A block taller than one page cannot be pushed, so it is left where it is and only the
  * places it crosses are reported.
- * A page break inside a block is filled out to the end of the page it falls on, which carries
- * the rest of that block - the rest of the sentence, the rest of the list item - to the top of
- * the next page while the block itself stays whole.
+ * A block is parted only where its measurer offered a candidate. A forced one - a page break
+ * written into the text - is filled out to the end of the page it falls on, which carries the rest
+ * of that block to the top of the next page while the block itself stays whole. An optional one -
+ * a row boundary in a table - is taken only where the piece after it would run off the page.
  */
 export declare function pageLayout({ blocks, pageBodyHeight, pageStep, }: PageLayoutInput): PageLayout;

package/dist/page/pageLayout.js

@@ -47,8 +47,7 @@ function pageLayout({
   pageStep
 }) {
   const pushes = [];
-  const spaces = [];
-  const tableContinuations = [];
+  const cuts = [];
   const splits = [];
   const firstPage = {
     page: 1,
@@ -58,14 +57,7 @@ function pageLayout({
   };
   const pages = [firstPage];
   if (!(pageBodyHeight > 0)) {
-    return {
-      pushes,
-      spaces,
-      tableContinuations,
-      splits,
-      pages,
-      bodyHeight: 0
-    };
+    return { pushes, cuts, splits, pages, bodyHeight: 0 };
   }
   let pageStart = 0;
   let cursor = 0;
@@ -82,11 +74,12 @@ function pageLayout({
       split(pageStart + pageBodyHeight, true, false);
     }
   };
+  let breakAfterPrevious = false;
   for (const block of blocks) {
     const pageEnd = pageStart + pageBodyHeight;
     const top = cursor + block.gap;
-    const startsPage = block.breakBefore && top > pageStart + TOLERANCE_PX;
-    const first = block.breaks[0] ?? block.table?.firstPageMinimum ?? block.height;
+    const startsPage = (block.breakBefore || breakAfterPrevious) && top > pageStart + TOLERANCE_PX;
+    const first = block.minFirstPiece;
     const overflows = top + first > pageEnd + TOLERANCE_PX;
     const fits = first <= pageBodyHeight + TOLERANCE_PX;
     const push = startsPage || overflows && fits ? Math.max(0, pageEnd + pageStep - top) : 0;
@@ -98,51 +91,35 @@ function pageLayout({
         push: round(push)
       });
     }
-    let contentTop = top + push;
-    for (const [index, offset] of block.breaks.entries()) {
-      const breakY = contentTop + offset;
-      crossTo(breakY);
-      split(pageStart + pageBodyHeight, false, true);
-      const height = Math.max(0, pageStart - breakY);
-      spaces.push({ pos: block.pos, index, height: round(height) });
-      contentTop += height;
-    }
-    let tableAdded = 0;
-    if (block.table) {
-      let segmentStart = 0;
-      for (let index = 0; index <= block.table.boundaries.length; index += 1) {
-        const segmentEnd = block.table.boundaries[index]?.offset ?? block.height;
-        const segmentTop = contentTop + segmentStart + tableAdded;
-        let segmentBottom = contentTop + segmentEnd + tableAdded;
-        const pageEnd2 = pageStart + pageBodyHeight;
-        const overflows2 = segmentBottom > pageEnd2 + TOLERANCE_PX;
-        const boundary = index === 0 ? null : block.table.boundaries[index - 1];
-        const segmentHeight = segmentEnd - segmentStart;
-        if (overflows2 && boundary && segmentTop > pageStart + TOLERANCE_PX && segmentHeight <= pageBodyHeight + TOLERANCE_PX) {
-          split(pageEnd2, false, false);
-          const height = Math.max(0, pageStart - segmentTop);
-          tableContinuations.push({
-            pos: boundary.pos,
-            height: round(height),
-            headerRows: block.table.headerRows,
-            headerSignature: block.table.headerSignature,
-            columns: block.table.columns
-          });
-          tableAdded += height + block.table.repeatHeaderHeight;
-          segmentBottom = contentTop + segmentEnd + tableAdded;
+    const contentTop = top + push;
+    let added = 0;
+    let pieceStart = 0;
+    for (let index = 0; index <= block.candidates.length; index += 1) {
+      const cut = index === 0 ? null : block.candidates[index - 1];
+      const pieceEnd = block.candidates[index]?.offset ?? block.height;
+      const pieceTop = contentTop + pieceStart + added;
+      let pieceBottom = contentTop + pieceEnd + added;
+      if (cut) {
+        if (cut.forced) crossTo(pieceTop);
+        const pageBottom = pageStart + pageBodyHeight;
+        const cutHere = cut.forced || pieceBottom > pageBottom + TOLERANCE_PX && pieceTop > pageStart + TOLERANCE_PX && pieceEnd - pieceStart <= pageBodyHeight + TOLERANCE_PX;
+        if (cutHere) {
+          split(pageBottom, false, cut.forced);
+          const height = Math.max(0, pageStart - pieceTop);
+          cuts.push({ at: cut.at, height: round(height) });
+          added += height + cut.repeatHeight;
+          pieceBottom += height + cut.repeatHeight;
         }
-        crossTo(segmentBottom);
-        segmentStart = segmentEnd;
       }
+      crossTo(pieceBottom);
+      pieceStart = pieceEnd;
     }
-    const bottom = contentTop + block.height + tableAdded;
-    crossTo(bottom);
-    cursor = bottom;
+    cursor = contentTop + block.height + added;
+    breakAfterPrevious = block.breakAfter;
   }
   return {
     pushes,
-    spaces,
-    tableContinuations,
+    cuts,
     splits,
     pages,
     bodyHeight: round(pageStart + pageBodyHeight)

package/dist/page/tableMeasurements.d.ts

@@ -1,10 +1,18 @@
 /** Measures safe row boundaries without treating pagination decorations as document content. */
 import type { Node as PMNode } from "prosemirror-model";
 import type { EditorView } from "prosemirror-view";
-import type { MeasuredTable } from "./pageLayout";
+import type { BreakCandidate } from "./blockKinds";
 export interface TableMeasure {
-    table: MeasuredTable;
+    /** Every row that may start the continued part of the table */
+    candidates: readonly BreakCandidate[];
+    /** The smallest useful first piece: headers followed by one body row group */
+    minFirstPiece: number;
     /** Height already added by the previous pagination pass */
     appliedHeight: number;
+    /** Document positions of the contiguous header rows at the start of the table */
+    headerRows: readonly number[];
+    /** Changes when any projected header content or formatting changes */
+    headerSignature: string;
+    columns: number;
 }
 export declare function measureTable(view: EditorView, tableNode: PMNode, tablePos: number, tableDom: HTMLElement, scale?: number): TableMeasure | null;

package/dist/page/tableMeasurements.js

@@ -81,33 +81,37 @@ function measureTable(view, tableNode, tablePos, tableDom, scale = 1) {
   if (rows.length === 0) return null;
   const headers = headerCount(rows);
   const unsafe = unsafeBoundaries(rows);
-  const boundaries = [];
+  const headerRows = rows.slice(0, headers);
+  const repeatHeaderHeight = headerRows.reduce(
+    (total, row) => total + row.height,
+    0
+  );
+  const candidates = [];
   for (let rowIndex = Math.max(1, headers); rowIndex < rows.length; rowIndex += 1) {
     const row = rows[rowIndex];
     if (row && !unsafe.has(rowIndex)) {
-      boundaries.push({ pos: row.pos, offset: row.top });
+      candidates.push({
+        at: row.pos,
+        offset: row.top,
+        forced: false,
+        repeatHeight: repeatHeaderHeight
+      });
     }
   }
-  const repeatHeaderHeight = rows.slice(0, headers).reduce((total, row) => total + row.height, 0);
-  const firstBodyBoundary = boundaries.find(
-    (boundary) => boundary.offset > repeatHeaderHeight + 0.5
+  const firstBodyBoundary = candidates.find(
+    (candidate) => candidate.offset > repeatHeaderHeight + 0.5
   );
   const appliedHeight = appliedRows.reduce(
     (total, row) => total + row.getBoundingClientRect().height / scale,
     0
   );
   return {
-    table: {
-      boundaries,
-      firstPageMinimum: firstBodyBoundary?.offset ?? tableDom.getBoundingClientRect().height / scale - appliedHeight,
-      repeatHeaderHeight,
-      headerRows: rows.slice(0, headers).map((row) => row.pos),
-      headerSignature: JSON.stringify(
-        rows.slice(0, headers).map((row) => row.node.toJSON())
-      ),
-      columns: columnCount(tableNode)
-    },
-    appliedHeight
+    candidates,
+    minFirstPiece: firstBodyBoundary?.offset ?? tableDom.getBoundingClientRect().height / scale - appliedHeight,
+    appliedHeight,
+    headerRows: headerRows.map((row) => row.pos),
+    headerSignature: JSON.stringify(headerRows.map((row) => row.node.toJSON())),
+    columns: columnCount(tableNode)
   };
 }
 export {

package/dist/page/usePageLayout.d.ts

@@ -8,9 +8,13 @@
  * in Japanese or Chinese stays open across a whole clause while the text grows line by line. So no
  * measurement is taken while a composition is open: the frame is taken again until it is over.
  */
+import type { Node as PMNode } from "prosemirror-model";
 import type { EditorView } from "prosemirror-view";
 import { type RefObject } from "react";
 import type { PageGeometry } from "../docx/pageGeometry";
+import type { PageCut } from "./blockKinds";
+import { type TableHeaderProjection } from "./measureBlocks";
+import { type BreakSpace, type TableContinuation } from "./pageLayout";
 /** One place where a page parts from the next. The position is measured on the sheet */
 export interface PageMark {
     page: number;
@@ -53,5 +57,16 @@ interface PageLayoutOptions {
     /** The paper the open document names. A4 where a document names none */
     geometry?: PageGeometry;
 }
+/**
+ * The layout's cuts as the two kinds of mark the decorations still take.
+ *
+ * A cut names the position the continued piece starts at, and which of the two it is follows from
+ * what stands there: a page `br` the block it sits in counted, or a table row. This stands in
+ * until the decorations take the cuts themselves.
+ */
+export declare function cutsToLegacyMarks(cuts: readonly PageCut[], tables: ReadonlyMap<number, TableHeaderProjection>, doc: PMNode): {
+    spaces: BreakSpace[];
+    tableContinuations: TableContinuation[];
+};
 export declare function usePageLayout({ view, layer, enabled, revision, geometry, }: PageLayoutOptions): PageOverlay | null;
 export {};

package/dist/page/usePageLayout.js

@@ -9,6 +9,7 @@ import {
 import { editorCssVariables } from "../styles/classNames.js";
 import { measureSheet } from "./measureBlocks.js";
 import {
+  pageBreaksIn,
   setPageBreakSpaces,
   setPagePushes,
   setTableContinuations
@@ -52,6 +53,27 @@ function useFrameThrottle(run, hold) {
 function sameOverlay(a, b) {
   return a !== null && a.left === b.left && a.top === b.top && a.width === b.width && a.sheetHeight === b.sheetHeight && JSON.stringify(a.marks) === JSON.stringify(b.marks) && JSON.stringify(a.badges) === JSON.stringify(b.badges) && JSON.stringify(a.pages) === JSON.stringify(b.pages);
 }
+function cutsToLegacyMarks(cuts, tables, doc) {
+  const spaces = [];
+  const tableContinuations = [];
+  for (const cut of cuts) {
+    const pos = doc.resolve(cut.at).before(1);
+    const block = doc.nodeAt(pos);
+    if (!block) continue;
+    const index = pageBreaksIn(block, pos).findIndex(
+      (found) => found.at === cut.at
+    );
+    if (index >= 0) {
+      spaces.push({ pos, index, height: cut.height });
+      continue;
+    }
+    const headers = tables.get(pos);
+    if (headers) {
+      tableContinuations.push({ pos: cut.at, height: cut.height, ...headers });
+    }
+  }
+  return { spaces, tableContinuations };
+}
 function usePageLayout({
   view,
   layer,
@@ -74,9 +96,14 @@ function usePageLayout({
         pageBodyHeight: page.bodyHeight,
         pageStep: page.pageStep
       });
+      const marks = cutsToLegacyMarks(
+        layout.cuts,
+        measured.tables,
+        view.state.doc
+      );
       setPagePushes(view, layout.pushes);
-      setPageBreakSpaces(view, layout.spaces);
-      setTableContinuations(view, layout.tableContinuations);
+      setPageBreakSpaces(view, marks.spaces);
+      setTableContinuations(view, marks.tableContinuations);
       const sheetHeight = measured.contentTop + layout.bodyHeight + measured.contentBottom;
       box.style.setProperty(editorCssVariables.sheetHeight, `${sheetHeight}px`);
       const next = {
@@ -137,5 +164,6 @@ function usePageLayout({
   return enabled ? overlay : null;
 }
 export {
+  cutsToLegacyMarks,
   usePageLayout
 };

package/dist/schema/attrRoles.d.ts

@@ -0,0 +1,35 @@
+/**
+ * What each attr of the schema is for, so that a judgement about a node can say which of them it
+ * is judging.
+ *
+ * An attr is one of three things. A `source` attr is what the exporter writes from: the XML the
+ * file arrived as, or a value the model owns that replaces part of it. A `display` attr is worked
+ * out from the source and the formatting around it, is never written, and is free to change the
+ * moment the surroundings do. A `session` attr says which block, control or link of the open
+ * document this is, and is never written either.
+ *
+ * The split exists because a display value changing is not the document changing. Opening a file
+ * in the editor re-derives a table's cell borders (`table/gridBorders`), and a comparison that
+ * counted that as an edit would rewrite a table nobody touched, losing the markup the writer does
+ * not model. `./sourceEquality` leaves display attrs out for that reason, and keeps session attrs
+ * in: two blocks that came from different places in the file are different blocks.
+ *
+ * `attrRoles.test.ts` holds this table against the schema in both directions, so an attr added
+ * without a role fails there before it can reach a judgement that does not know what to do with it.
+ */
+import { type MarkType, NodeType } from "prosemirror-model";
+export type AttrRole = "source" | "display" | "session";
+type AttrRoles = Readonly<Record<string, Readonly<Record<string, AttrRole>>>>;
+export declare const NODE_ATTR_ROLES: AttrRoles;
+export declare const MARK_ATTR_ROLES: AttrRoles;
+/**
+ * What this attr of this node or mark is for.
+ *
+ * An attr with no role declared is read as `source`: a judgement then compares it, which is the
+ * answer that reports a change rather than hiding one. `attrRoles.test.ts` is what keeps the case
+ * from arising.
+ */
+export declare function attrRole(type: NodeType | MarkType, name: string): AttrRole;
+/** The attrs of this node or mark that are worked out rather than written */
+export declare function displayAttrsOf(type: NodeType | MarkType): readonly string[];
+export {};

package/dist/schema/attrRoles.js

@@ -0,0 +1,106 @@
+// src/schema/attrRoles.ts
+import { NodeType } from "prosemirror-model";
+var NODE_ATTR_ROLES = {
+  paragraph: {
+    srcId: "session",
+    pAttrs: "source",
+    pPr: "source",
+    format: "display",
+    styleRun: "display"
+  },
+  table: {
+    srcId: "session",
+    tblAttrs: "source",
+    tblPr: "source",
+    tblW: "source",
+    gridCols: "source",
+    format: "display",
+    styleInside: "display",
+    styleCellMargins: "display"
+  },
+  tableRow: {
+    trAttrs: "source",
+    tblPrEx: "source",
+    trPr: "source",
+    format: "display"
+  },
+  tableCell: {
+    colspan: "source",
+    rowspan: "source",
+    // prosemirror-tables' own attr. Import writes null, the writer never reads it, and the table
+    // commands only carry it from one cell to another; a real column resize moves `gridCols`
+    colwidth: "display",
+    tcAttrs: "source",
+    tcPr: "source",
+    tcW: "source",
+    format: "display",
+    // Read from `sdtPrefix` rather than from the file, but a lock is not a display value: leaving
+    // it out of the comparison would let a step that unlocks a cell pass as a re-derivation
+    sdtPrefix: "source",
+    sdtContentsLocked: "source",
+    sdtDeletionLocked: "source"
+  },
+  rawBlock: { xml: "source", name: "source" },
+  docxRaw: { srcId: "session", name: "session" },
+  bookmarkBlock: { srcId: "session", name: "session" },
+  hardBreak: { brAttrs: "source" },
+  image: { src: "source", extent: "source", alt: "source", xml: "source" },
+  commentStart: { id: "source", xml: "source" },
+  commentEnd: { id: "source", xml: "source" },
+  commentReference: {
+    id: "source",
+    referenceXml: "source",
+    author: "source",
+    authorId: "source",
+    initials: "source",
+    date: "source",
+    text: "source",
+    commentXml: "source",
+    paraId: "source",
+    resolved: "source",
+    extensionXml: "source",
+    replies: "source",
+    // Read to decide whether the comment parts are rewritten at all; neither is written
+    imported: "session",
+    threadImported: "session"
+  },
+  noteReference: {
+    kind: "source",
+    id: "source",
+    customMarkFollows: "source",
+    referenceXml: "source",
+    // Both come from the notes part as the document was opened, and the writer puts back the
+    // reference alone: a note renumbered around an edit is the same reference it was
+    label: "display",
+    text: "display"
+  },
+  rawInline: { xml: "source" }
+};
+var MARK_ATTR_ROLES = {
+  run: { rPr: "source", rAttrs: "source", format: "display" },
+  sdt: {
+    sdtPrefix: "source",
+    // Counted through the document as it was opened, to tell one control from the next
+    sdtKey: "session",
+    contentsLocked: "source",
+    deletionLocked: "source"
+  },
+  link: { linkPrefix: "source", href: "source", linkKey: "session" },
+  tab: { tabAttrs: "source" }
+};
+function rolesOf(type) {
+  const roles = type instanceof NodeType ? NODE_ATTR_ROLES[type.name] : MARK_ATTR_ROLES[type.name];
+  return roles ?? {};
+}
+function attrRole(type, name) {
+  return rolesOf(type)[name] ?? "source";
+}
+function displayAttrsOf(type) {
+  return Object.entries(rolesOf(type)).filter(([, role]) => role === "display").map(([name]) => name);
+}
+export {
+  MARK_ATTR_ROLES,
+  NODE_ATTR_ROLES,
+  attrRole,
+  displayAttrsOf
+};

package/dist/schema/docxSchema.d.ts

@@ -1,6 +1,12 @@
 /**
  * ProseMirror schema joining preserved DOCX fragments with validated display values. Original XML
  * remains on nodes and marks so untouched content can round-trip verbatim.
+ *
+ * Every block sits in one of two groups beside `block`. A `modelled` block is one the editor
+ * takes apart and writes back out itself, so the writer decides what it says; a `preserved` one
+ * goes back out as the XML it arrived as. Which of the two a block is decides how it is written
+ * (`docx/serializeBlock`) and how a submitted file is compared against the original
+ * (`docx/storyProjection`), so a new block node has to name one of them.
  */
 import { Schema } from "prosemirror-model";
 export { imageNodeSpec, runMarkSpec } from "./rendering";