@portone/docx-editor 0.6.1 → 0.6.2

package/dist/docx/notes/writing.js

@@ -2,7 +2,9 @@
 import { elementXml } from "../../ooxml/element.js";
 import { wName } from "../../ooxml/names.js";
 import { R_NS } from "../../ooxml/xml.js";
+import { noteKeyOf } from "../../schema/stories.js";
 import { storyEntriesPlanner } from "../storyParts.js";
+import { eachNoteReference } from "./references.js";
 var NOTE_CONTENT_TYPES = {
   footnote: "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml",
   endnote: "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml"
@@ -60,12 +62,9 @@ function frozenNotes(session, kind) {
 }
 function referenceIds(doc, kind) {
   const ids = /* @__PURE__ */ new Set();
-  doc.descendants((node) => {
-    const id = node.attrs.id;
-    if (node.type.name === "noteReference" && node.attrs.kind === kind && typeof id === "string") {
-      ids.add(id);
-    }
-    return true;
+  eachNoteReference(doc, ({ key }) => {
+    const note = key === null ? null : noteKeyOf(key);
+    if (note?.kind === kind) ids.add(note.id);
   });
   return ids;
 }

package/dist/docx/serializePreserved.d.ts

@@ -7,8 +7,12 @@
  * the same way, from here.
  */
 import type { Node as PMNode } from "prosemirror-model";
+import { type ExportProblemReason, type ExportProblemStory } from "../ooxml/errors";
 import type { ExportRefs } from "./exportRefs";
 import { type SessionStore } from "./session";
 /** Why there is no original to write, which a block that came in from another document answers differently */
-export declare function lostOriginal(node: PMNode, session: SessionStore | null): string;
+export declare function lostOriginal(node: PMNode, session: SessionStore | null, story: ExportProblemStory | null): {
+    readonly message: string;
+    readonly reason: ExportProblemReason;
+};
 export declare function serializePreservedBlock(node: PMNode, refs: ExportRefs): string;

package/dist/docx/serializePreserved.js

@@ -1,20 +1,37 @@
 // src/docx/serializePreserved.ts
-import { DocxExportError } from "../ooxml/errors.js";
+import {
+  DocxExportError
+} from "../ooxml/errors.js";
 import { originalBlock, splitBlockKey } from "./session.js";
-function lostOriginal(node, session) {
+function lostOriginal(node, session, story) {
   const srcId = node.attrs.srcId;
   const key = typeof srcId === "string" ? splitBlockKey(srcId) : null;
-  return key === null || key.sessionId === session?.sessionId ? "a preserved block has lost its original XML" : `a preserved block comes from another document (${key.sessionId})`;
+  const name = node.type.name;
+  if (key === null || key.sessionId === session?.sessionId) {
+    return {
+      message: "a preserved block has lost its original XML",
+      reason: { kind: "lost-preserved-xml", node: name, story }
+    };
+  }
+  return {
+    message: `a preserved block comes from another document (${key.sessionId})`,
+    reason: {
+      kind: "preserved-from-another-document",
+      node: name,
+      sessionId: key.sessionId,
+      story
+    }
+  };
 }
 function serializePreservedBlock(node, refs) {
   const xml = node.attrs.xml;
   if (typeof xml === "string") return xml;
   const imported = refs.session ? originalBlock(node, refs.session) : void 0;
   if (!imported) {
-    throw new DocxExportError(
-      "lost-original",
-      lostOriginal(node, refs.session)
-    );
+    const { message, reason } = lostOriginal(node, refs.session, null);
+    throw new DocxExportError("lost-original", message, {
+      problem: { code: "lost-original", message, reason }
+    });
   }
   return imported.xml;
 }

package/dist/docx/storyParts.d.ts

@@ -6,7 +6,7 @@
  * and the export invariants would have a third answer of their own.
  */
 import type { Node as PMNode } from "prosemirror-model";
-import type { DocxExportErrorCode } from "../ooxml/errors";
+import type { DocxExportErrorCode, ExportPartName, ExportProblemReason } from "../ooxml/errors";
 import { type StoryKey, type StoryKind } from "../schema/stories";
 import { type StoryToSettle } from "./identities";
 import type { PartPlanner } from "./partPlan";
@@ -27,8 +27,6 @@ export type StoryChange = {
     readonly key: StoryKey;
     readonly current: PMNode;
 };
-/** The id a key of this kind names */
-export declare function storyIdOf(key: StoryKey, kind: StoryKind): string;
 /** Every story of this kind the package arrived with or the document now holds, in part order then id order */
 export declare function storyChangesOf(doc: PMNode, session: SessionStore, kind: StoryKind): readonly StoryChange[];
 export type StoryChanged = Exclude<StoryChange["change"], "kept">;
@@ -47,6 +45,11 @@ export interface StoryWriting {
 export declare function storyEntriesWriting(part: StoryEntriesPart): StoryWriting;
 /** A writer that takes these changes to every story of the kind, freezing none of them */
 export declare function storyWriting(kind: StoryKind, changes: readonly StoryChanged[]): StoryWriting;
+/** A change to a side story that no part writer carries into the file */
+export interface UnwrittenStoryChange {
+    readonly key: StoryKey;
+    readonly change: StoryChanged;
+}
 /**
  * Every change the document made to a side story that no part writer carries into the file, as the
  * key it stands under and what was done to it.
@@ -56,13 +59,26 @@ export declare function storyWriting(kind: StoryKind, changes: readonly StoryCha
  * writer does not write - and a change to an entry written as it arrived are all reported here
  * rather than dropped from the file without a word.
  */
-export declare function unwrittenStoryChanges(writings: readonly StoryWriting[], doc: PMNode, session: SessionStore): readonly {
+export declare function unwrittenStoryChanges(writings: readonly StoryWriting[], doc: PMNode, session: SessionStore): readonly UnwrittenStoryChange[];
+/** One side story the export writes block by block, under the key it stands at */
+export interface RewrittenStory {
     readonly key: StoryKey;
-    readonly change: StoryChanged;
-}[];
+    readonly story: PMNode;
+}
+/**
+ * Every side story the export writes block by block, which is every one a part writer carries an
+ * addition or an edit of.
+ *
+ * A story the writer hands back as the bytes it arrived as - one nobody touched, one its part
+ * freezes, one whose change no writer carries, which `unwrittenStoryChanges` refuses instead -
+ * goes out holding exactly what it came in holding, so nothing about it can newly be refused. The
+ * same "changed and written" answer decides both, so a writer and the invariants cannot disagree
+ * about which story is written from a node.
+ */
+export declare function rewrittenStories(writings: readonly StoryWriting[], doc: PMNode, session: SessionStore): readonly RewrittenStory[];
 /** A part holding one entry per story, e.g. `w:footnotes` holding a `w:footnote` apiece */
 export interface StoryEntriesPart {
-    readonly name: string;
+    readonly name: ExportPartName;
     readonly kind: StoryKind;
     readonly relType: string;
     readonly contentType: string;
@@ -83,16 +99,21 @@ export interface StoryEntriesPart {
     /** The entries a part this planner creates opens with, before any story */
     prelude(taken: ReadonlySet<string>): string;
 }
+/** One story a part writes, beside the key it stands under */
+export interface StoryEntry extends StoryToSettle {
+    readonly key: StoryKey;
+}
 /**
  * The stories a part is written with, in the order it writes them, and none where no story of its
  * kind changed and the part is not written at all. The identity pass runs over this list as one
  * part, and the export invariants ask the same list.
  */
-export declare function storyEntriesOf(part: StoryEntriesPart, doc: PMNode, session: SessionStore): readonly StoryToSettle[];
+export declare function storyEntriesOf(part: StoryEntriesPart, doc: PMNode, session: SessionStore): readonly StoryEntry[];
 /** One reason the part cannot take the changes its stories went through */
 export interface StoryPartProblem {
     readonly code: DocxExportErrorCode;
     readonly message: string;
+    readonly reason: ExportProblemReason;
 }
 /**
  * Why the part cannot take what the document did to its stories, or none when it can. The part the

package/dist/docx/storyParts.js

@@ -19,6 +19,7 @@ import { sameSource } from "../schema/sourceEquality.js";
 import {
   asStoryKey,
   STORY_KINDS,
+  splitStoryKey,
   storiesOf,
   storyKey,
   storyNodeOf
@@ -40,9 +41,6 @@ function byId(a, b) {
   if (a === b) return 0;
   return a < b ? -1 : 1;
 }
-function storyIdOf(key, kind) {
-  return key.slice(kind.length + 1);
-}
 function arrivedChange(doc, imported) {
   const current = storyNodeOf(doc, imported.key);
   if (current === null) return { change: "removed", imported };
@@ -53,7 +51,7 @@ function storyChangesOf(doc, session, kind) {
   const added = Object.keys(storiesOf(doc)).flatMap((text) => {
     const key = asStoryKey(text);
     return key === null || !key.startsWith(`${kind}:`) || session.stories.has(key) ? [] : [key];
-  }).sort((a, b) => byId(storyIdOf(a, kind), storyIdOf(b, kind))).flatMap((key) => {
+  }).sort((a, b) => byId(splitStoryKey(a).id, splitStoryKey(b).id)).flatMap((key) => {
     const current = storyNodeOf(doc, key);
     return current === null ? [] : [{ change: "added", key, current }];
   });
@@ -91,6 +89,21 @@ function unwrittenStoryChanges(writings, doc, session) {
     });
   });
 }
+function rewrittenStories(writings, doc, session) {
+  const byKind = new Map(writings.map((writing) => [writing.kind, writing]));
+  return STORY_KINDS.flatMap((kind) => {
+    const writing = byKind.get(kind);
+    if (writing === void 0) return [];
+    const frozen = writing.frozenEntries(session);
+    return storyChangesOf(doc, session, kind).flatMap(
+      (entry) => {
+        if (entry.change !== "added" && entry.change !== "edited") return [];
+        const key = entry.change === "added" ? entry.key : entry.imported.key;
+        return writing.changes.includes(entry.change) && !frozen.has(key) ? [{ key, story: entry.current }] : [];
+      }
+    );
+  });
+}
 function writtenStoryOf(change, frozen) {
   if (change.change === "added") return change.current;
   if (change.change === "kept" || frozen.has(change.imported.key)) {
@@ -102,11 +115,13 @@ function writtenStories(changes, frozen) {
   return changes.flatMap((change) => {
     const story = writtenStoryOf(change, frozen);
     if (story === null) return [];
+    const key = change.change === "added" ? change.key : change.imported.key;
     return [
       {
         change,
+        key,
         story,
-        frozen: change.change !== "added" && frozen.has(change.imported.key)
+        frozen: change.change !== "added" && frozen.has(key)
       }
     ];
   });
@@ -116,14 +131,17 @@ function storyEntriesOf(part, doc, session) {
   return changed(changes) ? writtenStories(changes, part.frozenEntries(session)) : [];
 }
 function addedIdProblems(part, changes) {
-  return changes.flatMap(
-    (change) => change.change === "added" && ST_DecimalNumber.parse(storyIdOf(change.key, part.kind)) === null ? [
+  return changes.flatMap((change) => {
+    if (change.change !== "added") return [];
+    const story = splitStoryKey(change.key);
+    return ST_DecimalNumber.parse(story.id) === null ? [
       {
         code: "unsupported-content",
-        message: `the ${change.key} story is named by no whole number, and a ${wName(part.entry)} is identified by one`
+        message: `the ${change.key} story is named by no whole number, and a ${wName(part.entry)} is identified by one`,
+        reason: { kind: "story-id-not-a-number", story }
       }
-    ] : []
-  );
+    ] : [];
+  });
 }
 function storyEntriesProblems(part, doc, session) {
   const changes = storyChangesOf(doc, session, part.kind);
@@ -136,12 +154,19 @@ function storyEntriesProblems(part, doc, session) {
   );
   if (xml !== null) {
     const problem = partRootProblem(xml, part.root);
-    return problem === null ? [] : [{ code: "malformed-xml", message: problem }];
+    return problem === null ? [] : [
+      {
+        code: "malformed-xml",
+        message: problem,
+        reason: { kind: "unwritable-part-root", part: part.name }
+      }
+    ];
   }
   return session.parts.has(CONTENT_TYPES_PATH) ? [] : [
     {
       code: "missing-content-types",
-      message: `cannot add a part to a package that has no ${CONTENT_TYPES_PATH}`
+      message: `cannot add a part to a package that has no ${CONTENT_TYPES_PATH}`,
+      reason: { kind: "missing-content-types", part: part.name }
     }
   ];
 }
@@ -159,7 +184,7 @@ function entryXml(part, { change, frozen }, settled, refs) {
     return serializeStory(
       settled,
       null,
-      containerOf(part, storyIdOf(change.key, part.kind)),
+      containerOf(part, splitStoryKey(change.key).id),
       refs
     );
   }
@@ -256,7 +281,7 @@ function planEntries(part, doc, session, context) {
   context.contentTypes.addOverride(path, part.contentType);
   const taken = /* @__PURE__ */ new Set([
     ...changes.map(
-      (change) => change.change === "added" ? storyIdOf(change.key, part.kind) : change.imported.id
+      (change) => change.change === "added" ? splitStoryKey(change.key).id : change.imported.id
     ),
     ...part.referencedIds(doc)
   ]);
@@ -278,12 +303,12 @@ function storyEntriesPlanner(part) {
 }
 export {
   EVERY_STORY_CHANGE,
+  rewrittenStories,
   storyChangesOf,
   storyEntriesOf,
   storyEntriesPlanner,
   storyEntriesProblems,
   storyEntriesWriting,
-  storyIdOf,
   storyWriting,
   unwrittenStoryChanges
 };

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

package/dist/index.d.ts

@@ -16,12 +16,12 @@ export type { DocxEditorHandle, DocxEditorMode, DocxEditorProps, } from "./DocxE
 export { DocxEditor } from "./DocxEditor";
 export type { DocxBytes, DocxSource } from "./docx/importDocx";
 /** What the handle and a `blocked` download report: each reason the document cannot be written, under the code `DocxExportError` would throw it with */
-export type { ExportProblem } from "./docx/invariants";
+export type { ExportPartName, ExportProblem, ExportProblemReason, ExportProblemStory, ExportStoryKind, } from "./docx/invariants";
 export type { DownloadDocxOptions, DownloadDocxResult, } from "./download";
 export { downloadDocx } from "./download";
 export type { CommentAuthor } from "./editor/commands/commentCommands";
 export type { CellFormat, CellVerticalAlign, DocumentDefaults, HighlightName, LineSpacing, NumberingRef, ParagraphAlign, ParagraphFormat, RowFormat, RowHeight, RunFormat, TableFormat, TableWidth, TableWidthType, UnderlineKind, VerticalAlign, } from "./model/format";
-export type { DocxExportErrorCode, DocxImportErrorCode, } from "./ooxml/errors";
+export type { DocxExportErrorCode, DocxExportErrorOptions, DocxImportErrorCode, } from "./ooxml/errors";
 export { DocxExportError, DocxImportError } from "./ooxml/errors";
 export { docxSchema } from "./schema";
 /** Whose comments the panel offers to edit, which `DocxEditorMode` takes */

package/dist/ooxml/errors.d.ts

@@ -3,7 +3,9 @@
  *
  * Messages are English one-liners meant for developers. The `code` is the stable,
  * machine-readable part: consumers switch on it to show their own localized text,
- * so a code never changes meaning even when a message is reworded.
+ * so a code never changes meaning even when a message is reworded. An export refusal carries an
+ * `ExportProblemReason` besides, which tells the several situations one code covers apart and
+ * names what each is about, so a host can say which content to put back.
  */
 /**
  * Why a document could not be opened.
@@ -33,8 +35,139 @@ export declare class DocxImportError extends Error {
  * - `invalid-table`: the table grid is inconsistent, e.g. a vertical merge outliving its rows
  */
 export type DocxExportErrorCode = "missing-content-types" | "unsupported-content" | "lost-original" | "malformed-xml" | "invalid-table";
+/**
+ * The kinds of side story a refusal can be about, which are the kinds a document holds beside its
+ * body (`schema/stories`). Spelled here because the reasons stand below the schema layer.
+ */
+export type ExportStoryKind = "comment" | "footnote" | "endnote" | "header" | "footer";
+/**
+ * One side story, as the document holds it.
+ *
+ * A reason names it wherever the content the refusal is about may stand outside the body, and the
+ * refusal is then about that story rather than the document: `story` is null for the body itself.
+ */
+export interface ExportProblemStory {
+    readonly kind: ExportStoryKind;
+    /** A note's number, a comment's id, or the path of the part a header or footer stands in */
+    readonly id: string;
+}
+/** A part the export writes beside the body, named after what it holds */
+export type ExportPartName = "media" | "numbering" | "comments" | "commentsExtended" | "people" | "footnotes" | "endnotes";
+/**
+ * What a refusal is actually about.
+ *
+ * A `code` groups several situations - `unsupported-content` alone covers a list nothing defines,
+ * a block standing twice, and a change to a story no writer carries - and the `message` telling
+ * them apart is an English one-liner for a developer. This says which situation was met and names
+ * what it is about, so a host can write the sentence its own user reads. Switch on `kind`.
+ */
+export type ExportProblemReason = 
+/** A preserved fragment holding bookmark markup could not be parsed (`malformed-xml`) */
+{
+    readonly kind: "unreadable-preserved-xml";
+    readonly story: ExportProblemStory | null;
+}
+/** A bookmark marker carries no id to pair it by (`malformed-xml`) */
+ | {
+    readonly kind: "unnamed-bookmark";
+    readonly marker: "start" | "end";
+    readonly story: ExportProblemStory | null;
+}
+/**
+ * A bookmark marker whose partner is gone (`malformed-xml`): a `start` with no end after it, or
+ * an `end` with no start before it.
+ */
+ | {
+    readonly kind: "unmatched-bookmark";
+    readonly id: string;
+    readonly marker: "start" | "end";
+    readonly story: ExportProblemStory | null;
+}
+/** One bookmark id is started twice (`malformed-xml`) */
+ | {
+    readonly kind: "repeated-bookmark-start";
+    readonly id: string;
+    readonly story: ExportProblemStory | null;
+}
+/** A part cannot be rewritten around its root element (`malformed-xml`) */
+ | {
+    readonly kind: "unwritable-part-root";
+    readonly part: ExportPartName;
+}
+/** A cell's vertical merge covers rows its table does not have (`invalid-table`) */
+ | {
+    readonly kind: "vertical-merge-past-table";
+    readonly story: ExportProblemStory | null;
+}
+/** A node that is written from its original XML alone no longer holds it (`lost-original`) */
+ | {
+    readonly kind: "lost-preserved-xml";
+    readonly node: string;
+    readonly story: ExportProblemStory | null;
+}
+/** A placeholder pasted in from another opened document, whose XML this session never read (`lost-original`) */
+ | {
+    readonly kind: "preserved-from-another-document";
+    readonly node: string;
+    /** The session the placeholder was opened in */
+    readonly sessionId: string;
+    readonly story: ExportProblemStory | null;
+}
+/** One preserved block stands in two places, and it has one original XML to be written (`unsupported-content`) */
+ | {
+    readonly kind: "duplicate-preserved-block";
+    readonly node: string;
+    readonly story: ExportProblemStory | null;
+}
+/** A paragraph is in a list neither the file nor the editor's register defines (`unsupported-content`) */
+ | {
+    readonly kind: "undefined-list";
+    readonly numId: number;
+    readonly story: ExportProblemStory | null;
+}
+/** A story was changed and no part writer carries that change into the file (`unsupported-content`) */
+ | {
+    readonly kind: "unwritten-story-change";
+    readonly story: ExportProblemStory;
+    readonly change: "added" | "edited" | "removed";
+}
+/** A story was added under an id its part identifies entries by no whole number of (`unsupported-content`) */
+ | {
+    readonly kind: "story-id-not-a-number";
+    readonly story: ExportProblemStory;
+}
+/** A part the writer has to add cannot be declared, the package having no content types part (`missing-content-types`) */
+ | {
+    readonly kind: "missing-content-types";
+    readonly part: ExportPartName;
+};
+/** One reason the document cannot be written back, with the code `exportDocx` would throw it under */
+export interface ExportProblem {
+    readonly code: DocxExportErrorCode;
+    /** An English one-liner for a developer; reworded freely. Read `code` and `reason` instead */
+    readonly message: string;
+    /** Which of the situations the code covers was met, and what it is about */
+    readonly reason: ExportProblemReason;
+    /**
+     * Where the problem stands in the document: the block or marker it is about, or, for a footnote
+     * or an endnote, the first reference to that note in the body, the note's own text standing
+     * nowhere there. Absent for a problem of the package, of the session, of a header, footer or
+     * comment story, and of a note the body refers to nowhere.
+     */
+    readonly pos?: number;
+}
+/** What a `DocxExportError` may be given beyond its code and message */
+export interface DocxExportErrorOptions extends ErrorOptions {
+    /** The entry `exportProblems` reports for this refusal, where an invariant predicted it */
+    readonly problem?: ExportProblem;
+}
 /** Thrown when an edited document cannot be written back out without losing or corrupting content */
 export declare class DocxExportError extends Error {
     readonly code: DocxExportErrorCode;
-    constructor(code: DocxExportErrorCode, message: string, options?: ErrorOptions);
+    /**
+     * What `exportProblems` reports for this refusal, carrying its `reason` and `pos`. Absent for a
+     * refusal met while writing that no invariant predicted.
+     */
+    readonly problem?: ExportProblem;
+    constructor(code: DocxExportErrorCode, message: string, options?: DocxExportErrorOptions);
 }

package/dist/ooxml/errors.js

@@ -9,10 +9,16 @@ var DocxImportError = class extends Error {
 };
 var DocxExportError = class extends Error {
   code;
+  /**
+   * What `exportProblems` reports for this refusal, carrying its `reason` and `pos`. Absent for a
+   * refusal met while writing that no invariant predicted.
+   */
+  problem;
   constructor(code, message, options) {
     super(message, options);
     this.name = "DocxExportError";
     this.code = code;
+    this.problem = options?.problem;
   }
 };
 export {

package/dist/schema/stories.d.ts

@@ -35,12 +35,20 @@ export declare const STORIES_ATTR = "stories";
 export declare function storyKey<K extends StoryKind>(kind: K, id: string): `${K}:${string}`;
 /** The key of a story that is a note: `footnote:2`, `endnote:3` */
 export type NoteKey = `${NoteKind}:${string}`;
+/** What a key names: which kind of story it is, and the id it stands under */
+export interface StoryName {
+    readonly kind: StoryKind;
+    readonly id: string;
+}
 /**
- * The note this key names, and null for a key naming a story of another kind.
+ * The kind and the id a key names.
  *
- * A note's id never carries a colon - a note is identified by a whole number (§17.11.2, §17.11.8)
- * - so the kind is everything up to the first one.
+ * An id carries colons of its own - a header is named by its part path - so the kind is everything
+ * up to the first one. A key is spelled `${StoryKind}:${string}`, so the kind always reads back;
+ * text that may spell no kind at all comes through `asStoryKey` first.
  */
+export declare function splitStoryKey(key: StoryKey): StoryName;
+/** The note this key names, and null for a key naming a story of another kind */
 export declare function noteKeyOf(key: StoryKey): {
     readonly kind: NoteKind;
     readonly id: string;

package/dist/schema/stories.js

@@ -15,11 +15,16 @@ var STORIES_ATTR = "stories";
 function storyKey(kind, id) {
   return `${kind}:${id}`;
 }
-function noteKeyOf(key) {
+function splitStoryKey(key) {
   const at = key.indexOf(":");
   const named = key.slice(0, at);
-  const kind = NOTE_KINDS.find((candidate) => candidate === named);
-  return kind === void 0 ? null : { kind, id: key.slice(at + 1) };
+  const kind = STORY_KINDS.find((candidate) => candidate === named);
+  return { kind: kind ?? "comment", id: key.slice(at + 1) };
+}
+function noteKeyOf(key) {
+  const { kind, id } = splitStoryKey(key);
+  const note = NOTE_KINDS.find((candidate) => candidate === kind);
+  return note === void 0 ? null : { kind: note, id };
 }
 var EDITABLE_NOTE_KINDS = NOTE_KINDS;
 function asStoryKey(text) {
@@ -88,6 +93,7 @@ export {
   noteKeyOf,
   noteName,
   sameStory,
+  splitStoryKey,
   storiesOf,
   storyKey,
   storyNodeOf,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portone/docx-editor",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "A simple DOCX editor for React, built directly on OOXML.",
   "license": "Apache-2.0",
   "type": "module",