@portone/docx-editor 0.4.0 → 0.5.1

package/dist/editor/imageFiles.js

@@ -10,6 +10,7 @@ import {
   pxToEmu,
   toImageSrc
 } from "../ooxml/image.js";
+import { plainTextPaste } from "./clipboard/parser.js";
 import { documentBodyWidthPx } from "./documentStyles.js";
 import { insertImage } from "./insertImage.js";
 import { moveCaretToDrop } from "./plugins/dropCaret.js";
@@ -140,6 +141,7 @@ function imageFiles() {
   return new Plugin({
     props: {
       handlePaste(view, event) {
+        if (plainTextPaste(view, event)) return false;
         const files = imageFilesIn(event.clipboardData);
         if (files.length === 0) return false;
         void insertImageFiles(view, files);

package/dist/editor/insertTable.d.ts

@@ -13,6 +13,6 @@ export interface TableSize {
 }
 /**
  * Inserts a table of empty cells and moves the caret into the first cell.
- * The table is as wide as one line of body text on the paper the open document names
+ * The table is as wide as one line of body text on the paper of the section it goes into
  */
 export declare function insertTable({ rows, columns }: TableSize): Command;

package/dist/editor/insertTable.js

@@ -5,7 +5,7 @@ import {
 } from "prosemirror-state";
 import { createTableNode, isTableSide } from "../docx/tableTemplate.js";
 import { editShut } from "../schema/guards.js";
-import { documentGeometry } from "./documentStyles.js";
+import { sectionGeometryAt } from "./documentStyles.js";
 function isInTable($pos) {
   for (let depth = $pos.depth; depth > 0; depth -= 1) {
     if ($pos.node(depth).type.spec.tableRole === "table") return true;
@@ -30,7 +30,7 @@ function insertTable({ rows, columns }) {
       const tr = state.tr.insert(
         at,
         Fragment.fromArray([
-          createTableNode(rows, columns, documentGeometry(state)),
+          createTableNode(rows, columns, sectionGeometryAt(state, at)),
           state.schema.nodes.paragraph.create()
         ])
       );

package/dist/editor/plainText.d.ts

@@ -1,3 +1,15 @@
 import type { EditorView } from "prosemirror-view";
+/** A single character that becomes an element, or text that goes in as it is */
+export type Piece = {
+    text: string;
+} | {
+    node: "hardBreak" | "tab";
+};
+/**
+ * Splits the incoming text into the pieces to be put into the document.
+ * Control characters that carry meaning become elements, and the rest are stripped because they
+ * would make the file impossible to open.
+ */
+export declare function toPieces(source: string): Piece[];
 export declare function insertPlainText(view: EditorView, source: string): void;
 export declare function insertPlainTextAt(view: EditorView, source: string, from: number, to: number): void;

package/dist/editor/plainText.js

@@ -46,5 +46,6 @@ function insertPlainTextAt(view, source, from, to) {
 }
 export {
   insertPlainText,
-  insertPlainTextAt
+  insertPlainTextAt,
+  toPieces
 };

package/dist/editor/plugins/columnResize.js

@@ -14,7 +14,7 @@ import {
   shiftedTableWidth,
   tableGridCols
 } from "../../table/widths.js";
-import { documentGeometry } from "../documentStyles.js";
+import { sectionGeometryAt } from "../documentStyles.js";
 import { TableNodeView } from "../views/tableView.js";
 var EDGE_TOLERANCE_PX = 4;
 var FALLBACK_DXA_PER_PX = 15;
@@ -127,7 +127,7 @@ function columnResize() {
         col: current.target.col,
         width: current.width
       },
-      documentGeometry(current.view.state)
+      sectionGeometryAt(current.view.state, current.target.tablePos)
     );
     if (tr) current.view.dispatch(tr);
   }
@@ -144,7 +144,10 @@ function columnResize() {
     drag = {
       view,
       target,
-      maxTotal: maxGridTotal(target.table, documentGeometry(view.state)),
+      maxTotal: maxGridTotal(
+        target.table,
+        sectionGeometryAt(view.state, target.tablePos)
+      ),
       startX: event.clientX,
       dxaPerPx: dxaPerPx(target.gridCols, target.tableDom),
       cols,

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

@@ -0,0 +1,28 @@
+/**
+ * Where the built-in comment composer stands: the stretch of text it was opened over, or nothing
+ * when it is shut.
+ *
+ * The stretch is the point of holding it here rather than in the component that draws the form.
+ * A comment is written about text the reader picked out, and writing it takes as long as it takes:
+ * the caret moves on, the page is scrolled, a word elsewhere is fixed. The stretch is moved along
+ * by every edit that happens meanwhile, so the comment lands on the text it was written for, and
+ * the form goes away by itself once that text is gone or the document stops taking comments.
+ *
+ * The commands here are the editor's own. A consumer opening its own composer from its own toolbar
+ * is a public surface this package has not settled yet, so nothing below is exported from
+ * `./commands`.
+ */
+import type { Command, EditorState, Plugin } from "prosemirror-state";
+import type { CommentRange } from "../commands/comments/model";
+/**
+ * Opens the composer over the selected text. False where a comment could not go there anyway, so
+ * the menu entry that runs it is drawn dead rather than opening a form nothing would come of. It
+ * is the same question that entry is drawn from, asked of the same selection.
+ */
+export declare const openCommentComposer: Command;
+/** Closes it. Called on Cancel, on the comment being written, and on the panel being put away */
+export declare const closeCommentComposer: Command;
+export declare function isCommentComposerOpen(state: EditorState): boolean;
+/** The stretch the open composer is writing about. Null when no composer stands */
+export declare function commentComposerRange(state: EditorState): CommentRange | null;
+export declare function commentComposer(): Plugin<CommentRange | null>;

package/dist/editor/plugins/commentComposer.js

@@ -0,0 +1,46 @@
+// src/editor/plugins/commentComposer.ts
+import { canAddComment } from "../commands/comments/editing.js";
+import { panelPlugin } from "./panelState.js";
+function isCommentRange(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const { from, to } = value;
+  return typeof from === "number" && typeof to === "number";
+}
+var composer = panelPlugin({
+  name: "docxEditorCommentComposer",
+  isAnchor: isCommentRange,
+  // The stretch moves with the text around it. Its two ends are biased inwards, so text typed
+  // against either edge stays outside the comment and an edit that swallows the stretch leaves
+  // the two ends together, which is the form closing
+  onDocChange: (anchor, tr) => {
+    const from = tr.mapping.map(anchor.from, 1);
+    const to = tr.mapping.map(anchor.to, -1);
+    return to > from ? { from, to } : null;
+  },
+  // Asked after every transaction, which is what catches the mode being switched to read-only:
+  // that changes no text, so the mapping above never sees it. It is also what keeps the form from
+  // ever standing over a stretch that takes no comment, whoever opened it
+  closeWhen: (state, anchor) => !canAddComment(state, anchor)
+});
+var openCommentComposer = (state, dispatch) => {
+  if (!canAddComment(state)) return false;
+  const { from, to } = state.selection;
+  return composer.open({ from, to })(state, dispatch);
+};
+var closeCommentComposer = composer.close;
+function isCommentComposerOpen(state) {
+  return composer.anchor(state) !== null;
+}
+function commentComposerRange(state) {
+  return composer.anchor(state);
+}
+function commentComposer() {
+  return composer.plugin;
+}
+export {
+  closeCommentComposer,
+  commentComposer,
+  commentComposerRange,
+  isCommentComposerOpen,
+  openCommentComposer
+};

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

@@ -1,3 +1,30 @@
-/** Draws the text ranges identified by Word comment markers. */
-import { Plugin } from "prosemirror-state";
+/**
+ * What the comments in a document come to, worked out once per edit: the threads in document
+ * order, the lookup a command asking after one of them uses, and the ranges drawn over the text
+ * each was written for.
+ *
+ * All three are read off the same walk. Which comments a document holds is decided by the document
+ * and nothing else, so it is a projection (`./documentProjection`) rather than something worked
+ * out again for every command asked, every decoration drawn and every render of the list beside
+ * the page.
+ */
+import type { Plugin } from "prosemirror-state";
+import { DecorationSet } from "prosemirror-view";
+import { type DocumentComment } from "../commands/comments/model";
+export interface DocumentComments {
+    comments: readonly DocumentComment[];
+    /**
+     * The comments by id. A document can hold the same id twice - a reference copied and pasted
+     * carries the one it was written with - and the first of them wins, which is the one a search
+     * through the list in document order arrived at.
+     */
+    byId: ReadonlyMap<string, DocumentComment>;
+    /** The stretch each comment was written for, drawn as it stood when the edit landed */
+    decorations: DecorationSet;
+}
+export declare const commentProjection: import("./documentProjection").DocumentProjection<DocumentComments>;
+/**
+ * What a state built by `createEditor` registers: the comments it goes on to answer, and the
+ * ranges drawn over the text identified by the Word comment markers holding them.
+ */
 export declare function commentDecorations(): Plugin;

package/dist/editor/plugins/commentDecorations.js

@@ -1,23 +1,97 @@
 // src/editor/plugins/commentDecorations.ts
-import { Plugin } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
+import { storyKey, storyOf, storyText } from "../../docx/story.js";
 import { editorClassNames } from "../../styles/classNames.js";
-import { documentComments } from "../commands/commentCommands.js";
-function commentDecorations() {
-  return new Plugin({
-    props: {
-      decorations(state) {
-        const decorations = documentComments(state).filter((comment) => comment.from < comment.to).map(
-          (comment) => Decoration.inline(comment.from, comment.to, {
-            class: editorClassNames.commentRange,
-            "data-comment-id": comment.id
-          })
-        );
-        return DecorationSet.create(state.doc, decorations);
-      }
+import {
+  repliesAttr,
+  stringAttr
+} from "../commands/comments/model.js";
+import { documentProjection } from "./documentProjection.js";
+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 };
+}
+function bodyText(doc, id) {
+  return storyText(storyOf(doc, storyKey("comment", id)));
+}
+function commentsIn(doc) {
+  const markers = markerPositions(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: bodyText(doc, id),
+      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: bodyText(doc, reply.id)
+      }))
+    };
   });
 }
+function deriveComments(doc) {
+  const comments = commentsIn(doc);
+  const byId = /* @__PURE__ */ new Map();
+  for (const comment of comments) {
+    if (!byId.has(comment.id)) byId.set(comment.id, comment);
+  }
+  return {
+    comments,
+    byId,
+    decorations: DecorationSet.create(
+      doc,
+      comments.filter((comment) => comment.from < comment.to).map(
+        (comment) => Decoration.inline(comment.from, comment.to, {
+          class: editorClassNames.commentRange,
+          "data-comment-id": comment.id
+        })
+      )
+    )
+  };
+}
+var commentProjection = documentProjection(
+  "docxEditorComments",
+  deriveComments,
+  {
+    // The set the last edit derived. Written as a method so that `this` is the plugin holding it
+    decorations(state) {
+      return this.getState(state)?.decorations;
+    }
+  }
+);
+function commentDecorations() {
+  return commentProjection.plugin;
+}
 export {
-  commentDecorations
+  commentDecorations,
+  commentProjection
 };

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

@@ -0,0 +1,31 @@
+/**
+ * One convention for a value the whole document decides: the comments beside it, the notes under
+ * it, the list markers drawn over it.
+ *
+ * Such a value is worked out by walking the document, and what it is worked out from changes only
+ * when the document does. Held here, it is derived once per edit rather than once per read, and a
+ * caret moving, a menu opening or a component rendering again all read back the value the last
+ * edit left. What a caller writes is unchanged: `read` answers with a value either way.
+ *
+ * A projection derives from the document alone. Anything that also depends on the selection, the
+ * protection or another plugin belongs in that plugin, which is asked again after every
+ * transaction rather than after an edit alone.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type EditorState, Plugin, type PluginSpec } from "prosemirror-state";
+export interface DocumentProjection<T> {
+    plugin: Plugin<T>;
+    /**
+     * The derived value. A state built without the plugin - one a consumer assembled itself, or one
+     * a test made out of a bare document - is answered by deriving on the spot, so a public reader
+     * standing on a projection keeps answering whoever asks it.
+     */
+    read(state: EditorState): T;
+}
+export declare function documentProjection<T>(name: string, derive: (doc: PMNode) => T, 
+/**
+ * The view props drawn from the derived value, which is how a projection that paints what it
+ * derived - comment ranges over the text they were written for - stays one plugin. `this` in
+ * such a prop is the plugin, so it reads the value back with `this.getState(state)`.
+ */
+props?: PluginSpec<T>["props"]): DocumentProjection<T>;

package/dist/editor/plugins/documentProjection.js

@@ -0,0 +1,22 @@
+// src/editor/plugins/documentProjection.ts
+import {
+  Plugin,
+  PluginKey
+} from "prosemirror-state";
+function documentProjection(name, derive, props) {
+  const key = new PluginKey(name);
+  return {
+    plugin: new Plugin({
+      key,
+      state: {
+        init: (_config, state) => derive(state.doc),
+        apply: (tr, held) => tr.docChanged ? derive(tr.doc) : held
+      },
+      props
+    }),
+    read: (state) => key.getState(state) ?? derive(state.doc)
+  };
+}
+export {
+  documentProjection
+};

package/dist/editor/plugins/imagePaste.js

@@ -3,12 +3,14 @@ import { isHistoryTransaction } from "prosemirror-history";
 import { Plugin, PluginKey } from "prosemirror-state";
 import { Decoration, DecorationSet } from "prosemirror-view";
 import { editShut, selectionIntents } from "../../schema/guards.js";
+import { readHtmlSlice, withPastedContent } from "../clipboard/htmlReader.js";
 import {
   hasResolvableClipboardImages,
   resolveClipboardImages
 } from "../clipboard/images.js";
-import { documentBodyHeightPx, documentBodyWidthPx } from "../documentStyles.js";
-import { richHtmlSlice, withPastedContent } from "../externalClipboard.js";
+import { plainTextPaste } from "../clipboard/parser.js";
+import { readContextOf } from "../clipboard/readContext.js";
+import { documentBodyWidthPx, sectionBodyHeightPx } from "../documentStyles.js";
 import { insertPlainTextAt } from "../plainText.js";
 var LOAD_TIMEOUT_MS = 15e3;
 var imagePasteKey = new PluginKey("docxImagePaste");
@@ -87,11 +89,13 @@ function imagePaste() {
     if (!range) return;
     removeMarker(task);
     if (task.view.isDestroyed) return;
-    const content = resolved === null || resolved.images.size === 0 ? null : richHtmlSlice(
-      task.view.state,
-      task.view.dom.ownerDocument,
-      resolved.source,
-      resolved.images
+    const content = resolved === null || resolved.images.size === 0 ? null : readHtmlSlice(
+      readContextOf(
+        task.view.state,
+        task.view.dom.ownerDocument,
+        resolved.images
+      ),
+      resolved.source
     );
     if (content !== null) {
       task.view.dispatch(
@@ -225,6 +229,7 @@ function imagePaste() {
     props: {
       decorations: (state) => imagePasteKey.getState(state)?.decorations,
       handlePaste(view, event) {
+        if (plainTextPaste(view, event)) return false;
         if (selectionIntents(view.state.selection, "replace").some(
           (intent) => editShut(view.state, intent)
         )) {
@@ -256,8 +261,10 @@ function imagePaste() {
           view,
           html,
           text,
+          // One sheet is drawn at one width, the first section's, and a pasted image is fitted
+          // to it; how tall a page is, though, is the paper of the section it lands in
           maxWidthPx: documentBodyWidthPx(view.state),
-          maxHeightPx: documentBodyHeightPx(view.state),
+          maxHeightPx: sectionBodyHeightPx(view.state, from),
           canceled: false,
           controller: null
         });

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

@@ -9,15 +9,19 @@
  * It closes on the document changing, which is what applying a link or taking one off does: the
  * panel is about the selection it opened over, and after an edit that selection has been answered.
  */
-import { type Command, type EditorState, Plugin } from "prosemirror-state";
+import type { Command, EditorState, Plugin } from "prosemirror-state";
+/** The panel is about the selection it opened over, so standing open is all there is to hold */
+declare const OPEN = true;
 /** Whether the link panel is open */
 export declare function isLinkPanelOpen(state: EditorState): boolean;
 /**
  * Opens the panel. It reports false where a link could not go on anyway - a caret standing in no
  * link, a selection a lock leaves nothing of - so that Cmd+K there is a key this editor did not
- * take, and a control drawn from it is drawn dead.
+ * take, and a control drawn from it is drawn dead. A panel already open is one more such place:
+ * the button that opened it has nothing left to do while it stands.
  */
 export declare const openLinkPanel: Command;
 /** Closes it. Called on applying, on Escape, and on a click outside */
 export declare const closeLinkPanel: Command;
-export declare function linkPanel(): Plugin<boolean>;
+export declare function linkPanel(): Plugin<typeof OPEN | null>;
+export {};

package/dist/editor/plugins/linkPanel.js

@@ -1,35 +1,21 @@
 // src/editor/plugins/linkPanel.ts
-import {
-  Plugin,
-  PluginKey
-} from "prosemirror-state";
 import { canSetLink } from "../commands/linkCommands.js";
-var panelKey = new PluginKey("docxEditorLinkPanel");
+import { panelPlugin } from "./panelState.js";
+var OPEN = true;
+var panel = panelPlugin({
+  name: "docxEditorLinkPanel",
+  isAnchor: (value) => value === OPEN,
+  // An edit answers the panel: the link went on, came off, or the text it was about moved
+  onDocChange: "close",
+  canOpen: (state) => canSetLink(state)
+});
 function isLinkPanelOpen(state) {
-  return panelKey.getState(state) === true;
+  return panel.anchor(state) === OPEN;
 }
-var openLinkPanel = (state, dispatch) => {
-  if (isLinkPanelOpen(state) || !canSetLink(state)) return false;
-  if (dispatch) dispatch(state.tr.setMeta(panelKey, true));
-  return true;
-};
-var closeLinkPanel = (state, dispatch) => {
-  if (!isLinkPanelOpen(state)) return false;
-  if (dispatch) dispatch(state.tr.setMeta(panelKey, false));
-  return true;
-};
+var openLinkPanel = (state, dispatch) => !isLinkPanelOpen(state) && panel.open(OPEN)(state, dispatch);
+var closeLinkPanel = panel.close;
 function linkPanel() {
-  return new Plugin({
-    key: panelKey,
-    state: {
-      init: () => false,
-      apply: (tr, open) => {
-        const meta = tr.getMeta(panelKey);
-        if (typeof meta === "boolean") return meta;
-        return tr.docChanged ? false : open;
-      }
-    }
-  });
+  return panel.plugin;
 }
 export {
   closeLinkPanel,

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

@@ -0,0 +1,67 @@
+/**
+ * One convention for every panel the editor opens over a spot in the document: a link panel, a
+ * right click menu, the comment composer.
+ *
+ * Each of them holds the same thing - where it stands, or nothing when it is shut - and answers the
+ * same three questions: open it here, close it, where does it stand. What differs between them is
+ * what "here" is and what an edit or a change of protection does to a panel already open, and those
+ * are the options below rather than four copies of a plugin.
+ *
+ * The anchor is whatever the panel is about: a point on the screen for a menu, a stretch of the
+ * document for the composer. It is read back out of the state as it was put in, so a panel that
+ * needs nothing but "open" carries an anchor that says just that.
+ *
+ * A panel that reads other plugins in `canOpen` or `closeWhen` must be registered after them:
+ * the state a plugin is handed while the transaction is being applied holds the fields of the
+ * plugins ahead of it and nothing of the ones behind it.
+ */
+import { type Command, type EditorState, Plugin, type PluginSpec, type Transaction } from "prosemirror-state";
+/**
+ * What a document change does to an open panel: shut it, or move the anchor along with the change.
+ * Answering null from the mapping shuts it, which is what a stretch the edit swallowed comes to.
+ */
+export type PanelDocChange<Anchor> = "close" | ((anchor: Anchor, tr: Transaction, state: EditorState) => Anchor | null);
+export interface PanelOptions<Anchor> {
+    /** The plugin key's name, which is what a state debugger and a duplicate registration report */
+    name: string;
+    /**
+     * Whether this is an anchor of this panel's. The opening goes through the transaction metadata,
+     * which anything may write, so what is read back is judged rather than trusted
+     */
+    isAnchor(value: unknown): value is Anchor;
+    onDocChange: PanelDocChange<Anchor>;
+    /** Whether the panel may open here. `open` reports false where it says no */
+    canOpen?(state: EditorState, anchor: Anchor): boolean;
+    /**
+     * Whether the panel must shut where the state now stands, asked after every transaction rather
+     * than after an edit alone: a protection switch changes no text (`./documentProtection`), so
+     * `onDocChange` never sees it, and a panel that only a commenter is offered has to go with it.
+     */
+    closeWhen?(state: EditorState, anchor: Anchor): boolean;
+    /**
+     * The view props the panel needs of its own, which is how a panel opened by a DOM event - a
+     * right click - stays one plugin. What that handler does with the event is the panel's business;
+     * all this factory asks is that the opening go through `opening` so the state stays this one.
+     */
+    props?: PluginSpec<Anchor | null>["props"];
+}
+export interface PanelPlugin<Anchor> {
+    plugin: Plugin<Anchor | null>;
+    /**
+     * Opens the panel over this anchor, or moves an open one there. False where `canOpen` says the
+     * panel has nothing to do here, so that a control drawn from it is drawn dead and a key bound to
+     * it is a key this editor did not take.
+     */
+    open(anchor: Anchor): Command;
+    /**
+     * The same opening recorded on a transaction already being built, for an opener that moves the
+     * selection in the same step. `canOpen` is not asked here: an opener holding the event that
+     * asked - a right click landing where the menu belongs - has decided that already.
+     */
+    opening(tr: Transaction, anchor: Anchor): Transaction;
+    /** Closes it. False where it stands closed already, so a key press falls through to what is behind it */
+    close: Command;
+    /** Where the panel stands. Null when it is shut, and for a state built without the plugin */
+    anchor(state: EditorState): Anchor | null;
+}
+export declare function panelPlugin<Anchor>({ name, isAnchor, onDocChange, canOpen, closeWhen, props, }: PanelOptions<Anchor>): PanelPlugin<Anchor>;

package/dist/editor/plugins/panelState.js

@@ -0,0 +1,54 @@
+// src/editor/plugins/panelState.ts
+import {
+  Plugin,
+  PluginKey
+} from "prosemirror-state";
+var CLOSE = /* @__PURE__ */ Symbol("panelClose");
+function panelPlugin({
+  name,
+  isAnchor,
+  onDocChange,
+  canOpen,
+  closeWhen,
+  props
+}) {
+  const key = new PluginKey(name);
+  const anchor = (state) => key.getState(state) ?? null;
+  const moved = (tr, held, next) => {
+    const meta = tr.getMeta(key);
+    if (meta === CLOSE) return null;
+    if (isAnchor(meta)) return meta;
+    if (held === null || !tr.docChanged) return held;
+    return onDocChange === "close" ? null : onDocChange(held, tr, next);
+  };
+  const opening = (tr, over) => tr.setMeta(key, over);
+  return {
+    plugin: new Plugin({
+      key,
+      state: {
+        init: () => null,
+        apply: (tr, held, _before, next) => {
+          const standing = moved(tr, held, next);
+          if (standing === null) return null;
+          return closeWhen?.(next, standing) ? null : standing;
+        }
+      },
+      props
+    }),
+    open: (over) => (state, dispatch) => {
+      if (canOpen && !canOpen(state, over)) return false;
+      dispatch?.(opening(state.tr, over));
+      return true;
+    },
+    opening,
+    close: (state, dispatch) => {
+      if (anchor(state) === null) return false;
+      dispatch?.(state.tr.setMeta(key, CLOSE));
+      return true;
+    },
+    anchor
+  };
+}
+export {
+  panelPlugin
+};

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

@@ -8,7 +8,7 @@
  * selected text is taken first by the text menu (`editor/textContextMenu`), which stands ahead
  * of this one and hands back a click with nothing selected inside a cell.
  */
-import { type Command, type EditorState, Plugin } from "prosemirror-state";
+import { type Command, type EditorState, type Plugin } from "prosemirror-state";
 /** Where the menu should stand (viewport coordinates) */
 export interface TableMenuAnchor {
     clientX: number;