@portone/docx-editor 0.6.0 → 0.6.2

package/dist/docx/invariants.js

@@ -8,6 +8,12 @@ import {
 } from "../ooxml/xml.js";
 import { visitPreservedFragments } from "../schema/preservedFragments.js";
 import { unattributedCommentAuthors } from "../schema/protection.js";
+import {
+  HEADER_FOOTER_KINDS,
+  NOTE_KINDS,
+  splitStoryKey,
+  storyKey
+} from "../schema/stories.js";
 import {
   commentReferencesIn,
   commentsChanged,
@@ -22,79 +28,122 @@ import {
 } from "./comments/parts.js";
 import { unrecordedAuthors } from "./comments/people.js";
 import { currentCommentBodies } from "./comments/writing.js";
-import { identityProblems } from "./identities.js";
+import { identityProblems, identityProblemsInStories } from "./identities.js";
 import { insertedImageSrcs } from "./media.js";
 import { canDefineNewList, newNumIds, startedLists } from "./newLists.js";
+import { firstNoteReferences } from "./notes/references.js";
 import { CONTENT_TYPES_PATH } from "./packageParts.js";
+import { STORY_ENTRIES_PARTS, STORY_WRITINGS } from "./partPlanners.js";
 import { lostOriginal } from "./serializePreserved.js";
 import {
   originalBlock,
   sessionOf
 } from "./session.js";
-var bookmarkPairs = {
-  name: "bookmarkPairs",
-  check(doc, session) {
-    const problems = [];
-    const open = /* @__PURE__ */ new Map();
-    const used = /* @__PURE__ */ new Set();
-    visitPreservedFragments(doc, (node, pos, xml) => {
-      const source = xml ?? originalBlock(node, session)?.xml ?? null;
-      if (source === null) return;
-      if (!source.includes("bookmark")) return;
-      let root;
-      try {
-        root = parseXml(
-          session.documentPrefix + source + session.documentSuffix
-        ).documentElement;
-      } catch {
-        problems.push({
+import {
+  rewrittenStories,
+  storyChangesOf,
+  storyEntriesOf,
+  storyEntriesProblems,
+  unwrittenStoryChanges
+} from "./storyParts.js";
+function found(scope, pos, problem) {
+  return scope.story === null ? { ...problem, pos } : problem;
+}
+function overScopes(name, check) {
+  return {
+    name,
+    check: ({ scopes, session }) => scopes.flatMap((scope) => check(scope, session))
+  };
+}
+var bookmarkPairs = overScopes("bookmarkPairs", (scope, session) => {
+  const problems = [];
+  const open = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  visitPreservedFragments(scope.doc, (node, pos, xml) => {
+    const source = xml ?? originalBlock(node, session)?.xml ?? null;
+    if (source === null) return;
+    if (!source.includes("bookmark")) return;
+    let root;
+    try {
+      root = parseXml(
+        session.documentPrefix + source + session.documentSuffix
+      ).documentElement;
+    } catch {
+      problems.push(
+        found(scope, pos, {
           code: "malformed-xml",
           message: "preserved bookmark XML could not be parsed",
-          pos
-        });
-        return;
-      }
-      for (const marker of Array.from(root.getElementsByTagName("*"))) {
-        if (marker.namespaceURI !== W_NS || marker.localName !== "bookmarkStart" && marker.localName !== "bookmarkEnd")
-          continue;
-        const kind = marker.localName.slice("bookmark".length);
-        const value = attributeByLocalName(marker, "id");
-        if (value === null || value === "") {
-          problems.push({
+          reason: { kind: "unreadable-preserved-xml", story: scope.story }
+        })
+      );
+      return;
+    }
+    for (const marker of Array.from(root.getElementsByTagName("*"))) {
+      if (marker.namespaceURI !== W_NS || marker.localName !== "bookmarkStart" && marker.localName !== "bookmarkEnd")
+        continue;
+      const kind = marker.localName.slice("bookmark".length);
+      const value = attributeByLocalName(marker, "id");
+      if (value === null || value === "") {
+        problems.push(
+          found(scope, pos, {
             code: "malformed-xml",
             message: `a bookmark${kind} has no id`,
-            pos
-          });
-        } else if (kind === "Start") {
-          if (used.has(value)) {
-            problems.push({
+            reason: {
+              kind: "unnamed-bookmark",
+              marker: kind === "Start" ? "start" : "end",
+              story: scope.story
+            }
+          })
+        );
+      } else if (kind === "Start") {
+        if (used.has(value)) {
+          problems.push(
+            found(scope, pos, {
               code: "malformed-xml",
               message: `bookmark ${value} has more than one start marker`,
-              pos
-            });
-          } else {
-            open.set(value, pos);
-            used.add(value);
-          }
-        } else if (!open.delete(value)) {
-          problems.push({
+              reason: {
+                kind: "repeated-bookmark-start",
+                id: value,
+                story: scope.story
+              }
+            })
+          );
+        } else {
+          open.set(value, pos);
+          used.add(value);
+        }
+      } else if (!open.delete(value)) {
+        problems.push(
+          found(scope, pos, {
             code: "malformed-xml",
             message: `bookmark ${value} ends without an earlier start marker`,
-            pos
-          });
-        }
+            reason: {
+              kind: "unmatched-bookmark",
+              id: value,
+              marker: "end",
+              story: scope.story
+            }
+          })
+        );
       }
-    });
-    for (const [id, pos] of open) {
-      problems.push({
+    }
+  });
+  for (const [id, pos] of open) {
+    problems.push(
+      found(scope, pos, {
         code: "malformed-xml",
         message: `bookmark ${id} has no end marker`,
-        pos
-      });
-    }
-    return problems;
+        reason: {
+          kind: "unmatched-bookmark",
+          id,
+          marker: "start",
+          story: scope.story
+        }
+      })
+    );
   }
-};
+  return problems;
+});
 function mergeReachesPastLastRow(table) {
   let overlong = false;
   table.forEach((row, _offset, at) => {
@@ -106,113 +155,190 @@ function mergeReachesPastLastRow(table) {
   });
   return overlong;
 }
-var tableGrids = {
-  name: "tableGrids",
-  check(doc) {
-    const problems = [];
-    doc.descendants((node, pos) => {
-      if (node.type.name !== "table") return true;
-      if (mergeReachesPastLastRow(node)) {
-        problems.push({
+var tableGrids = overScopes("tableGrids", (scope) => {
+  const problems = [];
+  scope.doc.descendants((node, pos) => {
+    if (node.type.name !== "table") return true;
+    if (mergeReachesPastLastRow(node)) {
+      problems.push(
+        found(scope, pos, {
           code: "invalid-table",
           message: "a vertical merge in the table reaches past the last row",
-          pos
-        });
-      }
-      return true;
-    });
-    return problems;
-  }
-};
+          reason: { kind: "vertical-merge-past-table", story: scope.story }
+        })
+      );
+    }
+    return true;
+  });
+  return problems;
+});
 var CARRIES_ITS_XML = /* @__PURE__ */ new Set([
   "rawInline",
   "rawRunContent"
 ]);
-function lostOriginalOf(node, session) {
+function lostOriginalOf(node, session, story) {
   if (CARRIES_ITS_XML.has(node.type.name)) {
-    return typeof node.attrs.xml === "string" ? null : "a preserved element has lost its original XML";
+    return typeof node.attrs.xml === "string" ? null : {
+      message: "a preserved element has lost its original XML",
+      reason: {
+        kind: "lost-preserved-xml",
+        node: node.type.name,
+        story
+      }
+    };
   }
   if (node.type.isInGroup("preserved")) {
     if (typeof node.attrs.xml === "string") return null;
-    return originalBlock(node, session) ? null : lostOriginal(node, session);
+    return originalBlock(node, session) ? null : lostOriginal(node, session, story);
   }
   return null;
 }
-var preservedOriginals = {
-  name: "preservedOriginals",
-  check(doc, session) {
+var preservedOriginals = overScopes(
+  "preservedOriginals",
+  (scope, session) => {
     const problems = [];
-    doc.descendants((node, pos) => {
-      const message = lostOriginalOf(node, session);
-      if (message !== null)
-        problems.push({ code: "lost-original", message, pos });
+    scope.doc.descendants((node, pos) => {
+      const lost = lostOriginalOf(node, session, scope.story);
+      if (lost !== null) {
+        problems.push(found(scope, pos, { code: "lost-original", ...lost }));
+      }
       return true;
     });
     return problems;
   }
-};
+);
 var uniqueIdentities = {
   name: "uniqueIdentities",
-  check(doc) {
-    return identityProblems(doc);
+  check({ doc, session }) {
+    const parts = [
+      ...HEADER_FOOTER_KINDS.flatMap(
+        (kind) => storyChangesOf(doc, session, kind).flatMap(
+          (change) => change.change === "edited" ? [
+            [
+              {
+                key: change.imported.key,
+                story: change.current,
+                frozen: false
+              }
+            ]
+          ] : []
+        )
+      ),
+      ...STORY_ENTRIES_PARTS.map((part) => storyEntriesOf(part, doc, session))
+    ];
+    return [
+      ...identityProblems(doc).map(
+        ({ code, message, node, pos }) => ({
+          code,
+          message,
+          reason: { kind: "duplicate-preserved-block", node, story: null },
+          pos
+        })
+      ),
+      ...parts.flatMap(
+        (entries) => identityProblemsInStories(entries).map(
+          ({ code, message, node, story }) => {
+            const entry = entries[story];
+            return {
+              code,
+              message,
+              reason: {
+                kind: "duplicate-preserved-block",
+                node,
+                story: entry === void 0 ? null : splitStoryKey(entry.key)
+              }
+            };
+          }
+        )
+      )
+    ];
+  }
+};
+var storiesHaveWriters = {
+  name: "storiesHaveWriters",
+  check({ doc, session }) {
+    return unwrittenStoryChanges(STORY_WRITINGS, doc, session).map(
+      ({ key, change }) => ({
+        code: "unsupported-content",
+        message: `the ${key} story was ${change}, and no part writer carries that into the file`,
+        reason: {
+          kind: "unwritten-story-change",
+          story: splitStoryKey(key),
+          change
+        }
+      })
+    );
   }
 };
+function undefinedListProblems(scope, undefinedIds) {
+  const problems = [];
+  scope.doc.descendants((node, pos) => {
+    if (node.type.name !== "paragraph") return true;
+    const numId = toParagraphFormat(node.attrs.format)?.numbering?.numId;
+    if (numId === void 0 || !undefinedIds.delete(numId)) return false;
+    problems.push(
+      found(scope, pos, {
+        code: "unsupported-content",
+        message: `the list numbered ${numId} has no definition to be written`,
+        reason: { kind: "undefined-list", numId, story: scope.story }
+      })
+    );
+    return false;
+  });
+  return problems;
+}
 var listDefinitions = {
   name: "listDefinitions",
-  check(doc, session) {
+  check({ doc, session, scopes }) {
     const undefinedIds = new Set(startedLists(doc, session).unregistered);
     if (undefinedIds.size === 0) return [];
-    const problems = [];
-    doc.descendants((node, pos) => {
-      if (node.type.name !== "paragraph") return true;
-      const numId = toParagraphFormat(node.attrs.format)?.numbering?.numId;
-      if (numId === void 0 || !undefinedIds.delete(numId)) return false;
-      problems.push({
-        code: "unsupported-content",
-        message: `the list numbered ${numId} has no definition to be written`,
-        pos
-      });
-      return false;
-    });
-    return problems;
+    return scopes.flatMap(
+      (scope) => undefinedListProblems(scope, undefinedIds)
+    );
   }
 };
-function addsCommentsPart(doc, session) {
+function addedCommentsPart(doc, session) {
   const bodyChanged = commentsChanged(doc, session);
   const threadChanged = extensionsChanged(doc, session);
-  if (!bodyChanged && !threadChanged) return false;
-  if (commentsPart.pathIn(session) === null || session.comments.xml === null)
-    return true;
+  if (!bodyChanged && !threadChanged) return null;
+  if (commentsPart.pathIn(session) === null || session.comments.xml === null) {
+    return "comments";
+  }
   const references = commentReferencesIn(doc);
-  if (threadChanged && (references.size > 0 || session.comments.extendedPartPath !== null) && (commentsExtendedPart.pathIn(session) === null || session.comments.extendedXml === null))
-    return true;
+  if (threadChanged && (references.size > 0 || session.comments.extendedPartPath !== null) && (commentsExtendedPart.pathIn(session) === null || session.comments.extendedXml === null)) {
+    return "commentsExtended";
+  }
   return bodyChanged && (peoplePart.pathIn(session) === null || session.comments.people.xml === null) && unrecordedAuthors(
     currentCommentBodies(references).values(),
     session.comments.people,
     unattributedCommentAuthors(session.comments.ordered)
-  ).size > 0;
+  ).size > 0 ? "people" : null;
 }
 var mediaContentTypes = {
   name: "mediaContentTypes",
-  check(doc, session) {
+  check({ doc, session }) {
     if (session.parts.has(CONTENT_TYPES_PATH)) return [];
     const problems = [];
     if (insertedImageSrcs(doc).length > 0) {
       problems.push({
         code: "missing-content-types",
-        message: `cannot add an image to a package that has no ${CONTENT_TYPES_PATH}`
+        message: `cannot add an image to a package that has no ${CONTENT_TYPES_PATH}`,
+        reason: { kind: "missing-content-types", part: "media" }
       });
     }
     if (!canDefineNewList(session) && newNumIds(doc, session).length > 0) {
       problems.push({
         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: "numbering" }
       });
     }
-    if (addsCommentsPart(doc, session)) {
+    const comments = addedCommentsPart(doc, session);
+    if (comments !== null) {
       problems.push({
         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: comments }
       });
     }
     return problems;
@@ -220,37 +346,95 @@ var mediaContentTypes = {
 };
 var commentPartRoots = {
   name: "commentPartRoots",
-  check(doc, session) {
+  check({ doc, session }) {
     const problems = [];
     const { xml, extendedXml, extendedPartPath } = session.comments;
     if (xml !== null && commentsChanged(doc, session)) {
       const problem = commentsRootProblem(xml);
-      if (problem !== null)
-        problems.push({ code: "malformed-xml", message: problem });
+      if (problem !== null) {
+        problems.push({
+          code: "malformed-xml",
+          message: problem,
+          reason: { kind: "unwritable-part-root", part: "comments" }
+        });
+      }
     }
     if (extendedXml !== null && extensionsChanged(doc, session) && (commentReferencesIn(doc).size > 0 || extendedPartPath !== null)) {
       const problem = extensionsRootProblem(extendedXml);
-      if (problem !== null)
-        problems.push({ code: "malformed-xml", message: problem });
+      if (problem !== null) {
+        problems.push({
+          code: "malformed-xml",
+          message: problem,
+          reason: { kind: "unwritable-part-root", part: "commentsExtended" }
+        });
+      }
     }
     return problems;
   }
 };
+var notePartRoots = {
+  name: "notePartRoots",
+  check: ({ doc, session }) => STORY_ENTRIES_PARTS.flatMap(
+    (part) => storyEntriesProblems(part, doc, session)
+  )
+};
+function noteKeyIn(reason) {
+  const story = "story" in reason ? reason.story : null;
+  if (story === null) return null;
+  const kind = NOTE_KINDS.find((candidate) => candidate === story.kind);
+  return kind === void 0 ? null : storyKey(kind, story.id);
+}
+function atNoteReferences(problems, doc) {
+  let references = null;
+  const placed = (key) => {
+    references ??= firstNoteReferences(
+      doc,
+      new Set(
+        problems.flatMap(
+          ({ pos, reason }) => pos === void 0 ? noteKeyIn(reason) ?? [] : []
+        )
+      )
+    );
+    return references.get(key);
+  };
+  return problems.map((problem) => {
+    const key = problem.pos === void 0 ? noteKeyIn(problem.reason) : null;
+    const pos = key === null ? void 0 : placed(key);
+    return pos === void 0 ? problem : { ...problem, pos };
+  });
+}
 var EXPORT_INVARIANTS = [
   bookmarkPairs,
   tableGrids,
   preservedOriginals,
   uniqueIdentities,
   listDefinitions,
+  storiesHaveWriters,
   mediaContentTypes,
-  commentPartRoots
+  commentPartRoots,
+  notePartRoots
 ];
+function exportScopes(doc, session) {
+  return [
+    { doc, story: null },
+    ...rewrittenStories(STORY_WRITINGS, doc, session).map(({ key, story }) => ({
+      doc: story,
+      story: splitStoryKey(key)
+    }))
+  ];
+}
 var answered = /* @__PURE__ */ new WeakMap();
 function problemsOf(doc, session) {
   const known = answered.get(doc);
   if (known && known.session === session) return known.problems;
-  const problems = EXPORT_INVARIANTS.flatMap(
-    (invariant) => invariant.check(doc, session)
+  const subject = {
+    doc,
+    session,
+    scopes: exportScopes(doc, session)
+  };
+  const problems = atNoteReferences(
+    EXPORT_INVARIANTS.flatMap((invariant) => invariant.check(subject)),
+    doc
   );
   answered.set(doc, { session, problems });
   return problems;

package/dist/docx/newLists.js

@@ -3,6 +3,7 @@ import { toParagraphFormat } from "../model/format.js";
 import { NEW_LISTS_ATTR, newListsOf } from "../numbering/listRegistry.js";
 import { parseNumbering } from "../numbering/parseNumbering.js";
 import { R_NS } from "../ooxml/xml.js";
+import { asStoryKey, storiesOf, storyNodeOf } from "../schema/stories.js";
 import { CONTENT_TYPES_PATH } from "./packageParts.js";
 var NUMBERING_REL_TYPE = `${R_NS}/numbering`;
 var NUMBERING_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml";
@@ -15,20 +16,28 @@ function collectNumIds(node, into) {
   };
   if (visit(node)) node.descendants(visit);
 }
-function numIdsIn(node) {
+function numIdsNow(doc) {
   const used = /* @__PURE__ */ new Set();
-  collectNumIds(node, used);
+  collectNumIds(doc, used);
+  for (const key of Object.keys(storiesOf(doc))) {
+    const story = asStoryKey(key);
+    const node = story === null ? null : storyNodeOf(doc, story);
+    if (node !== null) collectNumIds(node, used);
+  }
   return used;
 }
 function numIdsAtOpen(session) {
   const used = /* @__PURE__ */ new Set();
   for (const block of session.blocks) collectNumIds(block.node, used);
+  for (const story of session.stories.values()) {
+    for (const block of story.blocks) collectNumIds(block.node, used);
+  }
   return used;
 }
 function newNumIds(doc, session) {
   const defined = parseNumbering(session.numberingXml).lists;
   const atOpen = numIdsAtOpen(session);
-  return Array.from(numIdsIn(doc)).filter((numId) => !defined.has(numId) && !atOpen.has(numId)).sort((a, b) => a - b);
+  return Array.from(numIdsNow(doc)).filter((numId) => !defined.has(numId) && !atOpen.has(numId)).sort((a, b) => a - b);
 }
 function startedLists(doc, session) {
   const registered = newListsOf(doc.attrs[NEW_LISTS_ATTR]);

package/dist/docx/notes/newNote.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The note an edit puts into a document: a new, empty one, and a copy of one the document holds.
+ *
+ * Both are side stories (`docx/story`), written back by the notes part writer (`./writing`) as an
+ * entry of their own, which is why a copy names none of the blocks its original was read from.
+ */
+import { type Node as PMNode } from "prosemirror-model";
+import { type NoteKind, type StoryKey } from "../../schema/stories";
+import type { FormattingContext } from "../formatting";
+import { type SessionStore } from "../session";
+/**
+ * The elements that stand for a note's own number inside its entry, which is what Word draws the
+ * number from and what a note that keeps its number keeps (`editor/notes/noteSurface`).
+ */
+export declare const NOTE_NUMBER_ELEMENTS: readonly string[];
+/**
+ * The run properties a note's number is written with: the document's own style for it where the
+ * document defines one, and superscript where it does not.
+ */
+export declare function noteNumberRunProps(kind: NoteKind, formatting: FormattingContext): string;
+/**
+ * The story of a new note holding no text yet: one paragraph in the document's style for note
+ * text, opening with the note's number the way Word writes a note it inserts.
+ */
+export declare function newNoteStory(kind: NoteKind, formatting: FormattingContext): PMNode;
+/**
+ * Every id a note of this kind already answers to: the entries the opened part holds, the stories
+ * the document holds, and the ids the references name, whether or not a note stands behind them.
+ */
+export declare function takenNoteIds(doc: PMNode, kind: NoteKind, reserved: ReadonlySet<StoryKey>): Set<string>;
+/** The id one above the largest of these, and never below one */
+export declare function nextNoteId(taken: Iterable<string>): string;
+/**
+ * The story a copied reference's note is given: the same content, naming none of the blocks the
+ * original was read from and none of its paragraph ids, so the export writes it as an entry of its
+ * own rather than as the bytes of the original a second time (`docx/cloning`). A preserved block
+ * that only names its fragment takes the fragment's XML along.
+ */
+export declare function copiedNoteStory(story: PMNode, session: SessionStore | null): PMNode;