@portone/docx-editor 0.2.1 → 0.3.0

package/dist/editor/documentStyles.d.ts

@@ -1,45 +1,23 @@
 /**
- * Brings what the document laid down into the editor: what styles.xml told us, and the paper it
- * is written on.
+ * What the document laid down, as the commands and the toolbar ask for it: what styles.xml told
+ * us, and the paper it is written on.
  *
- * Commands and the toolbar know nothing about the session, so this plugin holds all of it on
- * their behalf: deriving the display values again after a formatting edit needs the values the
- * style laid down, the toolbar needs the size a run is rendered at where nobody wrote a size
- * down, and a new table is fitted to the width of the body the paper leaves.
- * The values are fixed the moment the document is opened and do not change while editing.
+ * Commands and the toolbar know nothing about the session, so they read the snapshot
+ * `editor/editorDocument` holds on their behalf: deriving the display values again after a
+ * formatting edit needs the context the hierarchy is resolved against, the toolbar needs the size
+ * a run is rendered at where nobody wrote a size down, and a new table is fitted to the width of
+ * the body the paper leaves.
  */
-import { type EditorState, Plugin } from "prosemirror-state";
-import { type ParagraphFormatLayer, type ParagraphFormattingContext, type ParagraphStyleOption, type StyleTable } from "../docx/formatting";
+import type { EditorState } from "prosemirror-state";
+import type { FormattingContext, ParagraphStyleOption } from "../docx/formatting";
 import { type PageGeometry } from "../docx/pageGeometry";
 import type { DocumentDefaults } from "../model/format";
-import { type Numbering } from "../numbering/parseNumbering";
-/** Values that apply to the whole document */
-interface DocumentInfo {
-    styles: StyleTable;
-    defaults: DocumentDefaults;
-    paragraphDefaults: ParagraphFormatLayer;
-    numbering: Numbering;
-    paragraphStyles: ParagraphStyleOption[];
-    /** The paper the document is written on, which decides the width a new table is fitted to */
-    geometry: PageGeometry;
-    /** The distance between automatic tab stops when no custom stop applies. */
-    defaultTabStopPt: number;
-}
-/** This document's style table. Empty when the editor does not know the table */
-export declare function documentStyles(state: EditorState): StyleTable;
+/** Everything a paragraph's or a run's display values are resolved against. Empty when the editor does not know the document */
+export declare function documentFormatting(state: EditorState): FormattingContext;
 /** The default formatting this document wrote down. When the editor does not know it, it is the same as nothing being specified */
 export declare function documentDefaults(state: EditorState): DocumentDefaults;
-/** The values required to resolve the OOXML paragraph-property hierarchy. */
-export declare function documentParagraphFormatting(state: EditorState): ParagraphFormattingContext;
 /** The paragraph styles this document defines. Empty when the editor does not know them */
 export declare function documentParagraphStyles(state: EditorState): ParagraphStyleOption[];
-/**
- * The style a paragraph pointing at none of its own wears (`w:default="1"`). Null when the
- * document marks none.
- *
- * It is the style the list of them marks, of which `readParagraphStyles` leaves exactly one.
- */
-export declare function defaultParagraphStyleId(state: EditorState): string | null;
 /**
  * The paper the document is written on. A document the editor knows no paper for is drawn on
  * the same A4 every document was drawn on before the geometry was read
@@ -56,5 +34,3 @@ export declare function documentDefaultTabStopPt(state: EditorState): number;
 export declare function documentBodyWidthPx(state: EditorState): number;
 /** The height one page of body content occupies, in pixels. */
 export declare function documentBodyHeightPx(state: EditorState): number;
-export declare function documentStyleTable(styles: StyleTable, defaults?: DocumentDefaults, paragraphStyles?: ParagraphStyleOption[], geometry?: PageGeometry, paragraphDefaults?: ParagraphFormatLayer, numbering?: Numbering, defaultTabStopPt?: number): Plugin<DocumentInfo>;
-export {};

package/dist/editor/documentStyles.js

@@ -1,47 +1,24 @@
 // src/editor/documentStyles.ts
-import { Plugin, PluginKey } from "prosemirror-state";
-import { DEFAULT_TAB_STOP_PT } from "../docx/documentSettings.js";
 import {
-  NO_DOCUMENT_DEFAULTS,
-  NO_PARAGRAPH_FORMATTING,
-  NO_STYLES
-} from "../docx/formatting.js";
-import {
-  A4_PORTRAIT,
   bodyHeightTwips,
   bodyWidth,
   twipsToPx
 } from "../docx/pageGeometry.js";
-import { EMPTY_NUMBERING } from "../numbering/parseNumbering.js";
-var NO_PARAGRAPH_STYLES = [];
-var documentKey = new PluginKey("docxEditorDocument");
-function documentStyles(state) {
-  return documentKey.getState(state)?.styles ?? NO_STYLES;
+import { documentOf } from "./editorDocument.js";
+function documentFormatting(state) {
+  return documentOf(state).formatting;
 }
 function documentDefaults(state) {
-  return documentKey.getState(state)?.defaults ?? NO_DOCUMENT_DEFAULTS;
-}
-function documentParagraphFormatting(state) {
-  const info = documentKey.getState(state);
-  if (!info) return NO_PARAGRAPH_FORMATTING;
-  return {
-    styles: info.styles,
-    defaultStyleId: info.paragraphStyles.find((style) => style.isDefault)?.id ?? null,
-    defaults: info.paragraphDefaults,
-    numbering: info.numbering
-  };
+  return documentOf(state).defaults;
 }
 function documentParagraphStyles(state) {
-  return documentKey.getState(state)?.paragraphStyles ?? NO_PARAGRAPH_STYLES;
-}
-function defaultParagraphStyleId(state) {
-  return documentParagraphStyles(state).find((style) => style.isDefault)?.id ?? null;
+  return documentOf(state).paragraphStyles;
 }
 function documentGeometry(state) {
-  return documentKey.getState(state)?.geometry ?? A4_PORTRAIT;
+  return documentOf(state).geometry;
 }
 function documentDefaultTabStopPt(state) {
-  return documentKey.getState(state)?.defaultTabStopPt ?? DEFAULT_TAB_STOP_PT;
+  return documentOf(state).defaultTabStopPt;
 }
 function documentBodyWidthPx(state) {
   return bodyWidth(documentGeometry(state)).px;
@@ -49,32 +26,12 @@ function documentBodyWidthPx(state) {
 function documentBodyHeightPx(state) {
   return twipsToPx(bodyHeightTwips(documentGeometry(state)));
 }
-function documentStyleTable(styles, defaults = NO_DOCUMENT_DEFAULTS, paragraphStyles = NO_PARAGRAPH_STYLES, geometry = A4_PORTRAIT, paragraphDefaults = {}, numbering = EMPTY_NUMBERING, defaultTabStopPt = DEFAULT_TAB_STOP_PT) {
-  return new Plugin({
-    key: documentKey,
-    state: {
-      init: () => ({
-        styles,
-        defaults,
-        paragraphDefaults,
-        numbering,
-        paragraphStyles,
-        geometry,
-        defaultTabStopPt
-      }),
-      apply: (_tr, current) => current
-    }
-  });
-}
 export {
-  defaultParagraphStyleId,
   documentBodyHeightPx,
   documentBodyWidthPx,
   documentDefaultTabStopPt,
   documentDefaults,
+  documentFormatting,
   documentGeometry,
-  documentParagraphFormatting,
-  documentParagraphStyles,
-  documentStyleTable,
-  documentStyles
+  documentParagraphStyles
 };

package/dist/editor/editorDocument.d.ts

@@ -0,0 +1,56 @@
+/**
+ * What the opened document laid down, held as one value: the formatting context every display
+ * value is resolved against, the paper the body is written on, and the identifiers its comment
+ * parts have already spent.
+ *
+ * Commands and the toolbar know nothing about the session, so the snapshot stands for it on their
+ * behalf, and `editorDocumentOf` is the one place a session is read into editor values: a screen
+ * and a test that open the same document hold the same values.
+ */
+import { type EditorState, Plugin } from "prosemirror-state";
+import { type FormattingContext, type ParagraphStyleOption } from "../docx/formatting";
+import { type PageGeometry } from "../docx/pageGeometry";
+import type { SessionStore } from "../docx/session";
+import type { DocumentDefaults } from "../model/format";
+/** The document-level values one editing state is built on */
+export interface EditorDocument {
+    /** The document these values were read from. Null for a state built without one */
+    readonly session: SessionStore | null;
+    /** The style chain, the defaults and the list definitions a paragraph's and a run's display values are resolved against */
+    readonly formatting: FormattingContext;
+    readonly defaults: DocumentDefaults;
+    /** The styles the document defines for the style picker to offer */
+    readonly paragraphStyles: ParagraphStyleOption[];
+    /**
+     * Whether the document has a place (numbering.xml) to write the definition of a new list.
+     * A state built without opening a document assumes that place exists and behaves as every
+     * state did before the question was asked.
+     */
+    readonly canStartNewList: boolean;
+    /** The paper the document is written on, which decides the width a new table is fitted to */
+    readonly geometry: PageGeometry;
+    /** The distance between automatic tab stops when no custom stop applies */
+    readonly defaultTabStopPt: number;
+    /** Every id already present in the opened Comments part, including unreferenced entries */
+    readonly reservedCommentIds: ReadonlySet<string>;
+    /** Every paragraph id present in the opened comment parts, including orphan extension entries */
+    readonly reservedCommentParaIds: ReadonlySet<string>;
+}
+/** What a state built without an opened document answers: the same as nothing being written down */
+export declare const NO_DOCUMENT: EditorDocument;
+/** The one place an opened document is read into the values the editor holds */
+export declare function editorDocumentOf(session: SessionStore): EditorDocument;
+/** The document the state was built for. `NO_DOCUMENT` for a state built without one */
+export declare function documentOf(state: EditorState): EditorDocument;
+/**
+ * Holds the snapshot for the lifetime of the state.
+ *
+ * It is derived again only where a document-level edit could have been recorded, so an ordinary
+ * edit and a selection move both leave the same object behind, allowing the sheet's style to be
+ * cached against that identity.
+ */
+export declare function editorDocument(document: EditorDocument): Plugin<EditorDocument>;
+/** The comment ids the opened document already spent, which a new comment may not take */
+export declare function reservedCommentIds(state: EditorState): ReadonlySet<string>;
+/** The paragraph ids the opened comment parts already spent */
+export declare function reservedCommentParaIds(state: EditorState): ReadonlySet<string>;

package/dist/editor/editorDocument.js

@@ -0,0 +1,74 @@
+// src/editor/editorDocument.ts
+import { Plugin, PluginKey } from "prosemirror-state";
+import { DEFAULT_TAB_STOP_PT } from "../docx/documentSettings.js";
+import {
+  NO_DOCUMENT_DEFAULTS,
+  NO_FORMATTING
+} from "../docx/formatting.js";
+import { A4_PORTRAIT } from "../docx/pageGeometry.js";
+var NO_IDS = /* @__PURE__ */ new Set();
+var NO_PARAGRAPH_STYLES = [];
+var NO_DOCUMENT = {
+  session: null,
+  formatting: NO_FORMATTING,
+  defaults: NO_DOCUMENT_DEFAULTS,
+  paragraphStyles: NO_PARAGRAPH_STYLES,
+  canStartNewList: true,
+  geometry: A4_PORTRAIT,
+  defaultTabStopPt: DEFAULT_TAB_STOP_PT,
+  reservedCommentIds: NO_IDS,
+  reservedCommentParaIds: NO_IDS
+};
+function reservedParaIds(session) {
+  const paraIds = /* @__PURE__ */ new Set();
+  for (const comment of session.comments.ordered) {
+    if (comment.paraId !== null) paraIds.add(comment.paraId);
+  }
+  for (const extension of session.comments.extendedOrdered) {
+    paraIds.add(extension.paraId);
+  }
+  return paraIds;
+}
+function editorDocumentOf(session) {
+  return {
+    session,
+    formatting: session.formatting,
+    defaults: session.defaults,
+    paragraphStyles: session.paragraphStyles,
+    canStartNewList: session.numberingPartPath !== null,
+    geometry: session.geometry,
+    defaultTabStopPt: session.defaultTabStopPt,
+    reservedCommentIds: new Set(session.comments.byId.keys()),
+    reservedCommentParaIds: reservedParaIds(session)
+  };
+}
+var editorDocumentKey = new PluginKey("docxEditorDocument");
+function documentOf(state) {
+  return editorDocumentKey.getState(state) ?? NO_DOCUMENT;
+}
+function derive(session, _doc) {
+  return editorDocumentOf(session);
+}
+function editorDocument(document) {
+  return new Plugin({
+    key: editorDocumentKey,
+    state: {
+      init: () => document,
+      apply: (tr, current, old) => current.session === null || tr.doc.attrs === old.doc.attrs ? current : derive(current.session, tr.doc)
+    }
+  });
+}
+function reservedCommentIds(state) {
+  return documentOf(state).reservedCommentIds;
+}
+function reservedCommentParaIds(state) {
+  return documentOf(state).reservedCommentParaIds;
+}
+export {
+  NO_DOCUMENT,
+  documentOf,
+  editorDocument,
+  editorDocumentOf,
+  reservedCommentIds,
+  reservedCommentParaIds
+};

package/dist/editor/externalClipboard.js

@@ -5,11 +5,12 @@ import {
   Slice
 } from "prosemirror-model";
 import { Plugin } from "prosemirror-state";
-import { effectiveParagraphFormat, styleIdOf } from "../docx/formatting.js";
-import { withParagraphStyle } from "../docx/paraProps.js";
+import { paragraphAttrsFor, styleIdOf } from "../docx/formatting.js";
+import {
+  withListNumbering,
+  withParagraphStyle
+} from "../docx/paraProps.js";
 import { MAX_ILVL, nextNumId } from "../numbering/listTemplate.js";
-import { elementXml } from "../ooxml/element.js";
-import { wName } from "../ooxml/names.js";
 import { docxSchema, isPageBreak } from "../schema/index.js";
 import { editorClassNames } from "../styles/classNames.js";
 import { PASTED_IMAGE_ATTRIBUTE } from "./clipboard/images.js";
@@ -21,12 +22,7 @@ import {
   withInlineStyle
 } from "./clipboard/inlineFormatting.js";
 import { listRefOf } from "./commands/listCommands.js";
-import {
-  defaultParagraphStyleId,
-  documentParagraphFormatting,
-  documentParagraphStyles,
-  documentStyles
-} from "./documentStyles.js";
+import { documentFormatting, documentParagraphStyles } from "./documentStyles.js";
 import { insertPlainText } from "./plainText.js";
 import { moveCaretToDrop } from "./plugins/dropCaret.js";
 import {
@@ -242,12 +238,7 @@ function blockContext(state, parent, element, preserveParagraphStyle) {
     };
   }
   const styleId = destinationStyleId(state, sourceStyleId, level);
-  const paragraph = styleId === null ? null : withParagraphStyle(
-    null,
-    styleId,
-    documentStyles(state),
-    defaultParagraphStyleId(state)
-  );
+  const paragraph = styleId === null ? null : withParagraphStyle(null, styleId);
   const usesDestinationStyle = editorParagraph && (sourceStyleId === null || paragraph !== null);
   let inline = parent;
   if (paragraph === null && level !== null) {
@@ -258,38 +249,18 @@ function blockContext(state, parent, element, preserveParagraphStyle) {
     paragraph
   };
 }
-function listParagraphAttrs(state, list) {
+function listParagraphProps(list) {
   if (!list || list.numId === null) return null;
-  const ilvl = Math.min(MAX_ILVL, list.level);
-  const pPr = elementXml(
-    wName("pPr"),
-    [],
-    [
-      elementXml(
-        wName("numPr"),
-        [],
-        [
-          elementXml(wName("ilvl"), [[wName("val"), `${ilvl}`]]),
-          elementXml(wName("numId"), [[wName("val"), `${list.numId}`]])
-        ]
-      )
-    ]
-  );
-  return {
-    pPr,
-    format: effectiveParagraphFormat(pPr, documentParagraphFormatting(state))
-  };
+  return withListNumbering(null, {
+    numbering: { numId: list.numId, ilvl: Math.min(MAX_ILVL, list.level) },
+    indent: { kind: "keep" }
+  });
 }
 function paragraphAttrs(state, list, paragraph) {
-  const listed = listParagraphAttrs(state, list);
-  if (listed) return listed;
-  return paragraph ? {
-    pPr: paragraph.pPr,
-    format: effectiveParagraphFormat(
-      paragraph.pPr,
-      documentParagraphFormatting(state)
-    ),
-    styleRun: paragraph.styleRun
+  const props = listParagraphProps(list) ?? paragraph;
+  return props ? {
+    pPr: props.pPr,
+    ...paragraphAttrsFor(props.pPr, documentFormatting(state))
   } : null;
 }
 function usedNumIds(state) {

package/dist/editor/insertTable.js

@@ -4,7 +4,7 @@ import {
   TextSelection
 } from "prosemirror-state";
 import { createTableNode, isTableSide } from "../docx/tableTemplate.js";
-import { editsShut } from "../schema/protectionState.js";
+import { editShut } from "../schema/guards.js";
 import { documentGeometry } from "./documentStyles.js";
 function isInTable($pos) {
   for (let depth = $pos.depth; depth > 0; depth -= 1) {
@@ -14,8 +14,9 @@ function isInTable($pos) {
 }
 function insertPosition(state) {
   const $from = state.selection.$from;
-  if (editsShut(state) || $from.depth === 0 || isInTable($from)) return null;
-  return $from.after(1);
+  if ($from.depth === 0 || isInTable($from)) return null;
+  const at = $from.after(1);
+  return editShut(state, { kind: "insert", at }) ? null : at;
 }
 function canInsertTable(state) {
   return insertPosition(state) !== null;

package/dist/editor/paragraphEdits.d.ts

@@ -8,7 +8,6 @@
  */
 import type { Node as PMNode } from "prosemirror-model";
 import type { EditorState, Transaction } from "prosemirror-state";
-import { type StyleTable } from "../docx/formatting";
 import type { ParagraphProps } from "../docx/paraProps";
 export interface ParagraphSpot {
     pos: number;
@@ -17,28 +16,22 @@ export interface ParagraphSpot {
 /** The paragraphs the selection spans. Selections covering several table cells are handled too */
 export declare function selectedParagraphs(state: EditorState): ParagraphSpot[];
 /**
- * The selected paragraphs a lock leaves editable, which is what every paragraph edit works on.
+ * The selected paragraphs the guards leave editable, which is what every paragraph edit works on.
  *
- * A locked stretch is left out rather than the whole edit refused, the policy character formatting
- * already follows (`commands/formattingCommands`): the guard turns down a whole transaction, so
- * asking for it would leave the rest of the selection unedited too. A selection the lock leaves
- * nothing of edits nothing, and the command reports that of its own accord, which is the disabled
- * state of the control that runs it.
+ * A shut paragraph is left out rather than the whole edit refused, the policy character formatting
+ * already follows (`schema/guards`): the guard turns down a whole transaction, so asking for it
+ * would leave the rest of the selection unedited too. A selection the guards leave nothing of edits
+ * nothing, and the command reports that of its own accord, which is the disabled state of the
+ * control that runs it.
  *
- * Only the paragraphs of a locked cell are shut. A paragraph merely holding a locked control keeps
- * its own alignment, indent and style, which is what `insideLockedCell` says and
- * `rangeTouchesLocked` would not (`schema/locks`).
- *
- * A protection that shuts the body leaves no paragraph editable (`schema/protection`).
+ * A paragraph is rewritten around its content, which is the block intent: only the paragraphs of a
+ * locked cell are shut, and a paragraph merely holding a locked control keeps its own alignment,
+ * indent and style. A protection that shuts the body shuts every one of them.
  */
 export declare function editableParagraphs(state: EditorState): ParagraphSpot[];
 /** The original formatting XML this paragraph holds. Null when there is none */
 export declare function paragraphPPr(node: PMNode): string | null;
-/**
- * How to edit a single paragraph. Null skips that paragraph.
- * The style table and the document's default paragraph style come along, because the display values
- * of the edited fragment are read back with the style the paragraph wears laid underneath.
- */
-export type ParagraphSurgery = (node: PMNode, styles: StyleTable, defaultStyleId: string | null) => ParagraphProps | null;
+/** How to edit a single paragraph. Null skips that paragraph */
+export type ParagraphSurgery = (node: PMNode) => ParagraphProps | null;
 /** Edits the selected paragraphs in a single transaction. Does nothing when there is nothing to edit */
 export declare function editParagraphs(state: EditorState, dispatch: ((tr: Transaction) => void) | undefined, surgery: ParagraphSurgery): boolean;

package/dist/editor/paragraphEdits.js

@@ -1,13 +1,8 @@
 // src/editor/paragraphEdits.ts
-import { effectiveParagraphFormat } from "../docx/formatting.js";
+import { paragraphAttrsFor } from "../docx/formatting.js";
 import { docxSchema } from "../schema/index.js";
-import { insideLockedCell } from "../schema/locks.js";
-import { editsShut } from "../schema/protectionState.js";
-import {
-  defaultParagraphStyleId,
-  documentParagraphFormatting,
-  documentStyles
-} from "./documentStyles.js";
+import { editShut } from "../schema/guards.js";
+import { documentFormatting } from "./documentStyles.js";
 function selectedParagraphs(state) {
   const spots = /* @__PURE__ */ new Map();
   for (const range of state.selection.ranges) {
@@ -20,9 +15,8 @@ function selectedParagraphs(state) {
   return Array.from(spots, ([pos, node]) => ({ pos, node }));
 }
 function editableParagraphs(state) {
-  if (editsShut(state)) return [];
   return selectedParagraphs(state).filter(
-    (spot) => !insideLockedCell(state.doc, spot.pos)
+    (spot) => !editShut(state, { kind: "block", at: spot.pos })
   );
 }
 function paragraphPPr(node) {
@@ -31,22 +25,19 @@ function paragraphPPr(node) {
 }
 function writeChanges(state, changed) {
   const tr = state.tr;
-  const formatting = documentParagraphFormatting(state);
+  const formatting = documentFormatting(state);
   for (const { spot, props } of changed) {
     tr.setNodeMarkup(tr.mapping.map(spot.pos), void 0, {
       ...spot.node.attrs,
       pPr: props.pPr,
-      format: effectiveParagraphFormat(props.pPr, formatting),
-      styleRun: props.styleRun
+      ...paragraphAttrsFor(props.pPr, formatting)
     });
   }
   return tr;
 }
 function editParagraphs(state, dispatch, surgery) {
-  const styles = documentStyles(state);
-  const defaultStyleId = defaultParagraphStyleId(state);
   const changed = editableParagraphs(state).flatMap((spot) => {
-    const props = surgery(spot.node, styles, defaultStyleId);
+    const props = surgery(spot.node);
     return props ? [{ spot, props }] : [];
   });
   if (changed.length === 0) return false;

package/dist/editor/plugins/displayDerivation.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Keeps every display value of the document current: the ones an edit moved, after that edit, and
+ * every one at once when the document snapshot the values are resolved against is replaced.
+ *
+ * The derivers are registered here and run through the one walk `schema/displayDerivation`
+ * defines. What a node maps back to is settled here as well, from the mapping of the transactions
+ * that changed the document: a node whose content survived those transactions is the node that
+ * stood where its opening maps back to, and one whose content did not is new. A node rewritten
+ * where it stands (`setNodeMarkup`) therefore still maps back to itself, which is what lets a
+ * table resized or a paragraph re-aligned be told from a table or a paragraph put in.
+ *
+ * The transaction this appends carries the display-only pass (`schema/guards`), since it changes
+ * nothing a lock or a protection answers for, and goes to the history as part of the edit it
+ * follows, so that one undo takes the edit and its values back together. The re-derivation after
+ * a snapshot change follows no edit and goes to the history not at all: the values follow the
+ * snapshot, and undoing whatever replaced the snapshot derives them again.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { Plugin } from "prosemirror-state";
+import { type DisplayDeriver } from "../../schema/displayDerivation";
+import { type EditorDocument } from "../editorDocument";
+/** What a deriver of this editor resolves against */
+export interface DerivationContext {
+    readonly document: EditorDocument;
+    /**
+     * Where the composition the browser holds open stands, which a deriver leaves alone: rewriting
+     * the node it stands in redraws it, and a redraw under an open composition is what the browser
+     * answers by taking the composition down. Null while nothing is being composed, and while every
+     * value is being worked out again from nothing, when nothing may be left standing.
+     */
+    readonly composingAt: number | null;
+}
+export type DocumentDeriver = DisplayDeriver<DerivationContext>;
+export declare const DISPLAY_DERIVERS: readonly DocumentDeriver[];
+/**
+ * The document with every display value worked out against this snapshot, which is what a state
+ * is built over: the values a document arrived with were worked out against whatever opened it.
+ */
+export declare function withDerivedDisplay(doc: PMNode, document: EditorDocument, derivers?: readonly DocumentDeriver[]): PMNode;
+/**
+ * Derives the display values again after every change: for the nodes an edit moved, and for every
+ * node when the snapshot was replaced.
+ *
+ * An appended transaction is handed nothing but states, so the view an open composition is read
+ * from is the one the plugin is given when it mounts.
+ */
+export declare function displayDerivation(derivers?: readonly DocumentDeriver[]): Plugin;

package/dist/editor/plugins/displayDerivation.js

@@ -0,0 +1,78 @@
+// src/editor/plugins/displayDerivation.ts
+import { Plugin } from "prosemirror-state";
+import { Mapping, Transform } from "prosemirror-transform";
+import {
+  deriveDisplay,
+  displayOnly
+} from "../../schema/displayDerivation.js";
+import { documentOf } from "../editorDocument.js";
+import { paragraphDisplay } from "./paragraphDisplay.js";
+import { tableDisplay } from "./tableDisplay.js";
+var DISPLAY_DERIVERS = [
+  tableDisplay,
+  paragraphDisplay
+];
+var nothingBefore = () => null;
+function withDerivedDisplay(doc, document, derivers = DISPLAY_DERIVERS) {
+  const transform = new Transform(doc);
+  deriveDisplay(
+    transform,
+    { document, composingAt: null },
+    derivers,
+    nothingBefore
+  );
+  return transform.doc;
+}
+function previousIn(before, transactions) {
+  const mapping = new Mapping();
+  for (const transaction of transactions) {
+    mapping.appendMapping(transaction.mapping);
+  }
+  const back = mapping.invert();
+  return (node, pos) => {
+    const inside = node.isLeaf ? pos : pos + 1;
+    if (back.mapResult(inside, 1).deleted) return null;
+    const was = before.nodeAt(back.map(pos, 1));
+    return was !== null && was.type === node.type ? was : null;
+  };
+}
+function composingAt(view, state) {
+  return view?.composing === true ? state.selection.from : null;
+}
+function displayDerivation(derivers = DISPLAY_DERIVERS) {
+  let live = null;
+  return new Plugin({
+    view(view) {
+      live = view;
+      return {
+        destroy() {
+          live = null;
+        }
+      };
+    },
+    appendTransaction(transactions, oldState, newState) {
+      const document = documentOf(newState);
+      const replaced = document !== documentOf(oldState);
+      if (!replaced && !transactions.some((transaction) => transaction.docChanged)) {
+        return null;
+      }
+      const tr = newState.tr.setMeta(displayOnly, true);
+      if (replaced) tr.setMeta("addToHistory", false);
+      deriveDisplay(
+        tr,
+        {
+          document,
+          composingAt: replaced ? null : composingAt(live, newState)
+        },
+        derivers,
+        replaced ? nothingBefore : previousIn(oldState.doc, transactions)
+      );
+      return tr.docChanged ? tr : null;
+    }
+  });
+}
+export {
+  DISPLAY_DERIVERS,
+  displayDerivation,
+  withDerivedDisplay
+};

package/dist/editor/plugins/imagePaste.js

@@ -2,8 +2,7 @@
 import { isHistoryTransaction } from "prosemirror-history";
 import { Plugin, PluginKey } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
-import { replacementShut } from "../../schema/locks.js";
-import { editsShut } from "../../schema/protectionState.js";
+import { editShut, selectionIntents } from "../../schema/guards.js";
 import {
   hasResolvableClipboardImages,
   resolveClipboardImages
@@ -223,7 +222,9 @@ function imagePaste() {
     props: {
       decorations: (state) => imagePasteKey.getState(state)?.decorations,
       handlePaste(view, event) {
-        if (editsShut(view.state) || replacementShut(view.state.selection, view.state.doc)) {
+        if (selectionIntents(view.state.selection, "replace").some(
+          (intent) => editShut(view.state, intent)
+        )) {
           return false;
         }
         if (view.state.selection.ranges.length > 1) return false;