@portone/docx-editor 0.6.0 → 0.6.2

package/dist/editor/clipboard/htmlReader.js

@@ -7,6 +7,7 @@ import {
   withListNumbering,
   withParagraphStyle
 } from "../../docx/paraProps.js";
+import { setStory } from "../../docx/story.js";
 import {
   listsWorn,
   NEW_LISTS_ATTR,
@@ -20,6 +21,10 @@ import {
 import { styleIdOf } from "../../ooxml/props.js";
 import { docxSchema } from "../../schema/index.js";
 import { COPIED_STYLE_ATTRIBUTE } from "../../schema/clipboard.js";
+import {
+  EDITABLE_NOTE_KINDS,
+  storyKey
+} from "../../schema/stories.js";
 import { editorClassNames } from "../../styles/classNames.js";
 import { numIdsIn } from "../commands/listCommands.js";
 import {
@@ -32,6 +37,9 @@ import {
   marksFor,
   withInlineStyle
 } from "./inlineFormatting.js";
+import {
+  NO_NOTE_STORIES
+} from "./internalChannel.js";
 import { detectHtmlSource } from "./source.js";
 var BLOCK_TAGS = /* @__PURE__ */ new Set([
   "ADDRESS",
@@ -363,14 +371,41 @@ function readHtmlSlice(context, source) {
   template.innerHTML = source;
   return readHtml(template.content, context);
 }
+function notesCalledIn(doc) {
+  const keys = /* @__PURE__ */ new Set();
+  doc.descendants((node) => {
+    if (node.type !== docxSchema.nodes.noteReference) return true;
+    const kind = EDITABLE_NOTE_KINDS.find(
+      (candidate) => candidate === node.attrs.kind
+    );
+    const id = node.attrs.id;
+    if (kind !== void 0 && typeof id === "string") {
+      keys.add(storyKey(kind, id));
+    }
+    return true;
+  });
+  return keys;
+}
+function withPastedStories(tr, stories) {
+  if (stories.size === 0) return tr;
+  const called = notesCalledIn(tr.doc);
+  for (const [key, story] of stories) {
+    if (called.has(key)) setStory(tr, key, story);
+  }
+  return tr;
+}
 function withPastedContent(tr, content) {
-  return tr.setDocAttribute(
-    NEW_LISTS_ATTR,
-    newListsValue(listsWorn(content.newLists, numIdsIn(tr.doc)))
+  return withPastedStories(
+    tr.setDocAttribute(
+      NEW_LISTS_ATTR,
+      newListsValue(listsWorn(content.newLists, numIdsIn(tr.doc)))
+    ),
+    content.newStories ?? NO_NOTE_STORIES
   );
 }
 export {
   readHtml,
   readHtmlSlice,
-  withPastedContent
+  withPastedContent,
+  withPastedStories
 };

package/dist/editor/clipboard/internalChannel.d.ts

@@ -16,15 +16,23 @@
  * about the copy that only the editor it was copied from can answer: a number says nothing about
  * whether it counted or bulleted, and the definition that said so is the source document's. It is
  * read here because this is where both ends are the same session.
+ *
+ * The note each reference in it calls is kept the same way, and for a stronger reason: a cut takes
+ * a footnote away together with its last reference (`editor/plugins/noteLifecycle`), so by the time
+ * the paste happens the document no longer holds what the copy was pointing at.
  */
-import type { Slice } from "prosemirror-model";
+import type { Node as PMNode, Slice } from "prosemirror-model";
 import type { ListKind } from "../../numbering/listTemplate";
 import type { Numbering } from "../../numbering/parseNumbering";
+import { type NoteKey, type StoryKey } from "../../schema/stories";
 /** Where the copied HTML carries the name of the slice this editor kept */
 export declare const INTERNAL_TOKEN_ATTRIBUTE = "data-docx-clip";
 /** The kind of list each numbering id of a slice stood for where the slice was copied */
 export type ListKinds = ReadonlyMap<number, ListKind>;
 export declare const NO_LIST_KINDS: ListKinds;
+/** The story of each note the slice refers to, as the document copied from held it */
+export type NoteStories = ReadonlyMap<NoteKey, PMNode>;
+export declare const NO_NOTE_STORIES: NoteStories;
 /**
  * The two ways a copy leaves the editor.
  *
@@ -34,19 +42,38 @@ export declare const NO_LIST_KINDS: ListKinds;
  * replaced only by the next copy made the same way.
  */
 export type CopyRoute = "clipboard" | "drag";
-/** What one name stands for: the slice that was copied, and what its list numbers meant there */
+/** What one name stands for: the slice that was copied, and what it named where it was copied */
 export interface RecalledCopy {
     readonly slice: Slice;
     readonly listKinds: ListKinds;
+    readonly noteStories: NoteStories;
+}
+/** The document a copy is made from, which is the only one that can answer what it carries */
+export interface CopySource {
+    /** Null for a state built without a document, which has no session to bind a name to */
+    readonly sessionId: string | null;
+    readonly doc: PMNode;
+    readonly numbering: Numbering;
+    /** The notes laying a part out rather than saying something, which are never copied */
+    readonly specialNotes: ReadonlySet<StoryKey>;
 }
 /**
  * Keeps the copied slice under a fresh name, and answers with the name to write into the markup.
  * Null for a state built without a document: with no session to bind the name to there is nothing
  * to tell this editor's copy from another's, and the copy travels as markup alone.
  */
-export declare function rememberCopied(route: CopyRoute, slice: Slice, sessionId: string | null, numbering: Numbering): string | null;
+export declare function rememberCopied(route: CopyRoute, slice: Slice, source: CopySource): string | null;
 /** The copy that name stands for, and only when the session asking is the one that copied it */
 export declare function recallCopied(token: string | null, sessionId: string | null): RecalledCopy | null;
+/**
+ * The notes the last drag out of this editor carried.
+ *
+ * A drop is handed the slice itself rather than markup (`prosemirror-view`), so it carries no name
+ * to look a copy up by; the drag is the one route whose last copy is the copy being dropped. The
+ * session must still be the one that dragged, since a drop from another editor arrives as the
+ * markup its own reader answers for.
+ */
+export declare function draggedNotes(sessionId: string | null): NoteStories;
 /**
  * The name the pasted markup carries, if it carries one.
  *

package/dist/editor/clipboard/internalChannel.js

@@ -1,31 +1,50 @@
 // src/editor/clipboard/internalChannel.ts
 import { docxSchema } from "../../schema/index.js";
+import {
+  EDITABLE_NOTE_KINDS,
+  storyKey,
+  storyNodeOf
+} from "../../schema/stories.js";
 import { listKindOf, listRefOf } from "../commands/listCommands.js";
 var INTERNAL_TOKEN_ATTRIBUTE = "data-docx-clip";
 var NO_LIST_KINDS = /* @__PURE__ */ new Map();
+var NO_NOTE_STORIES = /* @__PURE__ */ new Map();
 var copied = /* @__PURE__ */ new Map();
 var copies = 0;
 function nextToken() {
   copies += 1;
   return `c${copies}-${Math.random().toString(36).slice(2, 10)}`;
 }
-function rememberCopied(route, slice, sessionId, numbering) {
+function rememberCopied(route, slice, source) {
+  const { sessionId } = source;
   if (sessionId === null) return null;
   const token = nextToken();
   copied.set(route, {
     token,
     sessionId,
     slice,
-    listKinds: listKindsIn(slice, numbering)
+    listKinds: listKindsIn(slice, source.numbering),
+    noteStories: noteStoriesIn(slice, source)
   });
   return token;
 }
+function recalled(copy) {
+  return {
+    slice: copy.slice,
+    listKinds: copy.listKinds,
+    noteStories: copy.noteStories
+  };
+}
 function recallCopied(token, sessionId) {
   if (token === null || sessionId === null) return null;
   const found = [...copied.values()].find(
     (copy) => copy.token === token && copy.sessionId === sessionId
   );
-  return found === void 0 ? null : { slice: found.slice, listKinds: found.listKinds };
+  return found === void 0 ? null : recalled(found);
+}
+function draggedNotes(sessionId) {
+  const found = copied.get("drag");
+  return found === void 0 || sessionId === null || found.sessionId !== sessionId ? NO_NOTE_STORIES : found.noteStories;
 }
 function listKindsIn(slice, numbering) {
   const kinds = /* @__PURE__ */ new Map();
@@ -41,6 +60,25 @@ function listKindsIn(slice, numbering) {
   slice.content.forEach(read);
   return kinds.size === 0 ? NO_LIST_KINDS : kinds;
 }
+function noteStoriesIn(slice, source) {
+  const stories = /* @__PURE__ */ new Map();
+  const read = (node) => {
+    if (node.type === docxSchema.nodes.noteReference) {
+      const kind = EDITABLE_NOTE_KINDS.find(
+        (candidate) => candidate === node.attrs.kind
+      );
+      const id = node.attrs.id;
+      if (kind === void 0 || typeof id !== "string") return;
+      const key = storyKey(kind, id);
+      const story = source.specialNotes.has(key) ? null : storyNodeOf(source.doc, key);
+      if (story !== null) stories.set(key, story);
+      return;
+    }
+    node.forEach(read);
+  };
+  slice.content.forEach(read);
+  return stories.size === 0 ? NO_NOTE_STORIES : stories;
+}
 function internalTokenOf(dom) {
   if (dom instanceof Element) {
     const own = dom.getAttribute(INTERNAL_TOKEN_ATTRIBUTE);
@@ -52,6 +90,8 @@ function internalTokenOf(dom) {
 export {
   INTERNAL_TOKEN_ATTRIBUTE,
   NO_LIST_KINDS,
+  NO_NOTE_STORIES,
+  draggedNotes,
   internalTokenOf,
   recallCopied,
   rememberCopied

package/dist/editor/clipboard/normalizers.d.ts

@@ -16,8 +16,9 @@
 import { type Node as PMNode, Slice } from "prosemirror-model";
 import type { EditorState } from "prosemirror-state";
 import { type ListKind } from "../../numbering/listTemplate";
+import { type NoteKind } from "../../schema/stories";
 import type { PastedContent } from "./htmlReader";
-import { type ListKinds } from "./internalChannel";
+import { type ListKinds, type NoteStories } from "./internalChannel";
 /** What one normalizer answers about the document the slice is going into */
 export interface NormalizeContext {
     readonly state: EditorState;
@@ -40,6 +41,17 @@ export interface NormalizeContext {
      * the list button starts one. Null in a document with nowhere to write a definition.
      */
     startList(kind: ListKind): number | null;
+    /**
+     * What the notes the slice's references call said where it was copied
+     * (`./internalChannel`). Empty for a slice that arrived any other way, whose references name
+     * notes of a document this one knows nothing about.
+     */
+    readonly noteStories: NoteStories;
+    /**
+     * A note this paste puts in, under an id no note of this document answers to, registered in
+     * `PastedContent.newStories`. It answers with the id the reference is pasted under.
+     */
+    startNote(kind: NoteKind, story: PMNode): string;
 }
 export type SliceNormalizer = (slice: Slice, context: NormalizeContext) => Slice;
 /** The slice with every node rewritten depth first, and the ones mapped to null taken out */
@@ -71,17 +83,31 @@ export declare const rekeyNumbering: SliceNormalizer;
 /**
  * Takes the anchors off what is pasted.
  *
- * A comment marker, a bookmark and a note reference all point at something written elsewhere in
- * the package: the comment, the bookmark's other end, the note's body. A copy of the marker alone
- * points at the same thing a second time, which is a duplicate identifier the file may not hold
- * and a range the reader cannot close. Nothing here duplicates what they point at, so the anchor
- * goes and the text it stood in stays, which is what Word does with a note it has no body for.
+ * A comment marker and a bookmark both point at something written elsewhere in the package: the
+ * comment, the bookmark's other end. A copy of the marker alone points at the same thing a second
+ * time, which is a duplicate identifier the file may not hold and a range the reader cannot close.
+ * Nothing here duplicates what they point at, so the anchor goes and the text it stood in stays,
+ * which is what Word does with a note it has no body for.
  *
  * A move drop duplicates nothing: the source goes as the drop lands, so the one anchor there was
  * travels with the text it opened. Taking it off would delete a marker the document has no way to
  * write back, which is a change the preserved guard refuses whole, and the drag would do nothing.
  */
 export declare const detachAnchors: SliceNormalizer;
+/**
+ * Gives a pasted note reference a note of its own.
+ *
+ * A note is written once and called from the text by its id, so a second reference naming that id
+ * is one note drawn with one number where the reader made two. The note each reference called was
+ * remembered as the slice was copied (`./internalChannel`) - a cut deletes a footnote together
+ * with its last reference, so the document no longer holds it by the time the paste lands - and
+ * each reference is pasted under a fresh id with a copy of that note beside it.
+ *
+ * A reference no remembered note answers for points at nothing here: a copy from another editor or
+ * another document numbers its notes against its own file, and markup naming one says nothing
+ * about what it said. It goes the way the other anchors do.
+ */
+export declare const duplicateNotes: SliceNormalizer;
 /**
  * Works out again what the pasted paragraphs are drawn with.
  *
@@ -93,7 +119,8 @@ export declare const detachAnchors: SliceNormalizer;
 export declare const rederiveDisplay: SliceNormalizer;
 export declare const DEFAULT_NORMALIZERS: readonly SliceNormalizer[];
 /**
- * The pasted content as this document may hold it, and the definitions of the lists the paste
- * starts - the ones a reading started, and the ones a reissued number was taken for.
+ * The pasted content as this document may hold it, the definitions of the lists the paste starts -
+ * the ones a reading started, and the ones a reissued number was taken for - and the notes it puts
+ * in beside the references calling them.
  */
 export declare function normalizePasted(content: PastedContent, state: EditorState, move: boolean, normalizers?: readonly SliceNormalizer[]): PastedContent;

package/dist/editor/clipboard/normalizers.js

@@ -9,6 +9,11 @@ import {
   resolveParagraph,
   resolveRun
 } from "../../docx/formatting.js";
+import {
+  copiedNoteStory,
+  nextNoteId,
+  takenNoteIds
+} from "../../docx/notes/newNote.js";
 import { withListNumbering } from "../../docx/paraProps.js";
 import {
   allocateList,
@@ -20,13 +25,21 @@ import {
   RANGE_MARKERS
 } from "../../ooxml/rangeMarkers.js";
 import { docxSchema } from "../../schema/index.js";
+import {
+  EDITABLE_NOTE_KINDS,
+  storyKey
+} from "../../schema/stories.js";
 import { listRefOf, numIdsIn } from "../commands/listCommands.js";
 import { documentFormatting } from "../documentStyles.js";
+import { documentOf } from "../editorDocument.js";
 import {
   canStartNewList,
   documentNumbering
 } from "../plugins/numberingDecorations.js";
-import { NO_LIST_KINDS } from "./internalChannel.js";
+import {
+  NO_LIST_KINDS,
+  NO_NOTE_STORIES
+} from "./internalChannel.js";
 function xmlAttr(value) {
   return typeof value === "string" ? value : null;
 }
@@ -90,22 +103,25 @@ var rekeyNumbering = (slice, context) => {
     return props === null ? node : withAttrs(node, { ...node.attrs, pPr: props.pPr });
   });
 };
-var ANCHOR_NODES = /* @__PURE__ */ new Set([
-  "commentStart",
-  "commentEnd",
-  "commentReference",
-  "noteReference"
-]);
+var ANCHORS = {
+  commentStart: () => true,
+  commentEnd: () => true,
+  commentReference: () => true
+};
 var REFERENCE_ELEMENTS = [
   "commentReference",
   "footnoteReference",
-  "endnoteReference"
+  "endnoteReference",
+  "footnoteRef",
+  "endnoteRef"
 ];
+var NOTE_OWN_MARKS = ["footnoteRef", "endnoteRef"];
 var ANCHOR_ELEMENTS = /* @__PURE__ */ new Set([
   ...RANGE_MARKERS,
   ...PERMISSION_MARKERS,
   ...COMMENT_RANGE_MARKERS,
-  ...REFERENCE_ELEMENTS
+  ...REFERENCE_ELEMENTS,
+  ...NOTE_OWN_MARKS
 ]);
 var PRESERVED_INLINE = /* @__PURE__ */ new Set([
   "rawInline",
@@ -119,11 +135,26 @@ function preservedName(node) {
   return typeof element === "string" ? element : null;
 }
 var detachAnchors = (slice, { move }) => move ? slice : mapSliceNodes(slice, (node) => {
-  if (ANCHOR_NODES.has(node.type.name)) return null;
+  if (ANCHORS[node.type.name]?.(node) === true) return null;
   if (!PRESERVED_INLINE.has(node.type.name)) return node;
   const name = preservedName(node);
   return name !== null && ANCHOR_ELEMENTS.has(name) ? null : node;
 });
+var duplicateNotes = (slice, { move, noteStories, startNote }) => move ? slice : mapSliceNodes(slice, (node) => {
+  if (node.type !== docxSchema.nodes.noteReference) return node;
+  const kind = EDITABLE_NOTE_KINDS.find(
+    (candidate) => candidate === node.attrs.kind
+  );
+  const id = node.attrs.id;
+  if (kind === void 0 || typeof id !== "string") return null;
+  const story = noteStories.get(storyKey(kind, id));
+  if (story === void 0) return null;
+  return withAttrs(node, {
+    ...node.attrs,
+    id: startNote(kind, story),
+    referenceXml: null
+  });
+});
 var rederiveDisplay = (slice, { state }) => {
   const formatting = documentFormatting(state);
   return mapSliceNodes(slice, (node) => {
@@ -152,6 +183,7 @@ var rederiveDisplay = (slice, { state }) => {
 var DEFAULT_NORMALIZERS = [
   dropSourceIdentity,
   detachAnchors,
+  duplicateNotes,
   rekeyNumbering,
   rederiveDisplay
 ];
@@ -164,11 +196,26 @@ function normalizePasted(content, state, move, normalizers = DEFAULT_NORMALIZERS
     ...content.newLists.keys()
   ]);
   const started = /* @__PURE__ */ new Map();
+  const document = documentOf(state);
+  const takenNotes = /* @__PURE__ */ new Map();
+  const startedNotes = /* @__PURE__ */ new Map();
   const context = {
     state,
     move,
     knownLists: known,
     listKinds: content.listKinds ?? NO_LIST_KINDS,
+    noteStories: content.noteStories ?? NO_NOTE_STORIES,
+    startNote(kind, story) {
+      const ids = takenNotes.get(kind) ?? takenNoteIds(state.doc, kind, document.reservedNoteKeys);
+      takenNotes.set(kind, ids);
+      const id = nextNoteId(ids);
+      ids.add(id);
+      startedNotes.set(
+        storyKey(kind, id),
+        copiedNoteStory(story, document.session)
+      );
+      return id;
+    },
     startList(kind) {
       if (!canStartNewList(state)) return null;
       const list = templateList(kind);
@@ -185,13 +232,15 @@ function normalizePasted(content, state, move, normalizers = DEFAULT_NORMALIZERS
   );
   return {
     slice,
-    newLists: started.size === 0 ? content.newLists : new Map([...content.newLists, ...started])
+    newLists: started.size === 0 ? content.newLists : new Map([...content.newLists, ...started]),
+    newStories: startedNotes.size === 0 ? content.newStories : startedNotes
   };
 }
 export {
   DEFAULT_NORMALIZERS,
   detachAnchors,
   dropSourceIdentity,
+  duplicateNotes,
   mapSliceNodes,
   normalizePasted,
   rederiveDisplay,

package/dist/editor/clipboard/plugin.js

@@ -13,7 +13,9 @@ import { documentOf } from "../editorDocument.js";
 import { insertPlainText } from "../plainText.js";
 import { moveCaretToDrop } from "../plugins/dropCaret.js";
 import { documentNumbering } from "../plugins/numberingDecorations.js";
+import { withPastedStories } from "./htmlReader.js";
 import {
+  draggedNotes,
   INTERNAL_TOKEN_ATTRIBUTE,
   internalTokenOf,
   rememberCopied
@@ -78,6 +80,7 @@ function docxClipboard(options = {}) {
     }
   );
   let started = null;
+  let startedStories = null;
   let dropMove = false;
   let draggingOut = false;
   return new Plugin({
@@ -90,26 +93,33 @@ function docxClipboard(options = {}) {
       };
     },
     /**
-     * The definitions of the lists a paste began, registered on the document once the paste is
-     * in. A list the pasted markup started is numbered as it is read, and only the edit that
-     * lands says whether that number is worn in the end.
+     * What a paste brought beside its text, registered on the document once the paste is in: the
+     * definitions of the lists it began and the notes its references call. A list the pasted
+     * markup started is numbered as it is read, and only the edit that lands says whether that
+     * number is worn in the end.
      */
     appendTransaction(transactions, _before, after) {
       const lists = started;
+      const stories = startedStories;
       started = null;
-      if (lists === null || lists.size === 0 || !transactions.some((tr) => tr.docChanged)) {
-        return null;
+      startedStories = null;
+      if (!transactions.some((tr2) => tr2.docChanged)) return null;
+      const tr = after.tr;
+      if (lists !== null && lists.size > 0) {
+        const worn = numIdsIn(after.doc);
+        const registered = newListsOf(after.doc.attrs[NEW_LISTS_ATTR]);
+        const missing = [...lists].filter(
+          ([numId]) => worn.has(numId) && !registered.has(numId)
+        );
+        if (missing.length > 0) {
+          tr.setDocAttribute(
+            NEW_LISTS_ATTR,
+            newListsValue(new Map([...registered, ...missing]))
+          );
+        }
       }
-      const worn = numIdsIn(after.doc);
-      const registered = newListsOf(after.doc.attrs[NEW_LISTS_ATTR]);
-      const missing = [...lists].filter(
-        ([numId]) => worn.has(numId) && !registered.has(numId)
-      );
-      if (missing.length === 0) return null;
-      return after.tr.setDocAttribute(
-        NEW_LISTS_ATTR,
-        newListsValue(new Map([...registered, ...missing]))
-      );
+      if (stories !== null) withPastedStories(tr, stories);
+      return tr.steps.length === 0 ? null : tr;
     },
     props: {
       handleDOMEvents: {
@@ -145,24 +155,34 @@ function docxClipboard(options = {}) {
       clipboardTextSerializer: clipboardText,
       transformCopied(slice, view) {
         const route = draggingOut ? "drag" : "clipboard";
-        copyToken = rememberCopied(
-          route,
-          slice,
-          documentOf(view.state).session?.sessionId ?? null,
-          documentNumbering(view.state)
-        );
+        const document = documentOf(view.state);
+        copyToken = rememberCopied(route, slice, {
+          sessionId: document.session?.sessionId ?? null,
+          doc: view.state.doc,
+          numbering: documentNumbering(view.state),
+          specialNotes: document.specialNotes
+        });
         return copiedSlice(slice);
       },
       transformPasted(slice, view, plain) {
         if (!plain) parser.setPlainText(false);
         const read = parser.takeRead();
         const content = normalizePasted(
-          read ?? { slice, newLists: NO_NEW_LISTS },
+          // A drop is handed the dragged slice itself rather than markup, so what that slice
+          // carried is looked up by the route it left on rather than by a name written into markup
+          read ?? {
+            slice,
+            newLists: NO_NEW_LISTS,
+            noteStories: draggedNotes(
+              documentOf(view.state).session?.sessionId ?? null
+            )
+          },
           view.state,
           dropMove,
           normalizers
         );
         started = content.newLists;
+        startedStories = content.newStories ?? null;
         return content.slice;
       },
       handlePaste(view, event, slice) {

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

@@ -1,11 +1,12 @@
 /** Document-level readers for whether the document as it stands can be written back. */
 import type { EditorState } from "prosemirror-state";
 import { type ExportProblem } from "../../docx/invariants";
-export type { ExportProblem } from "../../docx/invariants";
+export type { ExportPartName, ExportProblem, ExportProblemReason, ExportProblemStory, ExportStoryKind, } from "../../docx/invariants";
 /**
  * Every reason writing the document back would be refused, in the order `exportDocx` would raise
- * them, each with the code and message the refusal would carry and the position in the document
- * where there is one. Empty when the file would be written.
+ * them, each with the code and message the refusal would carry, the `reason` naming what it is
+ * about, and the position in the document where there is one. Empty when the file would be
+ * written.
  *
  * A state built without an opened document has no file to write back into, so nothing about it
  * can be refused and it reports no problem.

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

@@ -63,7 +63,7 @@ export { addComment, addCommentReply, canAddComment, canEditComment, documentCom
  * with the code `exportDocx` would throw it under. `canExport` is what an export control is
  * drawn from, and `downloadDocx` answers `blocked` with the same list.
  */
-export type { ExportProblem } from "./exportQueries";
+export type { ExportPartName, ExportProblem, ExportProblemReason, ExportProblemStory, ExportStoryKind, } from "./exportQueries";
 export { canExport, documentExportProblems } from "./exportQueries";
 export type { FidelityCode, FidelityNote, FidelitySeverity, } from "./fidelityQueries";
 export { documentFidelity } from "./fidelityQueries";
@@ -90,6 +90,7 @@ export { activeLink, activeLinkSpan, canSetLink, removeLink, setLink, } from "./
 export { activeListKind, decreaseListLevel, increaseListLevel, isInList, toggleBulletList, toggleNumberedList, } from "./listCommands";
 export type { SelectionLock } from "./lockCommands";
 export { documentHasLocked, lockSelection, selectionLock, selectionTouchesLocked, unlockSelection, } from "./lockCommands";
+export { canInsertEndnote, canInsertFootnote, insertEndnote, insertFootnote, openEndnote, openFootnote, setEndnoteBody, setFootnoteBody, } from "./noteCommands";
 export type { DocumentNote } from "./noteQueries";
 export { documentNotes } from "./noteQueries";
 export type { ActiveParagraphAlign, ActiveParagraphStyle, } from "./paragraphCommands";

package/dist/editor/commands/index.js

@@ -81,6 +81,16 @@ import {
   selectionTouchesLocked,
   unlockSelection
 } from "./lockCommands.js";
+import {
+  canInsertEndnote,
+  canInsertFootnote,
+  insertEndnote,
+  insertFootnote,
+  openEndnote,
+  openFootnote,
+  setEndnoteBody,
+  setFootnoteBody
+} from "./noteCommands.js";
 import { documentNotes } from "./noteQueries.js";
 import {
   activeParagraphAlign,
@@ -117,6 +127,8 @@ export {
   canExport,
   canFormatText,
   canIncreaseIndent,
+  canInsertEndnote,
+  canInsertFootnote,
   canInsertImage,
   canInsertTable,
   canRunCommand,
@@ -139,6 +151,8 @@ export {
   imageFilesIn,
   increaseIndent,
   increaseListLevel,
+  insertEndnote,
+  insertFootnote,
   insertImage,
   insertImageFiles,
   insertLineBreak,
@@ -151,6 +165,8 @@ export {
   isStrikeActive,
   isUnderlineActive,
   lockSelection,
+  openEndnote,
+  openFootnote,
   readImageFile,
   redo,
   removeComment,
@@ -161,8 +177,10 @@ export {
   selectionTouchesLocked,
   setCommentBody,
   setCommentResolved,
+  setEndnoteBody,
   setFontFamily,
   setFontSize,
+  setFootnoteBody,
   setLineSpacing,
   setLink,
   setParagraphAlign,