@portone/docx-editor 0.2.0 → 0.3.0

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,52 +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 */
-    pos: number;
-    /** Which break inside that block, counted in document order */
-    index: number;
-    height: number;
-}
 /** One block to be moved down to the next page */
 export interface BlockPush {
     pos: number;
@@ -99,17 +55,6 @@ export interface BlockPush {
     /** Of that, the extra amount pushed for the page's sake */
     push: number;
 }
-/** A display-only row inserted before the row that continues on the next page */
-export interface TableContinuation {
-    /** The position of the first original row on the next page */
-    pos: number;
-    /** Space from the previous page's row boundary to the next page body */
-    height: number;
-    /** Header rows to project immediately after the space */
-    headerRows: readonly number[];
-    headerSignature: string;
-    columns: number;
-}
 /** A place where one page parts from the next */
 export interface PageSplit {
     /** Where the previous page's body ends, measured from the top of the body */
@@ -148,8 +93,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 +114,11 @@ 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.
+ * A block kept with the next one is pushed together with what it is kept with: the blocks kept
+ * after it and the first piece of the block the keeps end at.
  */
 export declare function pageLayout({ blocks, pageBodyHeight, pageStep, }: PageLayoutInput): PageLayout;

package/dist/page/pageLayout.js

@@ -41,14 +41,41 @@ var TOLERANCE_PX = 0.5;
 function round(value) {
   return Math.round(value * 100) / 100;
 }
+function keepsWithNext(block, next) {
+  return block.keepWithNext && block.candidates.length === 0 && !block.breakAfter && !next.breakBefore;
+}
+function keptExtents(blocks, fitsPage) {
+  const extents = /* @__PURE__ */ new Map();
+  let run = [];
+  const settle = () => {
+    const head = run.at(-1);
+    if (head && fitsPage(head.extent)) {
+      for (const { index, extent } of run) {
+        extents.set(index, extent);
+      }
+    }
+    run = [];
+  };
+  for (let index = blocks.length - 2; index >= 0; index -= 1) {
+    const block = blocks[index];
+    const next = blocks[index + 1];
+    if (block && next && keepsWithNext(block, next)) {
+      const below = run.at(-1)?.extent ?? next.minFirstPiece;
+      run.push({ index, extent: block.height + next.gap + below });
+    } else {
+      settle();
+    }
+  }
+  settle();
+  return extents;
+}
 function pageLayout({
   blocks,
   pageBodyHeight,
   pageStep
 }) {
   const pushes = [];
-  const spaces = [];
-  const tableContinuations = [];
+  const cuts = [];
   const splits = [];
   const firstPage = {
     page: 1,
@@ -58,14 +85,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,13 +102,16 @@ function pageLayout({
       split(pageStart + pageBodyHeight, true, false);
     }
   };
-  for (const block of blocks) {
+  const fitsPage = (extent) => extent <= pageBodyHeight + TOLERANCE_PX;
+  const kept = keptExtents(blocks, fitsPage);
+  let breakAfterPrevious = false;
+  for (const [index, block] of blocks.entries()) {
     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 = kept.get(index) ?? block.minFirstPiece;
     const overflows = top + first > pageEnd + TOLERANCE_PX;
-    const fits = first <= pageBodyHeight + TOLERANCE_PX;
+    const fits = fitsPage(first);
     const push = startsPage || overflows && fits ? Math.max(0, pageEnd + pageStep - top) : 0;
     if (push > 0 || startsPage) split(pageEnd, false, startsPage);
     if (push > 0) {
@@ -98,51 +121,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 index2 = 0; index2 <= block.candidates.length; index2 += 1) {
+      const cut = index2 === 0 ? null : block.candidates[index2 - 1];
+      const pieceEnd = block.candidates[index2]?.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/usePageLayout.d.ts

@@ -3,8 +3,8 @@
  * page-boundary positions over to the view. It remeasures whenever the text changes or the
  * box is resized.
  *
- * A measurement hands new pushes and break spaces to the view (`./pageDecorations`), which is a
- * decoration transaction against the very paragraph an IME may be composing in, and a composition
+ * A measurement hands its marks to the view (`./pageDecorations`) in one decoration transaction
+ * against the very paragraph an IME may be composing in, and a composition
  * 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.
  */

package/dist/page/usePageLayout.js

@@ -8,11 +8,7 @@ import {
 } from "react";
 import { editorCssVariables } from "../styles/classNames.js";
 import { measureSheet } from "./measureBlocks.js";
-import {
-  setPageBreakSpaces,
-  setPagePushes,
-  setTableContinuations
-} from "./pageDecorations.js";
+import { setPageMarks } from "./pageDecorations.js";
 import {
   A4_PAGE_PIXELS,
   PAGE_SPLIT_PX,
@@ -74,9 +70,7 @@ function usePageLayout({
         pageBodyHeight: page.bodyHeight,
         pageStep: page.pageStep
       });
-      setPagePushes(view, layout.pushes);
-      setPageBreakSpaces(view, layout.spaces);
-      setTableContinuations(view, layout.tableContinuations);
+      setPageMarks(view, { pushes: layout.pushes, cuts: layout.cuts });
       const sheetHeight = measured.contentTop + layout.bodyHeight + measured.contentBottom;
       box.style.setProperty(editorCssVariables.sheetHeight, `${sheetHeight}px`);
       const next = {
@@ -120,9 +114,7 @@ function usePageLayout({
     if (enabled) return;
     layer.current?.style.removeProperty(editorCssVariables.sheetHeight);
     if (!view) return;
-    setPagePushes(view, []);
-    setPageBreakSpaces(view, []);
-    setTableContinuations(view, []);
+    setPageMarks(view, { pushes: [], cuts: [] });
   }, [enabled, layer, view]);
   useEffect(() => {
     const box = layer.current;

package/dist/schema/attrRoles.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Each attr has two independent classifications. Its role controls source comparison: `source`
+ * values are what the writer writes a block from; `display` values are worked out from the source
+ * and the formatting around it, and are never written into a block's XML (`docx/newLists` reads a
+ * list reference off one to decide what numbering.xml needs); `session` values are what export
+ * reads but neither writes nor derives again - which block, control or link this is, whether a
+ * comment came in with the file, the name of a preserved element. `sourceEquality` compares source
+ * and session values so a display refresh does not rebuild an untouched block.
+ *
+ * Its class records provenance: `preserved` holds XML, `derived` is calculated from other data,
+ * `identity` identifies content (imported or allocated here), and `model` holds editable values.
+ * Classification alone does not promise a public API; the plugin guide defines that boundary.
+ *
+ * Lock flags are derived from control XML but have the source role: ignoring them in a comparison
+ * would let an unlock pass as a display refresh. The imported flags are derived with the session
+ * role because export reads them to decide whether to rewrite comment parts.
+ * Both columns are checked against the schema by the adjacent tests.
+ */
+import { type MarkType, NodeType } from "prosemirror-model";
+export type AttrRole = "source" | "display" | "session";
+export type AttrClass = "preserved" | "derived" | "identity" | "model";
+/** What is declared about one attr: what a comparison does with it, and where its value comes from */
+export type AttrFacts = {
+    readonly role: AttrRole;
+    readonly class: AttrClass;
+};
+type AttrTable = Readonly<Record<string, Readonly<Record<string, AttrFacts>>>>;
+export declare const NODE_ATTR_ROLES: AttrTable;
+export declare const MARK_ATTR_ROLES: AttrTable;
+/**
+ * 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[];
+/** The attrs of this node or mark that the given class covers */
+export declare function attrsOfClass(type: NodeType | MarkType, cls: AttrClass): readonly string[];
+export {};

package/dist/schema/attrRoles.js

@@ -0,0 +1,141 @@
+// src/schema/attrRoles.ts
+import { NodeType } from "prosemirror-model";
+var NODE_ATTR_ROLES = {
+  paragraph: {
+    srcId: { role: "session", class: "identity" },
+    pAttrs: { role: "source", class: "preserved" },
+    pPr: { role: "source", class: "preserved" },
+    format: { role: "display", class: "derived" },
+    styleRun: { role: "display", class: "derived" }
+  },
+  table: {
+    srcId: { role: "session", class: "identity" },
+    tblAttrs: { role: "source", class: "preserved" },
+    tblPr: { role: "source", class: "preserved" },
+    tblW: { role: "source", class: "model" },
+    gridCols: { role: "source", class: "model" },
+    // The grid the table had before it was last revised, carried as it arrived
+    gridChange: { role: "source", class: "preserved" },
+    format: { role: "display", class: "derived" },
+    styleInside: { role: "display", class: "derived" },
+    styleCellMargins: { role: "display", class: "derived" }
+  },
+  tableRow: {
+    trAttrs: { role: "source", class: "preserved" },
+    tblPrEx: { role: "source", class: "preserved" },
+    trPr: { role: "source", class: "preserved" },
+    format: { role: "display", class: "derived" }
+  },
+  tableCell: {
+    colspan: { role: "source", class: "model" },
+    rowspan: { role: "source", class: "model" },
+    // 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: { role: "display", class: "derived" },
+    tcAttrs: { role: "source", class: "preserved" },
+    tcPr: { role: "source", class: "preserved" },
+    tcW: { role: "source", class: "model" },
+    format: { role: "display", class: "derived" },
+    // 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: { role: "source", class: "preserved" },
+    sdtContentsLocked: { role: "source", class: "derived" },
+    sdtDeletionLocked: { role: "source", class: "derived" }
+  },
+  rawBlock: {
+    xml: { role: "source", class: "preserved" },
+    name: { role: "source", class: "identity" }
+  },
+  docxRaw: {
+    srcId: { role: "session", class: "identity" },
+    name: { role: "session", class: "identity" }
+  },
+  bookmarkBlock: {
+    srcId: { role: "session", class: "identity" },
+    name: { role: "session", class: "identity" }
+  },
+  hardBreak: { brAttrs: { role: "source", class: "preserved" } },
+  image: {
+    // The bytes themselves, as a data URL the editor makes when an image is inserted
+    src: { role: "source", class: "model" },
+    extent: { role: "source", class: "model" },
+    alt: { role: "source", class: "model" },
+    xml: { role: "source", class: "preserved" }
+  },
+  commentStart: {
+    id: { role: "source", class: "identity" },
+    xml: { role: "source", class: "preserved" }
+  },
+  commentEnd: {
+    id: { role: "source", class: "identity" },
+    xml: { role: "source", class: "preserved" }
+  },
+  commentReference: {
+    id: { role: "source", class: "identity" },
+    referenceXml: { role: "source", class: "preserved" },
+    author: { role: "source", class: "model" },
+    authorId: { role: "source", class: "model" },
+    initials: { role: "source", class: "model" },
+    date: { role: "source", class: "model" },
+    text: { role: "source", class: "model" },
+    commentXml: { role: "source", class: "preserved" },
+    paraId: { role: "source", class: "identity" },
+    resolved: { role: "source", class: "model" },
+    extensionXml: { role: "source", class: "preserved" },
+    replies: { role: "source", class: "model" },
+    // Read to decide whether the comment parts are rewritten at all; neither is written
+    imported: { role: "session", class: "derived" },
+    threadImported: { role: "session", class: "derived" }
+  },
+  noteReference: {
+    kind: { role: "source", class: "model" },
+    id: { role: "source", class: "identity" },
+    customMarkFollows: { role: "source", class: "model" },
+    referenceXml: { role: "source", class: "preserved" },
+    // 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: { role: "display", class: "derived" },
+    text: { role: "display", class: "derived" }
+  },
+  rawInline: { xml: { role: "source", class: "preserved" } }
+};
+var MARK_ATTR_ROLES = {
+  run: {
+    rPr: { role: "source", class: "preserved" },
+    rAttrs: { role: "source", class: "preserved" },
+    format: { role: "display", class: "derived" }
+  },
+  sdt: {
+    sdtPrefix: { role: "source", class: "preserved" },
+    // Counted through the document as it was opened, to tell one control from the next
+    sdtKey: { role: "session", class: "identity" },
+    contentsLocked: { role: "source", class: "derived" },
+    deletionLocked: { role: "source", class: "derived" }
+  },
+  link: {
+    linkPrefix: { role: "source", class: "preserved" },
+    href: { role: "source", class: "model" },
+    linkKey: { role: "session", class: "identity" }
+  },
+  tab: { tabAttrs: { role: "source", class: "preserved" } }
+};
+function factsOf(type) {
+  const facts = type instanceof NodeType ? NODE_ATTR_ROLES[type.name] : MARK_ATTR_ROLES[type.name];
+  return facts ?? {};
+}
+function attrRole(type, name) {
+  return factsOf(type)[name]?.role ?? "source";
+}
+function displayAttrsOf(type) {
+  return Object.entries(factsOf(type)).filter(([, facts]) => facts.role === "display").map(([name]) => name);
+}
+function attrsOfClass(type, cls) {
+  return Object.entries(factsOf(type)).filter(([, facts]) => facts.class === cls).map(([name]) => name);
+}
+export {
+  MARK_ATTR_ROLES,
+  NODE_ATTR_ROLES,
+  attrRole,
+  attrsOfClass,
+  displayAttrsOf
+};

package/dist/schema/displayDerivation.d.ts

@@ -0,0 +1,82 @@
+/**
+ * How a display value gets onto a node: who says what it should be, and why the transaction that
+ * writes it is no edit.
+ *
+ * What a node draws with is worked out from its source and the formatting around it
+ * (`./attrRoles`), and has to be worked out again whenever either moves: the lines of a table's
+ * cells once a row is added, the style values of a paragraph once its own properties change, and
+ * every value at once when the formatting the document is resolved against is replaced. A deriver
+ * says, for the node types it answers for, what the display attrs of one such node should be, and
+ * `deriveDisplay` walks the blocks of a document, asks each owner in turn, and writes one step per
+ * node whose attrs would change. Only the display attrs of what a deriver hands back are read, so
+ * a deriver cannot write a source attr, and the walk is by construction the kind of transaction
+ * `changesOnlyDisplayAttrs` describes.
+ *
+ * The interface stands here, below `docx` and `editor`, so that a module of either can write a
+ * deriver against it. What a deriver resolves against is the caller's own `Context`, which this
+ * module never reads; `editor/plugins/displayDerivation` registers the derivers and runs the walk
+ * after every edit.
+ *
+ * A transaction carrying the `displayOnly` pass goes through the guard list whole (`./guards`),
+ * provided every step of it is judged, off the role table alone, to change display attrs and
+ * nothing else. The pass is a claim rather than a key: a step that rewrites a source attr, a lock
+ * flag among them, or that puts content anywhere, fails the claim, and the transaction is then
+ * judged as any other edit.
+ */
+import { type Attrs, type MarkType, type Node as PMNode, type Schema } from "prosemirror-model";
+import { PluginKey } from "prosemirror-state";
+import { type Step, type Transform } from "prosemirror-transform";
+import type { docxSchema } from "./docxSchema";
+/** The name of a node type of the document schema, which is what a deriver answers for by */
+export type NodeName = typeof docxSchema extends Schema<infer Nodes, string> ? Nodes : never;
+/** The display attrs one node should carry, by the position the node stands at in the document handed to the deriver */
+export interface DisplayAttrs {
+    readonly pos: number;
+    readonly attrs: Attrs;
+    /** Omitted for node attrs. Otherwise updates an existing mark on this inline node. */
+    readonly mark?: {
+        readonly type: MarkType;
+        readonly to: number;
+    };
+}
+/**
+ * What says, for the node types it answers for, what one node's display attrs should be.
+ *
+ * `derive` is asked once per such node, in document order, with the node as the derivers before it
+ * left it. It hands back the display attrs of that node and of any node inside it, each by
+ * position - a table's deriver answers for the cells - or nothing where nothing changes; a source
+ * or session attr among what it hands back is not written. `previous` is the node this one maps
+ * back to in the document before the change, or null when there is none, or when every value is
+ * being worked out again from nothing.
+ */
+export interface DisplayDeriver<Context> {
+    readonly name: string;
+    /**
+     * The block node types this deriver answers for. The walk runs over the blocks and never into
+     * the inline content of a textblock, since it runs after every keystroke, so an inline type
+     * cannot be answered for.
+     */
+    readonly nodeTypes: readonly NodeName[];
+    derive(node: PMNode, pos: number, doc: PMNode, context: Context, previous: PMNode | null): readonly DisplayAttrs[];
+}
+/**
+ * Writes the display attrs the derivers hand back, one `setNodeMarkup` per node whose attrs would
+ * change, onto the transform. It holds no state of its own: what a node maps back to comes from
+ * the caller, who knows what changed.
+ *
+ * Every step keeps the document the same size, so the positions gathered before the first write
+ * still hold, and a deriver asked after another reads the node as that one left it.
+ */
+export declare function deriveDisplay<Context>(transform: Transform, context: Context, derivers: readonly DisplayDeriver<Context>[], previousOf: (node: PMNode, pos: number) => PMNode | null): void;
+/**
+ * The pass a re-derivation carries. A plugin key is used as the name so that it cannot collide
+ * with a consumer's own metadata.
+ */
+export declare const displayOnly: PluginKey<boolean>;
+/**
+ * Whether the step changes display attrs and nothing else, judged off the role table alone.
+ *
+ * Node attrs and existing mark attrs may change only their display fields. Adding a mark where
+ * that type was absent, changing source attrs, and all other step shapes remain edits.
+ */
+export declare function changesOnlyDisplayAttrs(step: Step, doc: PMNode): boolean;