@portone/docx-editor 0.4.0 → 0.5.1

package/dist/editor/commands/comments/model.js

@@ -0,0 +1,11 @@
+// src/editor/commands/comments/model.ts
+function stringAttr(value) {
+  return typeof value === "string" ? value : null;
+}
+function repliesAttr(value) {
+  return Array.isArray(value) ? value : [];
+}
+export {
+  repliesAttr,
+  stringAttr
+};

package/dist/editor/commands/comments/reading.d.ts

@@ -1,11 +1,13 @@
 /** Reads comment threads and anchors from the editor document. */
 import type { EditorState } from "prosemirror-state";
-import type { CommentReplyData } from "../../../docx/comments";
 import type { DocumentComment } from "./model";
-export declare function stringAttr(value: unknown): string | null;
-export declare function repliesAttr(value: unknown): readonly CommentReplyData[];
 /** Comments in document order, including point comments that have no explicit range. */
 export declare function documentComments(state: EditorState): readonly DocumentComment[];
+/**
+ * The comment this id names, or undefined where the document holds none. Answered off the lookup
+ * the projection built, so a command asking after one comment does not read the whole list.
+ */
+export declare function commentById(state: EditorState, id: string): DocumentComment | undefined;
 /**
  * Whether the body of this comment, or of one of its replies, may be edited or deleted here: the
  * protection lets comments be edited at all, and the body is one of one's own to edit

package/dist/editor/commands/comments/reading.js

@@ -1,72 +1,22 @@
 // src/editor/commands/comments/reading.ts
 import { commentOwned } from "../../../schema/protection.js";
 import { protectionOf } from "../../../schema/protectionState.js";
-function stringAttr(value) {
-  return typeof value === "string" ? value : null;
-}
-function repliesAttr(value) {
-  return Array.isArray(value) ? value : [];
-}
-function markerPositions(doc) {
-  const starts = /* @__PURE__ */ new Map();
-  const ends = /* @__PURE__ */ new Map();
-  const references = [];
-  doc.descendants((node, pos) => {
-    const id = stringAttr(node.attrs.id);
-    if (id === null) return true;
-    if (node.type.name === "commentStart" && !starts.has(id)) {
-      starts.set(id, pos);
-    } else if (node.type.name === "commentEnd" && !ends.has(id)) {
-      ends.set(id, pos);
-    } else if (node.type.name === "commentReference") {
-      references.push({ node, pos });
-    }
-    return true;
-  });
-  return { starts, ends, references };
-}
+import { commentProjection } from "../../plugins/commentDecorations.js";
 function documentComments(state) {
-  const markers = markerPositions(state.doc);
-  return markers.references.map(({ node, pos }) => {
-    const id = stringAttr(node.attrs.id) ?? "";
-    const start = markers.starts.get(id);
-    const end = markers.ends.get(id);
-    const hasRange = start !== void 0 && end !== void 0 && start < end;
-    const point = start ?? end ?? pos;
-    return {
-      id,
-      author: stringAttr(node.attrs.author),
-      authorId: stringAttr(node.attrs.authorId),
-      initials: stringAttr(node.attrs.initials),
-      date: stringAttr(node.attrs.date),
-      text: stringAttr(node.attrs.text) ?? "",
-      from: hasRange ? start + 1 : point,
-      to: hasRange ? end : point,
-      referencePos: pos,
-      resolved: node.attrs.resolved === true,
-      replies: repliesAttr(node.attrs.replies).map((reply) => ({
-        id: reply.id,
-        author: reply.author,
-        authorId: reply.authorId,
-        initials: reply.initials,
-        date: reply.date,
-        text: reply.text
-      }))
-    };
-  });
+  return commentProjection.read(state).comments;
+}
+function commentById(state, id) {
+  return commentProjection.read(state).byId.get(id);
 }
 function canEditComment(state, commentId, replyId = null) {
   const rules = protectionOf(state);
   if (rules.protection === "readOnly") return false;
-  const comment = documentComments(state).find(
-    (entry) => entry.id === commentId
-  );
+  const comment = commentById(state, commentId);
   const body = replyId === null ? comment : comment?.replies.find((reply) => reply.id === replyId);
   return body !== void 0 && commentOwned(rules, body.authorId);
 }
 export {
   canEditComment,
-  documentComments,
-  repliesAttr,
-  stringAttr
+  commentById,
+  documentComments
 };

package/dist/editor/commands/index.d.ts

@@ -56,8 +56,8 @@ export { insertLineBreak, insertPageBreak } from "./breakCommands";
  * question takes are not exported anywhere.
  */
 export { canRunCommand } from "./canRunCommand";
-export type { CommentAuthor, DocumentComment, DocumentCommentReply, NewComment, } from "./commentCommands";
-export { addComment, addCommentReply, canAddComment, canEditComment, documentComments, removeComment, removeCommentReply, selectComment, setCommentResolved, updateComment, updateCommentReply, } from "./commentCommands";
+export type { CommentAuthor, CommentRange, DocumentComment, DocumentCommentReply, NewComment, } from "./commentCommands";
+export { addComment, addCommentReply, canAddComment, canEditComment, documentComments, removeComment, removeCommentReply, selectComment, setCommentBody, setCommentResolved, updateComment, updateCommentReply, } from "./commentCommands";
 /**
  * Whether the document as it stands can be written back, and every reason it could not, each
  * with the code `exportDocx` would throw it under. `canExport` is what an export control is

package/dist/editor/commands/index.js

@@ -25,6 +25,7 @@ import {
   removeComment,
   removeCommentReply,
   selectComment,
+  setCommentBody,
   setCommentResolved,
   updateComment,
   updateCommentReply
@@ -158,6 +159,7 @@ export {
   selectComment,
   selectionLock,
   selectionTouchesLocked,
+  setCommentBody,
   setCommentResolved,
   setFontFamily,
   setFontSize,

package/dist/editor/commands/linkCommands.js

@@ -1,6 +1,7 @@
 // src/editor/commands/linkCommands.ts
 import { docxSchema } from "../../schema/index.js";
 import { openStretches } from "../../schema/guards.js";
+import { innermostDepth, wrapperMarks, wrapperOf } from "../../schema/wrappers.js";
 var linkType = docxSchema.marks.link;
 function text(value) {
   return typeof value === "string" ? value : null;
@@ -16,6 +17,15 @@ function settled(address) {
 function linkMarkOf(marks) {
   return marks.find((mark) => mark.type === linkType) ?? null;
 }
+function linkOf(node) {
+  return wrapperOf(node, linkType);
+}
+function sameLink(a, b) {
+  return atDepth(a, 0).eq(atDepth(b, 0));
+}
+function atDepth(mark, depth) {
+  return mark.attrs.depth === depth ? mark : mark.type.create({ ...mark.attrs, depth });
+}
 function linkable(node, parent) {
   if (parent === null || !parent.type.allowsMarkType(linkType)) return false;
   return node.isText || node.type.allowsMarkType(linkType);
@@ -28,7 +38,10 @@ function piecesIn(doc, from, to) {
     const start = Math.max(pos, from);
     const end = Math.min(pos + node.nodeSize, to);
     if (start < end) {
-      pieces.push({ from: start, to: end, link: linkMarkOf(node.marks) });
+      const link = linkOf(node);
+      pieces.push(
+        link === null ? { from: start, to: end, link, wrappers: wrapperMarks(node) } : { from: start, to: end, link }
+      );
     }
     return false;
   });
@@ -37,12 +50,12 @@ function piecesIn(doc, from, to) {
 function linkSpans(parent, start) {
   const spans = [];
   parent.forEach((child, offset) => {
-    const link = linkMarkOf(child.marks);
+    const link = linkOf(child);
     if (!link) return;
     const from = start + offset;
     const to = from + child.nodeSize;
     const last = spans.at(-1);
-    if (last && last.to === from && last.link.eq(link)) last.to = to;
+    if (last && last.to === from && sameLink(last.link, link)) last.to = to;
     else spans.push({ from, to, link });
   });
   return spans;
@@ -52,7 +65,7 @@ function caretSpan(state) {
   const link = linkMarkOf($from.marks());
   if (!link) return null;
   return linkSpans($from.parent, $from.start()).find(
-    (span) => span.link.eq(link) && span.from <= $from.pos && $from.pos <= span.to
+    (span) => sameLink(span.link, link) && span.from <= $from.pos && $from.pos <= span.to
   ) ?? null;
 }
 function selectionSpan(state) {
@@ -93,7 +106,9 @@ function selectionPieces(state) {
   ]);
 }
 function linkMarkFor(piece, href) {
-  return linkType.create({ ...piece.link?.attrs, href });
+  if (piece.link !== null)
+    return linkType.create({ ...piece.link.attrs, href });
+  return linkType.create({ href, depth: innermostDepth(piece.wrappers) + 1 });
 }
 function setLink(url) {
   return (state, dispatch) => {

package/dist/editor/commands/listCommands.d.ts

@@ -33,6 +33,12 @@ export declare function numIdsIn(doc: PMNode): Set<number>;
  * of its own stays, putting it back where it was before it joined the list.
  */
 export declare const removeFromList: Command;
+/**
+ * The kind of this list position, which the number format of its level decides.
+ * Null where nothing defines the list, which is a position whose kind cannot be told and so is
+ * neither of the two buttons.
+ */
+export declare function listKindOf(numbering: Numbering, ref: NumberingRef): ListKind | null;
 /**
  * The kind of list the selected paragraphs belong to. Null when they are not a list, when nothing
  * defines the list they are in, or when the kinds are mixed.

package/dist/editor/commands/listCommands.js

@@ -122,7 +122,7 @@ var removeFromList = (state, dispatch) => changeParagraphs(
   dispatch,
   (node) => listRefOf(node) ? { numbering: null, indent: { kind: "clearHanging" } } : null
 );
-function kindOf(numbering, ref) {
+function listKindOf(numbering, ref) {
   const level = listFor(numbering, ref.numId)?.levels.get(ref.ilvl);
   if (!level) return null;
   return level.format === "bullet" ? "bullet" : "numbered";
@@ -131,7 +131,7 @@ function activeListKind(state) {
   const numbering = documentNumbering(state);
   const kinds = editableParagraphs(state).map(({ node }) => {
     const ref = listRefOf(node);
-    return ref === null ? null : kindOf(numbering, ref);
+    return ref === null ? null : listKindOf(numbering, ref);
   });
   const first = kinds[0] ?? null;
   return kinds.every((kind) => kind === first) ? first : null;
@@ -174,6 +174,7 @@ export {
   increaseListLevel,
   isInList,
   leaveEmptyListItem,
+  listKindOf,
   listLevelChange,
   listRefOf,
   numIdsIn,

package/dist/editor/commands/lockCommands.js

@@ -14,9 +14,11 @@ import {
   unlockAllowed
 } from "../../schema/locks.js";
 import { editsShut } from "../../schema/protectionState.js";
-function lockedControlMark(id) {
+import { innermostDepth, sharedWrappers } from "../../schema/wrappers.js";
+function lockedControlMark(id, depth) {
   return docxSchema.marks.sdt.create({
     sdtPrefix: lockedControlPrefix(id),
+    depth,
     contentsLocked: true,
     deletionLocked: true
   });
@@ -45,11 +47,26 @@ function overlaps(a, b) {
 function reaches(a, b) {
   return a.from <= b.to && a.to >= b.from;
 }
+function contains(a, b) {
+  return a.from <= b.from && a.to >= b.to;
+}
 function stretchIn(block, reach) {
   const from = Math.max(block.start, reach.from);
   const to = Math.min(block.start + block.node.content.size, reach.to);
   return from < to ? { from, to } : null;
 }
+function wrapperDepthOver(block, stretch, replaced = null) {
+  const covered = [];
+  block.node.forEach((child, offset) => {
+    const from = block.start + offset;
+    if (from < stretch.to && stretch.from < from + child.nodeSize) {
+      covered.push(child);
+    }
+  });
+  const shared = sharedWrappers(covered);
+  const at = replaced === null ? -1 : shared.findIndex((wrapper) => wrapper.eq(replaced));
+  return innermostDepth(at === -1 ? shared : shared.slice(0, at)) + 1;
+}
 function gapsIn(stretch, spans) {
   const gaps = [];
   let at = stretch.from;
@@ -61,38 +78,56 @@ function gapsIn(stretch, spans) {
   if (at < stretch.to) gaps.push({ from: at, to: stretch.to });
   return gaps;
 }
-function takeover(met, stretch, open) {
+function takeover(block, met, stretch, open) {
   const only = met.length === 1 ? met[0] : null;
   const prefix = only && prefixOf(only.mark.attrs);
   if (!only || isLocked(only.mark) || !prefix || !namesNothing(prefix)) {
     return null;
   }
-  const mark = open ? withLock(only.mark, true) : null;
-  return mark ? {
+  const locked = open ? withLock(only.mark, true) : null;
+  if (!locked) return null;
+  const widened = {
     from: Math.min(stretch.from, only.from),
-    to: Math.max(stretch.to, only.to),
-    mark
-  } : null;
+    to: Math.max(stretch.to, only.to)
+  };
+  const depth = wrapperDepthOver(block, widened, only.mark);
+  return {
+    ...widened,
+    mark: depth === locked.attrs.depth ? locked : locked.type.create({ ...locked.attrs, depth }),
+    replaces: only.mark
+  };
+}
+function outermost(spans) {
+  const kept = [];
+  for (const span of spans) {
+    if (!kept.some((other) => overlaps(other, span))) kept.push(span);
+  }
+  return kept;
 }
 function blockLockEdits(state, block, spans, reach) {
   const stretch = stretchIn(block, reach);
   if (!stretch) return [];
   const open = (of) => openStretches(state, of, "mark");
-  const met = spans.filter((span) => overlaps(span, stretch));
-  const taken = takeover(met, stretch, open([stretch]).length > 0);
+  const met = outermost(spans.filter((span) => overlaps(span, stretch)));
+  const taken = takeover(block, met, stretch, open([stretch]).length > 0);
   if (taken) return [taken];
   const shut = open(met.filter((span) => !isLocked(span.mark))).flatMap(
     (span) => {
       const mark = withLock(span.mark, true);
-      return mark ? [{ from: span.from, to: span.to, mark }] : [];
+      return mark ? [{ from: span.from, to: span.to, mark, replaces: span.mark }] : [];
     }
   );
   const fresh = open(gapsIn(stretch, spans)).map((gap) => ({
     ...gap,
-    mark: lockedControlMark(newControlId())
+    mark: lockedControlMark(newControlId(), wrapperDepthOver(block, gap))
   }));
   return [...shut, ...fresh];
 }
+function liftable(locked, reach) {
+  return locked.filter(
+    (span, index) => contains(reach, span) || !locked.slice(index + 1).some((inner) => contains(span, inner))
+  );
+}
 function selectionLockDetail(state) {
   const selection = state.selection;
   const locking = !selection.empty && selection instanceof TextSelection;
@@ -106,9 +141,14 @@ function selectionLockDetail(state) {
       if (!node.isTextblock) return true;
       const block = { node, start: pos + 1 };
       const controls = controlSpans(block);
-      for (const span of controls) {
-        if (isLocked(span.mark) && reaches(span, reach)) spans.push(span);
-      }
+      spans.push(
+        ...liftable(
+          controls.filter(
+            (span) => isLocked(span.mark) && reaches(span, reach)
+          ),
+          reach
+        )
+      );
       if (locking) {
         edits.push(...blockLockEdits(state, block, controls, reach));
       }
@@ -153,7 +193,10 @@ var lockSelection = guardedCommand((state) => {
   const edits = lockEditsOf(selectionLockDetail(state));
   if (edits.length === 0) return null;
   const tr = state.tr;
-  for (const edit of edits) tr.addMark(edit.from, edit.to, edit.mark);
+  for (const edit of edits) {
+    if (edit.replaces) tr.removeMark(edit.from, edit.to, edit.replaces);
+    tr.addMark(edit.from, edit.to, edit.mark);
+  }
   return tr;
 });
 function unlockCell(tr, cell) {
@@ -171,8 +214,8 @@ var unlockSelection = guardedCommand((state) => {
   const tr = state.tr.setMeta(unlockAllowed, true);
   for (const span of spans) {
     const opened = withLock(span.mark, false);
+    tr.removeMark(span.from, span.to, span.mark);
     if (opened) tr.addMark(span.from, span.to, opened);
-    else tr.removeMark(span.from, span.to, span.mark);
   }
   for (const cell of cells) unlockCell(tr, cell);
   return tr;

package/dist/editor/commands/noteQueries.d.ts

@@ -1,12 +1,29 @@
 /** Document-level readers for imported footnotes and endnotes. */
 import type { EditorState } from "prosemirror-state";
+import { DecorationSet } from "prosemirror-view";
 import type { NoteKind } from "../../docx/notes";
 export interface DocumentNote {
-    kind: NoteKind;
-    id: string;
-    label: string;
-    text: string;
-    referencePos: number;
+    readonly kind: NoteKind;
+    readonly id: string;
+    readonly label: string;
+    readonly text: string;
+    readonly referencePos: number;
 }
+interface NoteProjection {
+    notes: readonly DocumentNote[];
+    /**
+     * The body of each note on the marker pointing at it, which is the tooltip a reader gets without
+     * looking away from the line. It is drawn rather than written on the node, because what a note
+     * says is a story on the document and not an attr of the reference.
+     */
+    tooltips: DecorationSet;
+}
+/**
+ * Which notes the document refers to is the document's to decide, so the list is worked out once
+ * per edit (`editor/plugins/documentProjection`) rather than once per render of the panel under
+ * the page.
+ */
+export declare const noteProjection: import("../plugins/documentProjection").DocumentProjection<NoteProjection>;
 /** The distinct notes referenced by the main document story, in first-reference order. */
 export declare function documentNotes(state: EditorState): readonly DocumentNote[];
+export {};

package/dist/editor/commands/noteQueries.js

@@ -1,15 +1,29 @@
 // src/editor/commands/noteQueries.ts
+import { Decoration, DecorationSet } from "prosemirror-view";
+import { storyKey, storyOf, storyText } from "../../docx/story.js";
+import { documentProjection } from "../plugins/documentProjection.js";
 function stringAttr(value) {
   return typeof value === "string" ? value : null;
 }
-function documentNotes(state) {
+function noteKindOf(node) {
+  return node.attrs.kind === "endnote" ? "endnote" : "footnote";
+}
+function noteText(doc, kind, id) {
+  return storyText(storyOf(doc, storyKey(kind, id)));
+}
+function deriveNotes(doc) {
   const notes = [];
+  const tooltips = [];
   const seen = /* @__PURE__ */ new Set();
-  state.doc.descendants((node, pos) => {
+  doc.descendants((node, pos) => {
     if (node.type.name !== "noteReference") return true;
     const id = stringAttr(node.attrs.id);
     if (id === null) return true;
-    const kind = node.attrs.kind === "endnote" ? "endnote" : "footnote";
+    const kind = noteKindOf(node);
+    const text = noteText(doc, kind, id);
+    if (text !== "") {
+      tooltips.push(Decoration.node(pos, pos + node.nodeSize, { title: text }));
+    }
     const key = `${kind}:${id}`;
     if (seen.has(key)) return true;
     seen.add(key);
@@ -17,13 +31,27 @@ function documentNotes(state) {
       kind,
       id,
       label: stringAttr(node.attrs.label) ?? "?",
-      text: stringAttr(node.attrs.text) ?? "",
+      text,
       referencePos: pos
     });
     return true;
   });
-  return notes;
+  return { notes, tooltips: DecorationSet.create(doc, tooltips) };
+}
+var noteProjection = documentProjection(
+  "docxEditorNotes",
+  deriveNotes,
+  {
+    // The set the last edit derived. Written as a method so that `this` is the plugin holding it
+    decorations(state) {
+      return this.getState(state)?.tooltips;
+    }
+  }
+);
+function documentNotes(state) {
+  return noteProjection.read(state).notes;
 }
 export {
-  documentNotes
+  documentNotes,
+  noteProjection
 };

package/dist/editor/commands/paragraphCommands.js

@@ -2,14 +2,14 @@
 import {
   paragraphAttrsOf,
   resolveParagraph,
-  runMarkUnder,
-  styleIdOf
+  runMarkUnder
 } from "../../docx/formatting.js";
 import {
   withParagraphAlign,
   withParagraphStyle
 } from "../../docx/paraProps.js";
 import { toParagraphFormat } from "../../model/format.js";
+import { styleIdOf } from "../../ooxml/props.js";
 import { docxSchema } from "../../schema/index.js";
 import { lockedMarkOf } from "../../schema/locks.js";
 import { documentFormatting } from "../documentStyles.js";

package/dist/editor/createEditor.js

@@ -14,15 +14,17 @@ import {
   DEFAULT_FONT_FALLBACKS
 } from "../styles/fontStack.js";
 import { documentDefaultsStyle } from "../styles/inlineStyle.js";
+import { docxClipboard } from "./clipboard/plugin.js";
+import { noteProjection } from "./commands/noteQueries.js";
 import {
   documentOf,
   editorDocument,
   editorDocumentOf,
   NO_DOCUMENT
 } from "./editorDocument.js";
-import { externalClipboard } from "./externalClipboard.js";
 import { imageFiles } from "./imageFiles.js";
 import { columnResize } from "./plugins/columnResize.js";
+import { commentComposer } from "./plugins/commentComposer.js";
 import { commentDecorations } from "./plugins/commentDecorations.js";
 import {
   displayDerivation,
@@ -80,17 +82,22 @@ function createEditorState(doc, options = {}) {
       // above, is what takes such a conversion back
       listInputRules(),
       dropCursor(),
-      // Clipboard priority is files, resolvable HTML images, then regular HTML or plain text.
+      // Images get the first reading. The clipboard then handles only empty readings and text
+      // fallbacks; tableEditing owns insertion into a cell selection for every nonempty slice.
       imageFiles(),
       imagePaste(),
-      externalClipboard(),
+      docxClipboard(),
       // A press that grabs a table edge must be intercepted before a cell-selection drag starts.
       // For DOM events the plugin registered first wins, so both resizers precede `tableEditing`.
       columnResize(),
       rowResize(),
       tableEditing(),
       // Comment anchors live in the model; this paints their ranges without changing document XML.
+      // The list beside the page, the lookup the comment commands ask, and these ranges are the
+      // one walk this plugin holds (`plugins/commentDecorations`)
       commentDecorations(),
+      // What the notes under the page are, worked out from the document the same way
+      noteProjection.plugin,
       // Adjacent text tabs still need separate DOM ranges for layout and pointer selection.
       tabDecorations(),
       tabPointer(),
@@ -103,6 +110,9 @@ function createEditorState(doc, options = {}) {
       // 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()] : [],
+      // Holds the stretch of text the built-in comment composer was opened over. It reads the
+      // protection above it, so it stands after the plugin that holds one
+      commentComposer(),
       numberingMarkers(),
       // Values only go in when page display is turned on
       pageDecorations()

package/dist/editor/documentStyles.d.ts

@@ -19,10 +19,25 @@ export declare function documentDefaults(state: EditorState): DocumentDefaults;
 /** The paragraph styles this document defines. Empty when the editor does not know them */
 export declare function documentParagraphStyles(state: EditorState): ParagraphStyleOption[];
 /**
- * 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
+ * The paper the sheet is drawn on: the first section's, since one sheet is drawn at one paper
+ * (`page/pageLayout`). A document the editor knows no paper for is drawn on the same A4 every
+ * document was drawn on before the geometry was read.
+ *
+ * Anything deciding a value for one spot in the document - the width of a table put there, the
+ * height a pasted image is fitted to - asks `sectionGeometryAt` instead, since a later section may
+ * be written on another paper.
  */
 export declare function documentGeometry(state: EditorState): PageGeometry;
+/**
+ * The paper the block at this position is written on: the paper of the section that block belongs
+ * to (`docx/sections`), which is the width a table inserted or resized there is fitted to.
+ *
+ * The section table is read off the document rather than off the snapshot the state carries: a
+ * section is where the document says it is, and the snapshot holds the first section's paper
+ * alone. Reading it walks every block, so a caller drawing a whole document asks once and looks
+ * its positions up (`page/pageLayout`) rather than calling this per block.
+ */
+export declare function sectionGeometryAt(state: EditorState, pos: number): PageGeometry;
 /** The document-wide interval between automatic tab stops, in points. */
 export declare function documentDefaultTabStopPt(state: EditorState): number;
 /**
@@ -32,5 +47,12 @@ export declare function documentDefaultTabStopPt(state: EditorState): number;
  * itself asks for it rather than taking the A4 width `fittedExtent` falls back to.
  */
 export declare function documentBodyWidthPx(state: EditorState): number;
-/** The height one page of body content occupies, in pixels. */
-export declare function documentBodyHeightPx(state: EditorState): number;
+/**
+ * The height one page of body content occupies at this position, in pixels: the height the paper
+ * of the section that block sits in leaves.
+ *
+ * It is the height an image taller than the page is shrunk to when it is pasted there, so a tall
+ * image dropped into a section on shorter paper is fitted to that section rather than to the
+ * sheet's own.
+ */
+export declare function sectionBodyHeightPx(state: EditorState, pos: number): number;

package/dist/editor/documentStyles.js

@@ -4,6 +4,7 @@ import {
   bodyWidth,
   twipsToPx
 } from "../docx/pageGeometry.js";
+import { sectionAt } from "../docx/sections.js";
 import { documentOf } from "./editorDocument.js";
 function documentFormatting(state) {
   return documentOf(state).formatting;
@@ -17,21 +18,25 @@ function documentParagraphStyles(state) {
 function documentGeometry(state) {
   return documentOf(state).geometry;
 }
+function sectionGeometryAt(state, pos) {
+  return sectionAt(state.doc, pos).props.geometry;
+}
 function documentDefaultTabStopPt(state) {
   return documentOf(state).defaultTabStopPt;
 }
 function documentBodyWidthPx(state) {
   return bodyWidth(documentGeometry(state)).px;
 }
-function documentBodyHeightPx(state) {
-  return twipsToPx(bodyHeightTwips(documentGeometry(state)));
+function sectionBodyHeightPx(state, pos) {
+  return twipsToPx(bodyHeightTwips(sectionGeometryAt(state, pos)));
 }
 export {
-  documentBodyHeightPx,
   documentBodyWidthPx,
   documentDefaultTabStopPt,
   documentDefaults,
   documentFormatting,
   documentGeometry,
-  documentParagraphStyles
+  documentParagraphStyles,
+  sectionBodyHeightPx,
+  sectionGeometryAt
 };

package/dist/editor/imageFiles.d.ts

@@ -65,8 +65,8 @@ export declare function insertImageFiles(view: EditorView, files: readonly File[
 /**
  * The plugin that takes image files pasted or dropped onto the paper.
  *
- * It has to sit ahead of the plain-text plugin, which answers for every paste and drop
- * whether or not it has anything to insert (see the plugin order in `createEditor.ts`).
+ * It runs before clipboard fallback and table insertion (see the order in `createEditor.ts`).
+ * A paste that chose plain text leaves any accompanying image file alone.
  * An event carrying no image file is passed on untouched, so text keeps coming in exactly
  * as it did.
  */