@portone/docx-editor 0.6.1 → 0.6.2

package/dist/docx/invariants.js

@@ -8,7 +8,12 @@ import {
 } from "../ooxml/xml.js";
 import { visitPreservedFragments } from "../schema/preservedFragments.js";
 import { unattributedCommentAuthors } from "../schema/protection.js";
-import { HEADER_FOOTER_KINDS } from "../schema/stories.js";
+import {
+  HEADER_FOOTER_KINDS,
+  NOTE_KINDS,
+  splitStoryKey,
+  storyKey
+} from "../schema/stories.js";
 import {
   commentReferencesIn,
   commentsChanged,
@@ -23,12 +28,10 @@ import {
 } from "./comments/parts.js";
 import { unrecordedAuthors } from "./comments/people.js";
 import { currentCommentBodies } from "./comments/writing.js";
-import {
-  identityProblems,
-  identityProblemsInStories
-} 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";
@@ -37,75 +40,110 @@ import {
   sessionOf
 } from "./session.js";
 import {
+  rewrittenStories,
   storyChangesOf,
   storyEntriesOf,
   storyEntriesProblems,
   unwrittenStoryChanges
 } from "./storyParts.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({
+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) => {
@@ -117,135 +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, session) {
+  check({ doc, session }) {
     const parts = [
       ...HEADER_FOOTER_KINDS.flatMap(
-        (kind) => storyChangesOf(doc, session, kind)
-      ).flatMap(
-        (change) => change.change === "edited" ? [[{ story: change.current, frozen: false }]] : []
+        (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),
-      ...parts.flatMap((entries) => identityProblemsInStories(entries)).map(({ code, message }) => ({ code, message }))
+      ...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) {
+  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`
+        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;
@@ -253,28 +346,63 @@ 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(
+  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,
@@ -286,12 +414,27 @@ var EXPORT_INVARIANTS = [
   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/numbering.js

@@ -9,19 +9,12 @@ import { sectionsOf } from "../sections.js";
 import {
   withNoteProps
 } from "./reading.js";
+import { eachNoteReference } from "./references.js";
 var MAX_LABEL_CHARS = 64;
 function referencesBySection(doc) {
   const found = [];
-  doc.forEach((block, offset, index) => {
-    block.descendants((node, pos) => {
-      if (node.type.name === "noteReference") {
-        found.push({
-          block: index,
-          reference: { pos: offset + 1 + pos, node }
-        });
-      }
-      return true;
-    });
+  eachNoteReference(doc, ({ node, pos, block }) => {
+    found.push({ block, reference: { pos, node } });
   });
   if (found.length === 0) return [];
   const sections = sectionsOf(doc);

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

@@ -0,0 +1,33 @@
+/**
+ * Where the body refers to its notes.
+ *
+ * Three readers ask: the notes writers collect the ids each part is referred to by, the numbering
+ * counts the references section by section (`./numbering`), and the export invariants look up the
+ * first reference to one note, which is where a problem about a note's own text is reported
+ * (`docx/invariants`). One walk here is what keeps the three reading the same nodes in the same
+ * order.
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import { type NoteKey } from "../../schema/stories";
+/** One reference the body makes to a note */
+export interface PlacedNoteReference {
+    readonly node: PMNode;
+    /** Where the reference stands in the document */
+    readonly pos: number;
+    /** The top-level block it stands in, by index, which is what a section covers a run of */
+    readonly block: number;
+    /** The note it names, and null where it names no kind of note or carries no id */
+    readonly key: NoteKey | null;
+}
+/**
+ * Every `noteReference` of the body in document order, until `visit` answers false.
+ *
+ * Only the document node is walked: WordprocessingML puts a reference in the body and a note's own
+ * text in a part of its own, so a side story holds none.
+ */
+export declare function eachNoteReference(doc: PMNode, visit: (reference: PlacedNoteReference) => boolean | void): void;
+/**
+ * Where the body first refers to each of these notes, and nothing for one it refers to nowhere.
+ * The walk stops as soon as every note asked about has been placed.
+ */
+export declare function firstNoteReferences(doc: PMNode, wanted: ReadonlySet<NoteKey>): ReadonlyMap<NoteKey, number>;

package/dist/docx/notes/references.js

@@ -0,0 +1,37 @@
+// src/docx/notes/references.ts
+import { NOTE_KINDS, storyKey } from "../../schema/stories.js";
+function keyOf(node) {
+  const kind = NOTE_KINDS.find((candidate) => candidate === node.attrs.kind);
+  const id = node.attrs.id;
+  return kind === void 0 || typeof id !== "string" ? null : storyKey(kind, id);
+}
+function eachNoteReference(doc, visit) {
+  let running = true;
+  doc.forEach((block, offset, index) => {
+    if (!running) return;
+    block.descendants((node, pos) => {
+      if (!running) return false;
+      if (node.type.name !== "noteReference") return true;
+      running = visit({
+        node,
+        pos: offset + 1 + pos,
+        block: index,
+        key: keyOf(node)
+      }) !== false;
+      return false;
+    });
+  });
+}
+function firstNoteReferences(doc, wanted) {
+  const first = /* @__PURE__ */ new Map();
+  if (wanted.size === 0) return first;
+  eachNoteReference(doc, ({ key, pos }) => {
+    if (key !== null && wanted.has(key) && !first.has(key)) first.set(key, pos);
+    return first.size < wanted.size;
+  });
+  return first;
+}
+export {
+  eachNoteReference,
+  firstNoteReferences
+};