@portone/docx-editor 0.2.1 → 0.3.0

package/dist/docx/commentOnlyChange.js

@@ -1,161 +1,14 @@
 // src/docx/commentOnlyChange.ts
-import { decodeUtf8, elementChildren, parseXml } from "../ooxml/xml.js";
-import {
-  commentAdditionsBy,
-  commentEditsOwned,
-  commentIdentitiesKept,
-  withoutComments
-} from "../schema/protection.js";
-import {
-  COMMENTS_CONTENT_TYPE,
-  COMMENTS_EXTENDED_CONTENT_TYPE,
-  COMMENTS_EXTENDED_REL_TYPE,
-  COMMENTS_REL_TYPE,
-  CONTENT_TYPES_PATH,
-  PEOPLE_CONTENT_TYPE,
-  PEOPLE_REL_TYPE
-} from "./comments/constants.js";
-import { commentPartsKept } from "./comments/verifying.js";
-import { importDocx } from "./importDocx.js";
-import {
-  readRelationships,
-  relsPathOf
-} from "./relationships.js";
-import {
-  comparableStory,
-  isModelledBlock
-} from "./storyProjection.js";
-var COMMENT_REL_TYPES = [
-  COMMENTS_REL_TYPE,
-  COMMENTS_EXTENDED_REL_TYPE,
-  PEOPLE_REL_TYPE
-];
-var COMMENT_CONTENT_TYPES = [
-  COMMENTS_CONTENT_TYPE,
-  COMMENTS_EXTENDED_CONTENT_TYPE,
-  PEOPLE_CONTENT_TYPE
-];
-var refused = (reason) => ({ ok: false, reason });
-function sameBytes(before, after) {
-  return before.length === after.length && before.every((byte, index) => byte === after[index]);
-}
-function commentPartsOf(session) {
-  const { partPath, extendedPartPath, people } = session.comments;
-  return [partPath, extendedPartPath, people.partPath];
-}
-function commentPartPaths(session) {
-  return new Set(
-    commentPartsOf(session).filter((path) => path !== null)
-  );
-}
-function aroundTheStory(session) {
-  const preserved = session.blocks.filter((block) => !isModelledBlock(block.node)).map((block) => block.xml).join("");
-  return session.documentPrefix + preserved + session.documentSuffix;
-}
-function relationshipsKept(before, after) {
-  if (new Set(before.map((entry) => entry.id)).size !== before.length || new Set(after.map((entry) => entry.id)).size !== after.length) {
-    return false;
-  }
-  const now = new Map(after.map((entry) => [entry.id, entry]));
-  const kept = before.every((entry) => {
-    const current = now.get(entry.id);
-    return current !== void 0 && current.type === entry.type && current.target === entry.target && current.external === entry.external;
+import { commentsPolicy } from "./comments/policy.js";
+import { verifyChange } from "./protectionPolicy.js";
+function onlyCommentsChangedBy(original, submitted, authorId, {
+  editableComments = "own",
+  xmlParser
+} = {}) {
+  return verifyChange(commentsPolicy, original, submitted, authorId, {
+    editableComments,
+    xmlParser
   });
-  const ids = new Set(before.map((entry) => entry.id));
-  const parts = after.filter((entry) => !entry.external);
-  return kept && after.filter((entry) => !ids.has(entry.id)).every(
-    (entry) => COMMENT_REL_TYPES.includes(entry.type) && !entry.external && parts.filter((other) => other.type === entry.type).length === 1
-  );
-}
-function contentTypes(bytes) {
-  if (bytes === void 0) return /* @__PURE__ */ new Map();
-  const declared = /* @__PURE__ */ new Map();
-  for (const el of elementChildren(
-    parseXml(decodeUtf8(bytes).text).documentElement
-  )) {
-    const key = el.localName === "Default" ? el.getAttribute("Extension") : el.localName === "Override" ? el.getAttribute("PartName") : null;
-    if (key !== null) declared.set(key, el.getAttribute("ContentType") ?? "");
-  }
-  return declared;
-}
-function contentTypesKept(before, after) {
-  for (const [key, type] of before) {
-    if (after.get(key) !== type) return false;
-  }
-  for (const [key, type] of after) {
-    if (!before.has(key) && !COMMENT_CONTENT_TYPES.includes(type)) return false;
-  }
-  return true;
-}
-function gainedCommentPartsAreNew(before, after) {
-  const had = commentPartsOf(before);
-  return commentPartsOf(after).every(
-    (path, kind) => path === null || path === had[kind] || !before.parts.has(path)
-  );
-}
-function packageKept(before, after) {
-  if (before.mainPartPath !== after.mainPartPath) {
-    return { ok: false, reason: "part-changed", part: before.mainPartPath };
-  }
-  const relsPath = relsPathOf(before.mainPartPath);
-  const untouched = /* @__PURE__ */ new Set([
-    before.mainPartPath,
-    relsPath,
-    CONTENT_TYPES_PATH,
-    ...commentPartPaths(before),
-    ...commentPartPaths(after)
-  ]);
-  for (const path of /* @__PURE__ */ new Set([...before.parts.keys(), ...after.parts.keys()])) {
-    if (untouched.has(path)) continue;
-    const was = before.parts.get(path);
-    const now = after.parts.get(path);
-    if (was === void 0 || now === void 0 || !sameBytes(was, now)) {
-      return { ok: false, reason: "part-changed", part: path };
-    }
-  }
-  if (!relationshipsKept(
-    readRelationships(before.parts, relsPath),
-    readRelationships(after.parts, relsPath)
-  ) || !gainedCommentPartsAreNew(before, after)) {
-    return { ok: false, reason: "relationship-changed", part: relsPath };
-  }
-  if (!contentTypesKept(
-    contentTypes(before.parts.get(CONTENT_TYPES_PATH)),
-    contentTypes(after.parts.get(CONTENT_TYPES_PATH))
-  )) {
-    return { ok: false, reason: "part-changed", part: CONTENT_TYPES_PATH };
-  }
-  if (aroundTheStory(before) !== aroundTheStory(after)) {
-    return { ok: false, reason: "part-changed", part: before.mainPartPath };
-  }
-  return { ok: true };
-}
-function sameBody(before, after) {
-  const was = comparableStory(before, withoutComments);
-  const now = comparableStory(after, withoutComments);
-  return was !== null && now !== null && was.length === now.length && was.every((block, at) => block === now[at]);
-}
-function storyKept(before, after, authorId, editableComments) {
-  if (!sameBody(before, after)) return refused("body-changed");
-  if (!commentIdentitiesKept(before.doc, after.doc) || !commentAdditionsBy(before.doc, after.doc, authorId)) {
-    return refused("comment-author-forged");
-  }
-  if (!commentEditsOwned(before.doc, after.doc, {
-    protection: "comments",
-    authorId,
-    editableComments
-  })) {
-    return refused("comment-not-owned");
-  }
-  return { ok: true };
-}
-function onlyCommentsChangedBy(original, submitted, authorId, { editableComments = "own" } = {}) {
-  const before = importDocx(original);
-  const after = importDocx(submitted);
-  const packaged = packageKept(before.session, after.session);
-  if (!packaged.ok) return packaged;
-  const story = storyKept(before, after, authorId, editableComments);
-  return story.ok ? commentPartsKept(before, after, authorId, editableComments) : story;
 }
 export {
   onlyCommentsChangedBy

package/dist/docx/comments/constants.d.ts

@@ -2,7 +2,6 @@ export declare const COMMENTS_REL_TYPE = "http://schemas.openxmlformats.org/offi
 export declare const COMMENTS_EXTENDED_REL_TYPE = "http://schemas.microsoft.com/office/2011/relationships/commentsExtended";
 export declare const COMMENTS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml";
 export declare const COMMENTS_EXTENDED_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml";
-export declare const CONTENT_TYPES_PATH = "[Content_Types].xml";
 export declare const W14_NS: "http://schemas.microsoft.com/office/word/2010/wordml";
 export declare const W15_NS: "http://schemas.microsoft.com/office/word/2012/wordml";
 export declare const MC_NS: "http://schemas.openxmlformats.org/markup-compatibility/2006";

package/dist/docx/comments/constants.js

@@ -5,7 +5,6 @@ var COMMENTS_REL_TYPE = `${R_NS}/comments`;
 var COMMENTS_EXTENDED_REL_TYPE = "http://schemas.microsoft.com/office/2011/relationships/commentsExtended";
 var COMMENTS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml";
 var COMMENTS_EXTENDED_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.commentsExtended+xml";
-var CONTENT_TYPES_PATH = "[Content_Types].xml";
 var W14_NS = NAMESPACES.w14;
 var W15_NS = NAMESPACES.w15;
 var MC_NS = NAMESPACES.mc;
@@ -18,7 +17,6 @@ export {
   COMMENTS_EXTENDED_REL_TYPE,
   COMMENTS_REL_TYPE,
   COMMENT_AUTHOR_PROVIDER,
-  CONTENT_TYPES_PATH,
   MC_NS,
   PEOPLE_CONTENT_TYPE,
   PEOPLE_REL_TYPE,

package/dist/docx/comments/grammar.d.ts

@@ -14,11 +14,17 @@ export declare const COMMENT_ATTRIBUTES: ReadonlySet<string>;
 /** The attributes this editor writes on a `w15:commentEx` */
 export declare const COMMENT_EX_ATTRIBUTES: ReadonlySet<string>;
 /**
- * Whether the element carries no attribute outside this set.
+ * Whether the namespace declaration is one this editor's writer puts out, its value included.
  *
- * A namespace declaration is not an attribute of the element in this sense: it says where the
- * names come from rather than anything about the entry, and where a producer puts one is its own
- * business.
+ * A declaration decides what every name around it means, so one binding a prefix to a namespace
+ * this package does not write is markup the writer did not put there however ordinary the names
+ * under it look. The default declaration is never one of them: the writer spells out a prefix on
+ * everything it writes.
+ */
+export declare function declarationWritten(attr: Attr): boolean;
+/**
+ * Whether the element carries no attribute outside this set, and declares no namespace outside
+ * what the writer declares.
  */
 export declare function attributesWithin(el: Element, allowed: ReadonlySet<string>): boolean;
 /** The body of a comment, as a paragraph of one run holding the text and the breaks in it */

package/dist/docx/comments/grammar.js

@@ -4,7 +4,7 @@ import {
   elementXml,
   xmlnsAttr
 } from "../../ooxml/element.js";
-import { qualify, wName } from "../../ooxml/names.js";
+import { NAMESPACES, qualify, wName } from "../../ooxml/names.js";
 import {
   attributeByLocalName,
   elementChildren,
@@ -48,9 +48,18 @@ function threadKeyOrNone(el, localName) {
   const value = attributeByLocalName(el, localName);
   return value === null || THREAD_KEY.test(value);
 }
+var WRITTEN_NAMESPACES = /* @__PURE__ */ new Map([
+  ["w", NAMESPACES.w],
+  ["w14", NAMESPACES.w14],
+  ["w15", NAMESPACES.w15]
+]);
+function declarationWritten(attr) {
+  if (!attr.name.startsWith("xmlns:")) return false;
+  return WRITTEN_NAMESPACES.get(attr.name.slice("xmlns:".length)) === attr.value;
+}
 function attributesWithin(el, allowed) {
   return Array.from(el.attributes).every(
-    (attr) => attr.namespaceURI === XMLNS_NS || attr.name === "xmlns" || allowed.has(nameKey(attr.namespaceURI, attr.localName))
+    (attr) => attr.namespaceURI === XMLNS_NS ? declarationWritten(attr) : allowed.has(nameKey(attr.namespaceURI, attr.localName))
   );
 }
 function isNamed(el, namespace, localName) {
@@ -201,6 +210,7 @@ export {
   COMMENT_EX_ATTRIBUTES,
   arrivedEntries,
   attributesWithin,
+  declarationWritten,
   lastBodyParagraph,
   readStrictCommentBody,
   recordedIdentity,

package/dist/docx/comments/{verifying.d.ts → parts.d.ts}

@@ -1,18 +1,18 @@
 /**
- * Whether every entry of the three comment parts is one this editor wrote, for an author who was
- * in a position to write it.
+ * The three parts a comment is written across, each declared once: where it sits, what it is
+ * declared as in the package, what an entry in it looks like, and who may have written one.
  *
- * The parts a comment is written across are the ones a submission may rewrite, so the package
- * comparison (`../commentOnlyChange`) leaves their bytes alone. Something has to read them, or a
- * file could carry anything at all inside a comment and still be answered as unchanged. What that
- * reading holds an entry to is two separate questions. Grammar asks whether this editor's writer
+ * The writer named the relationship and the content type where it added a part and the verifier
+ * named them again where it excused one, so the two were free to drift apart. Both read this
+ * instead, which is what makes a part the editor writes a part it takes back.
+ *
+ * What an entry is held to is two separate questions. Grammar asks whether this editor's writer
  * could have put the entry out, whoever it belongs to. Permission asks whether this author could
  * have made the change. Asking them as one would refuse a moderator rewriting somebody else's
  * comment under `editableComments: "all"`, which is a thing the editor lets them do.
  */
 import type { EditableComments } from "../../schema/protection";
-import type { CommentOnlyVerdict } from "../commentOnlyChange";
-import type { Story } from "../storyProjection";
+import type { StoryPartKind } from "../protectionPolicy";
 import { type ImportedPeople } from "./people";
 /**
  * Whether this editor's writer could have put the entry out, whoever it belongs to.
@@ -21,6 +21,15 @@ import { type ImportedPeople } from "./people";
  * `entryAllowed`'s question. Each kind is read where it is written (`./grammar`).
  */
 export declare function wellFormedEntry(entry: Element): boolean;
+/**
+ * Whether the only thing between the two is that a thread gained its key.
+ *
+ * Settling a thread or replying to it belongs to everyone and leaves what the comment says alone,
+ * and the writer answers by putting the key on the entry that arrived rather than writing one of
+ * its own (`./grammar`). Such an entry is not a rewrite, so it is neither held to the grammar this
+ * editor writes bodies in nor to who owns the comment.
+ */
+export declare function threadKeyAlone(entry: Element, original: Element): boolean;
 /**
  * Whether `authorId` could have written or rewritten this entry.
  *
@@ -32,13 +41,12 @@ export declare function wellFormedEntry(entry: Element): boolean;
  * have to answer alike or a file the editor wrote would be turned down here.
  */
 export declare function entryAllowed(entry: Element, original: Element | null, authorId: string, editableComments: EditableComments, people: ImportedPeople): boolean;
-/**
- * Whether the three comment parts came back holding only entries this editor writes, each of them
- * one this author was in a position to write.
- *
- * This runs after the story has been judged, so a comment rewritten, re-anchored or deleted by the
- * wrong hand is already named for what it is (`../commentOnlyChange`). What is left to this is
- * everything the story cannot show: markup forged into a body, an entry nothing refers to, an
- * identity recorded for somebody else.
- */
-export declare function commentPartsKept(before: Story, after: Story, authorId: string, editableComments: EditableComments): CommentOnlyVerdict;
+export declare const commentsPart: StoryPartKind;
+export declare const commentsExtendedPart: StoryPartKind;
+export declare const peoplePart: StoryPartKind;
+/** The parts a comment protection lets an edit rewrite, in the order an export writes them */
+export declare const COMMENT_STORY_PARTS: readonly [
+    StoryPartKind,
+    StoryPartKind,
+    StoryPartKind
+];

package/dist/docx/comments/parts.js

@@ -0,0 +1,279 @@
+// src/docx/comments/parts.ts
+import { NAMESPACES } from "../../ooxml/names.js";
+import {
+  attributeByLocalName,
+  isElement,
+  parseXml,
+  serializeXml,
+  W_NS
+} from "../../ooxml/xml.js";
+import { availablePartPath } from "../packageParts.js";
+import {
+  COMMENTS_CONTENT_TYPE,
+  COMMENTS_EXTENDED_CONTENT_TYPE,
+  COMMENTS_EXTENDED_REL_TYPE,
+  COMMENTS_REL_TYPE,
+  PEOPLE_CONTENT_TYPE,
+  PEOPLE_REL_TYPE,
+  W14_NS,
+  W15_NS
+} from "./constants.js";
+import {
+  attributesWithin,
+  COMMENT_ATTRIBUTES,
+  declarationWritten,
+  lastBodyParagraph,
+  readStrictCommentBody,
+  recordedIdentity,
+  wellFormedCommentExtension,
+  wellFormedPerson
+} from "./grammar.js";
+import { commentReferencesIn } from "./model.js";
+import { commentAuthorId } from "./people.js";
+import { lastParagraphId } from "./reading.js";
+var COMMENT_IDENTITY = [
+  "id",
+  "author",
+  "date",
+  "initials"
+];
+function sameAttributes(entry, original, names) {
+  return names.every(
+    (name) => attributeByLocalName(entry, name) === attributeByLocalName(original, name)
+  );
+}
+function wellFormedEntry(entry) {
+  if (entry.namespaceURI === W_NS && entry.localName === "comment") {
+    return attributesWithin(entry, COMMENT_ATTRIBUTES) && readStrictCommentBody(entry) !== null;
+  }
+  if (entry.namespaceURI === W15_NS && entry.localName === "commentEx") {
+    return wellFormedCommentExtension(entry);
+  }
+  if (entry.namespaceURI === W15_NS && entry.localName === "person") {
+    return wellFormedPerson(entry);
+  }
+  return false;
+}
+function withoutThreadKey(entry) {
+  const copy = entry.cloneNode(true);
+  if (!isElement(copy)) return serializeXml(entry);
+  const last = lastBodyParagraph(copy);
+  last?.removeAttributeNS(W14_NS, "paraId");
+  return serializeXml(copy);
+}
+function threadKeyAlone(entry, original) {
+  const before = lastParagraphId(original);
+  const after = lastParagraphId(entry);
+  const kept = before === null || after === before;
+  return kept && withoutThreadKey(entry) === withoutThreadKey(original);
+}
+function entryAllowed(entry, original, authorId, editableComments, people) {
+  if (entry.namespaceURI === W_NS && entry.localName === "comment") {
+    const author = attributeByLocalName(entry, "author");
+    const recorded = author === null ? null : commentAuthorId(people, author);
+    if (original === null) return recorded === authorId;
+    const paraId = lastParagraphId(original);
+    if (!sameAttributes(entry, original, COMMENT_IDENTITY) || paraId !== null && lastParagraphId(entry) !== paraId) {
+      return false;
+    }
+    return editableComments === "all" || recorded === null || recorded === authorId;
+  }
+  if (entry.namespaceURI === W15_NS && entry.localName === "commentEx") {
+    if (original === null) return true;
+    return sameAttributes(entry, original, ["paraId", "paraIdParent"]);
+  }
+  if (entry.namespaceURI === W15_NS && entry.localName === "person") {
+    return original === null && recordedIdentity(entry) === authorId;
+  }
+  return false;
+}
+var TEXT_NODE = 3;
+var COMPATIBILITY = /* @__PURE__ */ new Map([
+  ["xmlns:w14", NAMESPACES.w14],
+  ["xmlns:mc", NAMESPACES.mc]
+]);
+var IGNORABLE = "mc:Ignorable";
+var IGNORED = "w14";
+function isLayout(node) {
+  return node.nodeType === TEXT_NODE && /^[ \t\r\n]*$/.test(node.nodeValue ?? "");
+}
+function surroundingNodes(parent) {
+  return parent === null ? [] : Array.from(parent.childNodes).filter(
+    (node) => !isElement(node) && !isLayout(node)
+  );
+}
+function sameNodes(now, was) {
+  return now.length === was.length && now.every((node, at) => {
+    const original = was[at];
+    return node.nodeType === original.nodeType && node.nodeName === original.nodeName && node.nodeValue === original.nodeValue;
+  });
+}
+function interEntryContentKept(now, was, rewritesContents) {
+  const current = surroundingNodes(now);
+  if (sameNodes(current, surroundingNodes(was))) return true;
+  return rewritesContents && current.length === 0 && was !== null && Array.from(now.children, serializeXml).join("") !== Array.from(was.children, serializeXml).join("");
+}
+function ignorableTokens(value) {
+  return new Set(value.split(/\s+/).filter(Boolean));
+}
+function ignorableKept(now, was) {
+  const gained = ignorableTokens(now);
+  const had = was === null ? /* @__PURE__ */ new Set() : ignorableTokens(was);
+  return Array.from(had).every((token) => gained.has(token)) && Array.from(gained).every((token) => had.has(token) || token === IGNORED);
+}
+function writtenRoot(root, shape) {
+  if (root.namespaceURI !== shape.namespace) return false;
+  if (root.localName !== shape.rootName) return false;
+  return Array.from(root.attributes).every(
+    (attr) => attr.name === IGNORABLE ? ignorableKept(attr.value, null) : declarationWritten(attr) || COMPATIBILITY.get(attr.name) === attr.value
+  );
+}
+function rootKeptAgainst(now, was, shape) {
+  if (was === null) return writtenRoot(now, shape);
+  if (now.nodeName !== was.nodeName) return false;
+  const had = new Map(
+    Array.from(was.attributes, (attr) => [attr.name, attr.value])
+  );
+  const kept = Array.from(now.attributes).every((attr) => {
+    const before = had.get(attr.name) ?? null;
+    if (attr.name === IGNORABLE) return ignorableKept(attr.value, before);
+    if (before === null) return COMPATIBILITY.get(attr.name) === attr.value;
+    return before === attr.value;
+  });
+  return kept && Array.from(had.keys()).every((name) => now.hasAttribute(name));
+}
+function entriesOf(shape, xml, reading) {
+  const entries = /* @__PURE__ */ new Map();
+  if (xml === null) return entries;
+  const strict = reading === "submitted";
+  for (const node of Array.from(parseXml(xml).documentElement.childNodes)) {
+    if (!isElement(node)) continue;
+    const el = node;
+    const named = strict ? el.namespaceURI === shape.namespace && el.localName === shape.localName : el.localName === shape.localName;
+    if (!named) {
+      if (strict) return null;
+      continue;
+    }
+    const id = attributeByLocalName(el, shape.idAttr);
+    if (id === null || entries.has(id)) {
+      if (strict) return null;
+      continue;
+    }
+    entries.set(id, { el, xml: serializeXml(el) });
+  }
+  return entries;
+}
+function arrivedIn(shape, session) {
+  return entriesOf(shape, shape.xmlIn(session), "arrived") ?? /* @__PURE__ */ new Map();
+}
+function storyPart(shape) {
+  return {
+    relType: shape.relType,
+    contentType: shape.contentType,
+    pathIn: shape.pathIn,
+    writePathIn: (session) => shape.pathIn(session) ?? availablePartPath(session.parts, session.mainPartPath, shape.baseName),
+    entriesIn: (session, reading) => entriesOf(shape, shape.xmlIn(session), reading),
+    rootKept: (before, after) => {
+      const submitted = shape.xmlIn(after);
+      if (submitted === null) return true;
+      const arrived = shape.xmlIn(before);
+      const now = parseXml(submitted);
+      const was = arrived === null ? null : parseXml(arrived);
+      return rootKeptAgainst(
+        now.documentElement,
+        was?.documentElement ?? null,
+        shape
+      ) && sameNodes(surroundingNodes(now), surroundingNodes(was)) && interEntryContentKept(
+        now.documentElement,
+        was?.documentElement ?? null,
+        shape.rewritesContents
+      );
+    },
+    referents: shape.referents,
+    wellFormed: wellFormedEntry,
+    anyonesChange: threadKeyAlone,
+    allowed: (entry, original, authorId, options, session) => entryAllowed(
+      entry,
+      original,
+      authorId,
+      options.editableComments,
+      session.comments.people
+    )
+  };
+}
+function referencedCommentIds(doc) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const [id, comment] of commentReferencesIn(doc)) {
+    ids.add(id);
+    for (const reply of comment.replies) ids.add(reply.id);
+  }
+  return ids;
+}
+var commentsShape = {
+  relType: COMMENTS_REL_TYPE,
+  contentType: COMMENTS_CONTENT_TYPE,
+  baseName: "comments",
+  namespace: W_NS,
+  rootName: "comments",
+  rewritesContents: true,
+  localName: "comment",
+  idAttr: "id",
+  xmlIn: (session) => session.comments.xml,
+  pathIn: (session) => session.comments.partPath,
+  referents: (story) => referencedCommentIds(story.doc)
+};
+function commentEntries(story) {
+  return Array.from(
+    arrivedIn(commentsShape, story.session).values(),
+    (entry) => entry.el
+  );
+}
+var commentsPart = storyPart(commentsShape);
+var commentsExtendedPart = storyPart({
+  relType: COMMENTS_EXTENDED_REL_TYPE,
+  contentType: COMMENTS_EXTENDED_CONTENT_TYPE,
+  baseName: "commentsExtended",
+  namespace: W15_NS,
+  rootName: "commentsEx",
+  rewritesContents: true,
+  localName: "commentEx",
+  idAttr: "paraId",
+  xmlIn: (session) => session.comments.extendedXml,
+  pathIn: (session) => session.comments.extendedPartPath,
+  // Thread state stands for a comment, and it is keyed by the comment's own thread key
+  referents: (story) => new Set(
+    commentEntries(story).flatMap((el) => {
+      const key = lastParagraphId(el);
+      return key === null ? [] : [key];
+    })
+  )
+});
+var peoplePart = storyPart({
+  relType: PEOPLE_REL_TYPE,
+  contentType: PEOPLE_CONTENT_TYPE,
+  baseName: "people",
+  namespace: W15_NS,
+  rootName: "people",
+  rewritesContents: false,
+  localName: "person",
+  idAttr: "author",
+  xmlIn: (session) => session.comments.people.xml,
+  pathIn: (session) => session.comments.people.partPath,
+  // An identity stands for a name somebody writes comments under
+  referents: (story) => new Set(
+    commentEntries(story).flatMap((el) => {
+      const author = attributeByLocalName(el, "author");
+      return author === null ? [] : [author];
+    })
+  )
+});
+var COMMENT_STORY_PARTS = [commentsPart, commentsExtendedPart, peoplePart];
+export {
+  COMMENT_STORY_PARTS,
+  commentsExtendedPart,
+  commentsPart,
+  entryAllowed,
+  peoplePart,
+  threadKeyAlone,
+  wellFormedEntry
+};

package/dist/docx/comments/people.d.ts

@@ -9,7 +9,8 @@
  * it stands and never appended to. Appending a second person for it would leave a file naming two
  * identities for one name, where a reader keying by name hands one author's comments to the other.
  */
-import { type RelationshipWriter } from "../relationships";
+import type { PartPlanContext } from "../partPlan";
+import type { StoryPartKind } from "../protectionPolicy";
 import type { SessionStore } from "../session";
 import type { CommentReferenceData, CommentReplyData } from "./model";
 export interface ImportedPeople {
@@ -31,9 +32,17 @@ export declare function readPeople(parts: Map<string, Uint8Array>, mainPartPath:
  * record, and for one the part records under more than one identity.
  */
 export declare function commentAuthorId(people: ImportedPeople, author: string): string | null;
+/**
+ * The authors the part records no person for at all, each under the name they write as. A name it
+ * already records is left as it stands, whichever provider recorded it and whatever it resolves to.
+ */
+export declare function unrecordedAuthors(bodies: Iterable<CommentReferenceData | CommentReplyData>, people: ImportedPeople): Map<string, string>;
 /**
  * Plans the people part, its relationship and its content type for every identity the current
  * comments carry that the document has not recorded. Null when it has recorded them all, which
  * leaves the part as it arrived.
+ *
+ * `part` is the description the verifier reads the part back through (`./parts`), so where this
+ * writes it and what it declares it as are the same facts on both sides.
  */
-export declare function planPeoplePart(bodies: Iterable<CommentReferenceData | CommentReplyData>, session: SessionStore, relationships: RelationshipWriter, currentContentTypes: Uint8Array | undefined): ReadonlyMap<string, Uint8Array> | null;
+export declare function planPeoplePart(part: StoryPartKind, bodies: Iterable<CommentReferenceData | CommentReplyData>, session: SessionStore, context: PartPlanContext): ReadonlyMap<string, Uint8Array> | null;