@portone/docx-editor 0.2.0 → 0.3.0

package/dist/editor/commands/paragraphCommands.js

@@ -1,16 +1,18 @@
 // src/editor/commands/paragraphCommands.ts
-import { layerRunFormat, styleIdOf } from "../../docx/formatting.js";
+import {
+  paragraphAttrsOf,
+  resolveParagraph,
+  runMarkUnder,
+  styleIdOf
+} from "../../docx/formatting.js";
 import {
   withParagraphAlign,
   withParagraphStyle
 } from "../../docx/paraProps.js";
-import { readRunProps } from "../../docx/runProps.js";
-import {
-  toParagraphFormat
-} from "../../model/format.js";
+import { toParagraphFormat } from "../../model/format.js";
 import { docxSchema } from "../../schema/index.js";
 import { lockedMarkOf } from "../../schema/locks.js";
-import { defaultParagraphStyleId, documentStyles } from "../documentStyles.js";
+import { documentFormatting } from "../documentStyles.js";
 import {
   editableParagraphs,
   editParagraphs,
@@ -24,9 +26,9 @@ function setParagraphAlign(align) {
   return (state, dispatch) => editParagraphs(
     state,
     dispatch,
-    (node, styles, defaultStyleId) => (
+    (node) => (
       // A paragraph already rendered with that alignment is left untouched, so its original XML survives
-      alignOf(node) === align ? null : withParagraphAlign(paragraphPPr(node), align, styles, defaultStyleId)
+      alignOf(node) === align ? null : withParagraphAlign(paragraphPPr(node), align)
     )
   );
 }
@@ -38,25 +40,16 @@ function activeParagraphAlign(state) {
   const first = aligns[0];
   return first !== void 0 && aligns.every((align) => align === first) ? { kind: "shared", align: first } : { kind: "mixed" };
 }
-function text(value) {
-  return typeof value === "string" ? value : null;
-}
-function restyledMark(child, style) {
-  const mark = child.marks.find((entry) => entry.type === docxSchema.marks.run);
-  if (mark) {
-    const format2 = layerRunFormat(style, readRunProps(text(mark.attrs.rPr)));
-    return mark.type.create({ ...mark.attrs, format: format2 });
-  }
-  if (!child.isText) return null;
-  const format = layerRunFormat(style, null);
-  if (format === null) return null;
-  return docxSchema.marks.run.create({ rPr: null, rAttrs: null, format });
-}
-function restyledMarks(spot, style) {
+function restyledMarks(spot, paragraph, context) {
   const changes = [];
   spot.node.forEach((child, offset) => {
     if (lockedMarkOf(child)) return;
-    const mark = restyledMark(child, style);
+    const mark = runMarkUnder(
+      child.marks.find((entry) => entry.type === docxSchema.marks.run) ?? null,
+      child.isText,
+      paragraph,
+      context
+    );
     if (!mark) return;
     const from = spot.pos + 1 + offset;
     changes.push({ from, to: from + child.nodeSize, mark });
@@ -65,12 +58,11 @@ function restyledMarks(spot, style) {
 }
 function writeStyleChanges(state, changed) {
   const tr = state.tr;
-  for (const { spot, props, marks } of changed) {
+  for (const { spot, props, attrs, marks } of changed) {
     tr.setNodeMarkup(tr.mapping.map(spot.pos), void 0, {
       ...spot.node.attrs,
       pPr: props.pPr,
-      format: props.format,
-      styleRun: props.styleRun
+      ...attrs
     });
     for (const change of marks) {
       tr.addMark(change.from, change.to, change.mark);
@@ -80,15 +72,20 @@ function writeStyleChanges(state, changed) {
 }
 function setParagraphStyle(styleId) {
   return (state, dispatch) => {
-    const styles = documentStyles(state);
-    const defaultStyleId = defaultParagraphStyleId(state);
+    const context = documentFormatting(state);
     const changed = editableParagraphs(state).flatMap((spot) => {
       const pPr = paragraphPPr(spot.node);
       if (styleIdOf(pPr) === styleId) return [];
-      const props = withParagraphStyle(pPr, styleId, styles, defaultStyleId);
+      const props = withParagraphStyle(pPr, styleId);
       if (!props) return [];
+      const paragraph = resolveParagraph(props.pPr, context);
       return [
-        { spot, props, marks: restyledMarks(spot, props.styleRun ?? {}) }
+        {
+          spot,
+          props,
+          attrs: paragraphAttrsOf(paragraph),
+          marks: restyledMarks(spot, paragraph, context)
+        }
       ];
     });
     if (changed.length === 0) return false;

package/dist/editor/commands/spacingCommands.js

@@ -24,7 +24,7 @@ function setLineSpacing(spacing) {
     return editParagraphs(
       state,
       dispatch,
-      (node, styles, defaultStyleId) => sameLineSpacing(lineSpacingOf(node, defaults), spacing) ? null : withLineSpacing(paragraphPPr(node), spacing, styles, defaultStyleId)
+      (node) => sameLineSpacing(lineSpacingOf(node, defaults), spacing) ? null : withLineSpacing(paragraphPPr(node), spacing)
     );
   };
 }

package/dist/editor/commands/tabCommands.js

@@ -4,8 +4,7 @@ import {
 } from "prosemirror-state";
 import { toParagraphFormat } from "../../model/format.js";
 import { docxSchema } from "../../schema/index.js";
-import { replacementShut } from "../../schema/locks.js";
-import { editsShut } from "../../schema/protectionState.js";
+import { editShut, selectionIntents } from "../../schema/guards.js";
 function isOrdinaryParagraph(state) {
   const { $from } = state.selection;
   if ($from.parent.type !== docxSchema.nodes.paragraph || toParagraphFormat($from.parent.attrs.format)?.numbering) {
@@ -18,7 +17,9 @@ function isOrdinaryParagraph(state) {
 }
 var insertTab = (state, dispatch) => {
   const { selection } = state;
-  if (!(selection instanceof TextSelection) || !selection.$from.sameParent(selection.$to) || !isOrdinaryParagraph(state) || editsShut(state) || replacementShut(selection, state.doc)) {
+  if (!(selection instanceof TextSelection) || !selection.$from.sameParent(selection.$to) || !isOrdinaryParagraph(state) || selectionIntents(selection, "replace").some(
+    (intent) => editShut(state, intent)
+  )) {
     return false;
   }
   if (dispatch) {

package/dist/editor/createEditor.d.ts

@@ -4,42 +4,25 @@
 import type { Node as PMNode } from "prosemirror-model";
 import { EditorState, type Plugin } from "prosemirror-state";
 import { EditorView } from "prosemirror-view";
-import { type ParagraphFormatLayer, type ParagraphStyleOption, type StyleTable } from "../docx/formatting";
-import { type PageGeometry } from "../docx/pageGeometry";
-import type { DocumentDefaults } from "../model/format";
-import { type Numbering } from "../numbering/parseNumbering";
+import type { SessionStore } from "../docx/session";
 import type { EditableComments, EditingProtection } from "../schema/protection";
 import { type FontFallbacks } from "../styles/fontStack";
 import type { CommentAuthor } from "./commands/comments/model";
+import { type EditorDocument } from "./editorDocument";
 export interface EditorStateOptions {
-    numbering?: Numbering;
-    styles?: StyleTable;
-    defaults?: DocumentDefaults;
-    /** Paragraph properties from styles.xml docDefaults. */
-    paragraphDefaults?: ParagraphFormatLayer;
     /**
-     * Whether the document has a place (numbering.xml) to write the definition of a new list.
-     * Callers that build a state without opening a document assume that place exists and behave
-     * as they do today.
+     * What the opened document laid down: its styles, its list definitions, the paper it is
+     * written on. A state built without one reads `NO_DOCUMENT`, which answers as nothing having
+     * been written down. `editorStateForSession` is what fills it in for an opened document.
      */
-    canStartNewList?: boolean;
+    document?: EditorDocument;
     /** The plugins handed in from outside the package */
     consumerPlugins?: readonly Plugin[];
-    /** The styles the document defines for the style picker to offer */
-    paragraphStyles?: ParagraphStyleOption[];
     /**
      * Whether the right click is the editor's own. Turned off, the browser's own menu is never
      * taken away, which is what a consumer drawing menus of its own needs.
      */
     contextMenus?: boolean;
-    /** The paper the document names. A4 where a document names none */
-    geometry?: PageGeometry;
-    /** The interval between automatic tab stops, in points. */
-    defaultTabStopPt?: number;
-    /** Every id already present in the opened Comments part, including unreferenced entries. */
-    reservedCommentIds?: Iterable<string>;
-    /** Every paragraph id present in the opened comment parts, including orphan extension entries. */
-    reservedCommentParaIds?: Iterable<string>;
     /**
      * What the document as a whole may receive (`schema/protection`): everything, comments alone,
      * or nothing. Everything when none is given, which is what every state was before.
@@ -53,17 +36,22 @@ export interface EditorStateOptions {
 /**
  * Creates a single editing state.
  * The list definitions, the style table, and the document defaults are what the document
- * wrote down, and commands and the toolbar read them through plugins.
+ * wrote down, and commands and the toolbar read them off the snapshot the state holds.
  */
-export declare function createEditorState(doc: PMNode, { numbering, styles, defaults, paragraphDefaults, canStartNewList, consumerPlugins, paragraphStyles, contextMenus, geometry, defaultTabStopPt, reservedCommentIds, reservedCommentParaIds, protection, author, editableComments, }?: EditorStateOptions): EditorState;
+export declare function createEditorState(doc: PMNode, options?: EditorStateOptions): EditorState;
+/**
+ * The state for a document that was opened, which is the one way a session becomes an editing
+ * state: what the screen builds and what a test builds are then the same values.
+ */
+export declare function editorStateForSession(opened: {
+    doc: PMNode;
+    session: SessionStore;
+}, options?: Omit<EditorStateOptions, "document">): EditorState;
 export interface EditorOptions {
     mount: HTMLElement;
     state: EditorState;
-    defaults: DocumentDefaults;
-    /** The paper the document names. The sheet is drawn from it, A4 where a document names none */
-    geometry?: PageGeometry;
     /** The fonts stood in for the ones the document declares. The built-in set when none is given */
     fontFallbacks?: FontFallbacks;
     onStateChange: (state: EditorState) => void;
 }
-export declare function createEditorView({ mount, state, defaults, geometry, fontFallbacks, onStateChange, }: EditorOptions): EditorView;
+export declare function createEditorView({ mount, state, fontFallbacks, onStateChange, }: EditorOptions): EditorView;

package/dist/editor/createEditor.js

@@ -6,13 +6,6 @@ import { keymap } from "prosemirror-keymap";
 import { EditorState } from "prosemirror-state";
 import { tableEditing } from "prosemirror-tables";
 import { EditorView } from "prosemirror-view";
-import { DEFAULT_TAB_STOP_PT } from "../docx/documentSettings.js";
-import {
-  NO_DOCUMENT_DEFAULTS,
-  NO_STYLES
-} from "../docx/formatting.js";
-import { A4_PORTRAIT } from "../docx/pageGeometry.js";
-import { EMPTY_NUMBERING } from "../numbering/parseNumbering.js";
 import { pageDecorations } from "../page/pageDecorations.js";
 import { pageGeometryStyle, pagePixels } from "../page/pageLayout.js";
 import { editsShut } from "../schema/protectionState.js";
@@ -21,24 +14,28 @@ import {
   DEFAULT_FONT_FALLBACKS
 } from "../styles/fontStack.js";
 import { documentDefaultsStyle } from "../styles/inlineStyle.js";
-import { gridBorders, withDerivedGridBorders } from "../table/gridBorders.js";
-import { documentDefaultTabStopPt, documentStyleTable } from "./documentStyles.js";
+import {
+  documentOf,
+  editorDocument,
+  editorDocumentOf,
+  NO_DOCUMENT
+} from "./editorDocument.js";
 import { externalClipboard } from "./externalClipboard.js";
 import { imageFiles } from "./imageFiles.js";
-import { bookmarkProtection } from "./plugins/bookmarkProtection.js";
 import { columnResize } from "./plugins/columnResize.js";
 import { commentDecorations } from "./plugins/commentDecorations.js";
-import { commentReservations } from "./plugins/commentReservations.js";
+import {
+  displayDerivation,
+  withDerivedDisplay
+} from "./plugins/displayDerivation.js";
 import { documentProtection } from "./plugins/documentProtection.js";
 import { imagePaste } from "./plugins/imagePaste.js";
 import { docxKeymap, historyKeys } from "./plugins/keymap.js";
 import { linkPanel } from "./plugins/linkPanel.js";
 import { listInputRules } from "./plugins/listInputRules.js";
 import { lockedContent } from "./plugins/lockedContent.js";
-import { noteProtection } from "./plugins/noteProtection.js";
 import { numberingMarkers } from "./plugins/numberingDecorations.js";
 import { rowResize } from "./plugins/rowResize.js";
-import { styledParagraphs } from "./plugins/styledParagraphs.js";
 import { tabCaret } from "./plugins/tabCaret.js";
 import { tabDecorations } from "./plugins/tabDecorations.js";
 import { tabLayout } from "./plugins/tabLayout.js";
@@ -47,41 +44,32 @@ import { tabPointer } from "./plugins/tabPointer.js";
 import { textContextMenu } from "./plugins/textContextMenu.js";
 import { ImageNodeView } from "./views/imageResize.js";
 import { runMarkView } from "./views/runMarkView.js";
-function createEditorState(doc, {
-  numbering = EMPTY_NUMBERING,
-  styles = NO_STYLES,
-  defaults = NO_DOCUMENT_DEFAULTS,
-  paragraphDefaults = {},
-  canStartNewList = true,
-  consumerPlugins = [],
-  paragraphStyles = [],
-  contextMenus = true,
-  geometry = A4_PORTRAIT,
-  defaultTabStopPt = DEFAULT_TAB_STOP_PT,
-  reservedCommentIds = [],
-  reservedCommentParaIds = [],
-  protection = "none",
-  author = null,
-  editableComments = "own"
-} = {}) {
+function createEditorState(doc, options = {}) {
+  const {
+    document = NO_DOCUMENT,
+    consumerPlugins = [],
+    contextMenus = true,
+    protection = "none",
+    author = null,
+    editableComments = "own"
+  } = options;
   return EditorState.create({
-    doc: withDerivedGridBorders(doc),
+    // The values the document arrived with were worked out against whatever opened it; the
+    // state's are worked out against its own snapshot, tables' shared lines included
+    doc: withDerivedDisplay(doc, document),
     plugins: [
       // Consumer plugins lead the array. ProseMirror walks the plugins in order and takes the
       // first answer for a keypress, a paste, a drop or any other DOM event, so this is the
       // only place from which a consumer handler can win over the built-in one.
       ...consumerPlugins,
-      // Refuses every edit inside a locked content control, whoever asked for it. It is not
-      // optional: a document that locked a part of itself stays locked in every consumer.
-      // The same guard refuses what the protection below shuts.
+      // Every document-level value the editor reads stands in one snapshot, and it leads the
+      // built-in plugins so that the ones drawing from it are initialized after it
+      editorDocument(document),
+      // Refuses every edit no guard in `schema/guards` lets through, whoever asked for it. It is
+      // not optional: a document that locked a part of itself stays locked in every consumer, and
+      // the preserved bookmark markers and note references stay where the file put them.
       lockedContent(),
       documentProtection({ protection, author, editableComments }),
-      // Bookmark ranges are preserved rather than edited, so neither half may disappear.
-      bookmarkProtection(),
-      // Note bodies are display-only, so their imported main-story references stay paired.
-      noteProtection(),
-      // An orphan Comments-part entry still owns its id and must not be replaced by a new comment.
-      commentReservations(reservedCommentIds, reservedCommentParaIds),
       history(),
       keymap(docxKeymap),
       historyKeys(),
@@ -108,52 +96,57 @@ function createEditorState(doc, {
       tabPointer(),
       tabLayout(),
       tabCaret(),
-      // Keeps table-cell lines aligned with OOXML precedence after an edit
-      gridBorders(),
-      // Reads the document's styles into the paragraphs an edit built from nothing
-      styledParagraphs(),
+      // Works the display values out again after every edit: the lines of a table's cells, and
+      // the style values of the paragraphs the edit built or rewrote
+      displayDerivation(),
       // Receiving a right-click means taking the browser's own menu away, so both of these stand
       // or fall together with the menus the editor draws. The text menu stands ahead of the table
       // menu, and hands a click with nothing selected inside a cell back to it
       ...contextMenus ? [textContextMenu(), tableContextMenu()] : [],
-      numberingMarkers(numbering, canStartNewList),
+      numberingMarkers(),
       // Values only go in when page display is turned on
-      pageDecorations(),
-      documentStyleTable(
-        styles,
-        defaults,
-        paragraphStyles,
-        geometry,
-        paragraphDefaults,
-        numbering,
-        defaultTabStopPt
-      )
+      pageDecorations()
     ]
   });
 }
+function editorStateForSession(opened, options = {}) {
+  return createEditorState(opened.doc, {
+    ...options,
+    document: editorDocumentOf(opened.session)
+  });
+}
+var sheetStyles = /* @__PURE__ */ new WeakMap();
+function sheetStyleOf(document, fallbacks) {
+  const remembered = sheetStyles.get(document);
+  if (remembered?.fallbacks === fallbacks) return remembered.style;
+  const style = `${pageGeometryStyle(pagePixels(document.geometry))};${documentDefaultsStyle(document.defaults, fallbacks)};`;
+  sheetStyles.set(document, { fallbacks, style });
+  return style;
+}
 function createEditorView({
   mount,
   state,
-  defaults,
-  geometry = A4_PORTRAIT,
   fontFallbacks = DEFAULT_FONT_FALLBACKS,
   onStateChange
 }) {
-  const sheetStyle = `${pageGeometryStyle(pagePixels(geometry))};${documentDefaultsStyle(defaults, fontFallbacks)};`;
   const view = new EditorView(mount, {
     state,
     // A protection that shuts the body shuts typing with it, and is read off the state so that a
     // mode switched on an open document takes effect without a new view. Selecting stays open
     // either way, which is what a reader marking a stretch for a comment needs
     editable: (current) => !editsShut(current),
-    attributes: (current) => ({
-      class: editorClassNames.sheet,
-      // The paper first, so a document that names one is drawn on it from the first frame
-      style: `${sheetStyle}tab-size:${documentDefaultTabStopPt(current)}pt`,
-      // A sheet that takes no typing is no longer focusable of itself, so a reader or a commenter
-      // is handed the focus another way: the keys reach it, and the selection stays its own
-      ...editsShut(current) ? { tabindex: "0" } : {}
-    }),
+    attributes: (current) => {
+      const document = documentOf(current);
+      return {
+        class: editorClassNames.sheet,
+        // The paper first, so a document that names one is drawn on it from the first frame
+        style: `${sheetStyleOf(document, fontFallbacks)}tab-size:${document.defaultTabStopPt}pt`,
+        // A sheet that takes no typing is no longer focusable of itself, so a reader or a
+        // commenter is handed the focus another way: the keys reach it, and the selection stays
+        // its own
+        ...editsShut(current) ? { tabindex: "0" } : {}
+      };
+    },
     // The schema can only draw a run with the default fallback fonts, so this editor draws its own
     markViews: { run: runMarkView(fontFallbacks) },
     // An image is drawn by a view of its own, which is what carries the resize handles
@@ -170,5 +163,6 @@ function createEditorView({
 }
 export {
   createEditorState,
-  createEditorView
+  createEditorView,
+  editorStateForSession
 };

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>;