@portone/docx-editor 0.2.1 → 0.4.0

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,57 @@
+/**
+ * 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 { Node as PMNode } from "prosemirror-model";
+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 definition of a new list has somewhere to go, which is what the commands that
+     * start one ask. A state built without opening a document assumes it has 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, doc: PMNode): 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 - the attrs of the
+ * document node, which is where such an edit is written - 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,86 @@
+// 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 { canDefineNewList } from "../docx/newLists.js";
+import { A4_PORTRAIT } from "../docx/pageGeometry.js";
+import { NEW_LISTS_ATTR, newListsOf } from "../numbering/listRegistry.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 formattingWithNewLists(formatting, doc) {
+  const added = newListsOf(doc.attrs[NEW_LISTS_ATTR]);
+  if (added.size === 0 && formatting.numbering.added.size === 0) {
+    return formatting;
+  }
+  return { ...formatting, numbering: { ...formatting.numbering, added } };
+}
+function editorDocumentOf(session, doc) {
+  return {
+    session,
+    formatting: formattingWithNewLists(session.formatting, doc),
+    defaults: session.defaults,
+    paragraphStyles: session.paragraphStyles,
+    canStartNewList: canDefineNewList(session),
+    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 derived(current, doc) {
+  return current.session === null ? {
+    ...current,
+    formatting: formattingWithNewLists(current.formatting, doc)
+  } : editorDocumentOf(current.session, doc);
+}
+function editorDocument(document) {
+  return new Plugin({
+    key: editorDocumentKey,
+    state: {
+      init: () => document,
+      apply: (tr, current, old) => tr.doc.attrs === old.doc.attrs ? current : derived(current, 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.d.ts

@@ -1,8 +1,19 @@
 import { Slice } from "prosemirror-model";
-import { type EditorState, Plugin } from "prosemirror-state";
+import { type EditorState, Plugin, type Transaction } from "prosemirror-state";
 import type { EditorView } from "prosemirror-view";
+import { type NewLists } from "../numbering/listRegistry";
 import type { ImageToInsert } from "./insertImage";
-export declare function richHtmlSlice(state: EditorState, document: Document, source: string, images?: ReadonlyMap<string, ImageToInsert>): Slice | null;
+/** What a paste puts in: the content, and the definitions of the lists it started */
+export interface PastedContent {
+    slice: Slice;
+    newLists: NewLists;
+}
+export declare function richHtmlSlice(state: EditorState, document: Document, source: string, images?: ReadonlyMap<string, ImageToInsert>): PastedContent | null;
+/**
+ * The transaction a paste is put in with: the content, and the definitions of the lists it started
+ * recorded on the document node so that the export writes them out and undo takes them back.
+ */
+export declare function withPastedContent(tr: Transaction, content: PastedContent): Transaction;
 export declare function insertRichHtml(view: EditorView, source: string): boolean;
 export declare function insertClipboardData(view: EditorView, data: {
     html?: string;

package/dist/editor/externalClipboard.js

@@ -5,11 +5,24 @@ import {
   Slice
 } from "prosemirror-model";
 import { Plugin } from "prosemirror-state";
-import { effectiveParagraphFormat, styleIdOf } from "../docx/formatting.js";
-import { 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 {
+  paragraphAttrsFor,
+  styleIdOf
+} from "../docx/formatting.js";
+import {
+  withListNumbering,
+  withParagraphStyle
+} from "../docx/paraProps.js";
+import {
+  listsWorn,
+  NEW_LISTS_ATTR,
+  newListsValue
+} from "../numbering/listRegistry.js";
+import {
+  allocateList,
+  MAX_ILVL,
+  templateList
+} from "../numbering/listTemplate.js";
 import { docxSchema, isPageBreak } from "../schema/index.js";
 import { editorClassNames } from "../styles/classNames.js";
 import { PASTED_IMAGE_ATTRIBUTE } from "./clipboard/images.js";
@@ -20,19 +33,11 @@ import {
   safeHref,
   withInlineStyle
 } from "./clipboard/inlineFormatting.js";
-import { listRefOf } from "./commands/listCommands.js";
-import {
-  defaultParagraphStyleId,
-  documentParagraphFormatting,
-  documentParagraphStyles,
-  documentStyles
-} from "./documentStyles.js";
+import { numIdsIn } from "./commands/listCommands.js";
+import { documentFormatting, documentParagraphStyles } from "./documentStyles.js";
 import { insertPlainText } from "./plainText.js";
 import { moveCaretToDrop } from "./plugins/dropCaret.js";
-import {
-  canStartNewList,
-  documentNumbering
-} from "./plugins/numberingDecorations.js";
+import { canStartNewList } from "./plugins/numberingDecorations.js";
 var BLOCK_TAGS = /* @__PURE__ */ new Set([
   "ADDRESS",
   "ARTICLE",
@@ -242,12 +247,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,56 +258,24 @@ 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))
-  };
-}
-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
-  } : null;
-}
-function usedNumIds(state) {
-  const used = new Set(documentNumbering(state).lists.keys());
-  state.doc.descendants((node) => {
-    if (node.type !== docxSchema.nodes.paragraph) return true;
-    const ref = listRefOf(node);
-    if (ref) used.add(ref.numId);
-    return false;
+  return withListNumbering(null, {
+    numbering: { numId: list.numId, ilvl: Math.min(MAX_ILVL, list.level) },
+    indent: { kind: "keep" }
   });
-  return used;
+}
+function paragraphAttrs(formatting, list, paragraph) {
+  const props = listParagraphProps(list) ?? paragraph;
+  return props ? { pPr: props.pPr, ...paragraphAttrsFor(props.pPr, formatting) } : null;
 }
 var HtmlReader = class {
   constructor(state, preserveParagraphStyles, images) {
     this.state = state;
     this.preserveParagraphStyles = preserveParagraphStyles;
     this.images = images;
-    this.used = usedNumIds(state);
+    this.formatting = documentFormatting(state);
+    this.used = numIdsIn(state.doc);
     this.canCreateLists = canStartNewList(state);
   }
   state;
@@ -316,6 +284,16 @@ var HtmlReader = class {
   blocks = [];
   used;
   canCreateLists;
+  /**
+   * What the pasted paragraphs are resolved against: the document's context, holding the
+   * definition of each pasted list as it is read, so that an item is drawn against the list it
+   * is joining rather than against a list nothing yet defines.
+   */
+  formatting;
+  /** The definitions of every list started while editing, the pasted ones among them */
+  get newLists() {
+    return this.formatting.numbering.added;
+  }
   read(root) {
     this.readFlow(root, { style: {}, href: null, preserveWhitespace: false });
     return this.blocks;
@@ -347,7 +325,7 @@ var HtmlReader = class {
     }
     this.blocks.push(
       docxSchema.nodes.paragraph.create(
-        paragraphAttrs(this.state, list, paragraph),
+        paragraphAttrs(this.formatting, list, paragraph),
         content
       )
     );
@@ -383,11 +361,20 @@ var HtmlReader = class {
     }
     flush();
   }
+  /**
+   * The number a pasted list takes, registered with the definition that list is drawn and written
+   * with. A pasted list is started here just as the list button starts one.
+   */
   takeNumId(kind) {
     if (!this.canCreateLists) return null;
-    const id = nextNumId(this.used, kind);
-    this.used.add(id);
-    return id;
+    const started = allocateList(
+      this.formatting.numbering,
+      this.used,
+      templateList(kind)
+    );
+    this.formatting = { ...this.formatting, numbering: started.numbering };
+    this.used.add(started.numId);
+    return started.numId;
   }
   readList(list, context, level, inherited) {
     const kind = list.tagName === "UL" ? "bullet" : "numbered";
@@ -436,15 +423,28 @@ function richHtmlSlice(state, document, source, images = /* @__PURE__ */ new Map
   const template = document.createElement("template");
   template.innerHTML = source;
   const open = sliceDepth(template.content);
-  const blocks = new HtmlReader(state, open === 0, images).read(
-    template.content
+  const reader = new HtmlReader(state, open === 0, images);
+  const blocks = reader.read(template.content);
+  return blocks.length === 0 ? null : {
+    slice: new Slice(Fragment.fromArray([...blocks]), open, open),
+    newLists: reader.newLists
+  };
+}
+function withPastedContent(tr, content) {
+  return tr.setDocAttribute(
+    NEW_LISTS_ATTR,
+    newListsValue(listsWorn(content.newLists, numIdsIn(tr.doc)))
   );
-  return blocks.length === 0 ? null : new Slice(Fragment.fromArray([...blocks]), open, open);
 }
 function insertRichHtml(view, source) {
-  const slice = richHtmlSlice(view.state, view.dom.ownerDocument, source);
-  if (slice === null) return false;
-  view.dispatch(view.state.tr.replaceSelection(slice).scrollIntoView());
+  const content = richHtmlSlice(view.state, view.dom.ownerDocument, source);
+  if (content === null) return false;
+  view.dispatch(
+    withPastedContent(
+      view.state.tr.replaceSelection(content.slice),
+      content
+    ).scrollIntoView()
+  );
   return true;
 }
 function insertClipboardData(view, data) {
@@ -481,5 +481,6 @@ export {
   externalClipboard,
   insertClipboardData,
   insertRichHtml,
-  richHtmlSlice
+  richHtmlSlice,
+  withPastedContent
 };

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,7 @@
  */
 import type { Node as PMNode } from "prosemirror-model";
 import type { EditorState, Transaction } from "prosemirror-state";
-import { type StyleTable } from "../docx/formatting";
+import { type FormattingContext } from "../docx/formatting";
 import type { ParagraphProps } from "../docx/paraProps";
 export interface ParagraphSpot {
     pos: number;
@@ -17,28 +17,36 @@ 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;
+/** What an edit does beyond swapping the fragments of the paragraphs it names */
+export interface ParagraphEditExtras {
+    /**
+     * The context the new display values are resolved against, which is the state's own unless the
+     * edit is itself changing it. An edit that starts a list hands in the context that already
+     * holds it, so the paragraph is drawn against the list it is joining in that same transaction.
+     */
+    formatting?: FormattingContext;
+    /**
+     * What else the edit records in the same transaction, such as the definition of the list the
+     * paragraphs are joining, so that undo takes the two back together.
+     */
+    alongside?: (tr: Transaction) => void;
+}
 /** 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;
+export declare function editParagraphs(state: EditorState, dispatch: ((tr: Transaction) => void) | undefined, surgery: ParagraphSurgery, extras?: ParagraphEditExtras): boolean;

package/dist/editor/paragraphEdits.js

@@ -1,13 +1,9 @@
 // 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";
+import { paragraphPlacementAt } from "./paragraphPlacement.js";
 function selectedParagraphs(state) {
   const spots = /* @__PURE__ */ new Map();
   for (const range of state.selection.ranges) {
@@ -20,37 +16,40 @@ 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) {
   const pPr = node.attrs.pPr;
   return typeof pPr === "string" ? pPr : null;
 }
-function writeChanges(state, changed) {
+function writeChanges(state, changed, extras) {
   const tr = state.tr;
-  const formatting = documentParagraphFormatting(state);
+  const formatting = extras.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,
+        paragraphPlacementAt(state.doc, spot.pos)
+      )
     });
   }
+  extras.alongside?.(tr);
   return tr;
 }
-function editParagraphs(state, dispatch, surgery) {
-  const styles = documentStyles(state);
-  const defaultStyleId = defaultParagraphStyleId(state);
+function editParagraphs(state, dispatch, surgery, extras = {}) {
   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;
-  if (dispatch) dispatch(writeChanges(state, changed).scrollIntoView());
+  if (dispatch) {
+    dispatch(writeChanges(state, changed, extras).scrollIntoView());
+  }
   return true;
 }
 export {

package/dist/editor/paragraphPlacement.d.ts

@@ -0,0 +1,11 @@
+/** Finds the table-style conditions at an editor position for both reads and writes. */
+import type { Node as PMNode } from "prosemirror-model";
+import type { ParagraphPlacement } from "../docx/formatting";
+/**
+ * The part of a table the paragraph stands in, which its table style dresses it by. null for a
+ * paragraph of the body, and for one in a cell of a table this editor did not build.
+ *
+ * The cell is found by walking out of the paragraph rather than passed down, because the walk that
+ * runs the derivers goes over the blocks and hands each of them nothing but its own position.
+ */
+export declare function paragraphPlacementAt(doc: PMNode, pos: number): ParagraphPlacement | null;

package/dist/editor/paragraphPlacement.js

@@ -0,0 +1,18 @@
+// src/editor/paragraphPlacement.ts
+import { TableMap } from "prosemirror-tables";
+import { docxSchema } from "../schema/index.js";
+import { cellDefaultsAt, tableCellSources } from "../table/gridBorders.js";
+function paragraphPlacementAt(doc, pos) {
+  const $pos = doc.resolve(pos);
+  for (let depth = $pos.depth; depth >= 2; depth -= 1) {
+    if ($pos.node(depth).type !== docxSchema.nodes.tableCell) continue;
+    const table = $pos.node(depth - 2);
+    if (table.type !== docxSchema.nodes.table) return null;
+    const cell = $pos.before(depth) - $pos.start(depth - 2);
+    return cellDefaultsAt(TableMap.get(table), cell, tableCellSources(table)).placement;
+  }
+  return null;
+}
+export {
+  paragraphPlacementAt
+};