@portone/docx-editor 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @portone/docx-editor
 
+## 0.2.0
+
+### Minor Changes
+
+- [#45](https://github.com/portone-io/docx-editor/pull/45) [`3190a35`](https://github.com/portone-io/docx-editor/commit/3190a359e0686bdc14166e22b1d96c761dabe251) Thanks [@Deea222](https://github.com/Deea222)! - Add a `comment` mode and record who wrote each comment.
+  
+  **Breaking:** `mode` is now required and the `commentAuthor` prop is removed.
+  `author: { id, name, initials? }` moves into `mode` for its `comment` and `edit` kinds.
+  `contextMenus` moves off `mode` onto `DocxEditor` itself, so `mode: { kind: "edit", contextMenus: false }` becomes `contextMenus={false}`.
+  
+  In `comment` mode the text can be selected and copied but not changed, while comments can be written, answered, resolved, and reopened.
+  A comment records its author's identity in the document, so two authors sharing a display name stay distinct.
+  Only a comment's author may edit or delete it, and anyone may reply, resolve, and reopen.
+  `mode.editableComments: "all"` opens every comment to a moderator.
+  The `canEditComment` and `editingProtection` queries report what the current mode allows.
+  A server can check a file coming back with `onlyCommentsChangedBy` from `@portone/docx-editor/core`, which answers `{ ok: true }` or `{ ok: false, reason }` for whether the file differs in nothing but one author's comments.
+
 ## 0.1.1
 
 ### Patch Changes

package/README.md

@@ -18,21 +18,33 @@ import "@portone/docx-editor/styles.css";
 import { DocxEditor, type DocxEditorHandle } from "@portone/docx-editor";
 import { useRef } from "react";
 
-export function Editor({ file }: { file: File }) {
+export function Editor({
+  file,
+  user,
+}: {
+  file: File;
+  user: { id: string; name: string };
+}) {
   const editorRef = useRef<DocxEditorHandle | null>(null);
 
-  return <DocxEditor ref={editorRef} document={file} />;
+  return (
+    <DocxEditor
+      ref={editorRef}
+      document={file}
+      mode={{ kind: "edit", author: { id: user.id, name: user.name } }}
+    />
+  );
 }
 ```
 
-`document` accepts a `File`, `Blob`, `ArrayBuffer`, or `Uint8Array`; use the ref to export the edited document as bytes.
+`document` accepts a `File`, `Blob`, `ArrayBuffer`, or `Uint8Array`; `mode` selects read-only, comment-only, or full editing and names the author new comments are attributed to; use the ref to export the edited document as bytes.
 
 ## What it does
 
-- Provides browser editing with built-in controls, read-only mode, and document locking.
+- Provides browser editing with built-in controls, read-only and comment-only modes, and document locking.
 - Fits the page to the available width by default and lets readers choose a fixed zoom level.
 - Exports edited documents as DOCX bytes or browser downloads.
-- Preserves document structures and package parts across edits.
+- Preserves document structures and package parts across edits, and records who wrote each comment.
 - Reads document styles, theme fonts, page layout, and CJK font information for display.
 
 See [Feature support](https://docx-editor.portone.io/docs/features) for the support matrix. Build [custom controls](https://docx-editor.portone.io/docs/custom-controls) or use [programmatic DOCX import and export](https://docx-editor.portone.io/docs/core).

package/dist/DocxEditor.d.ts

@@ -13,6 +13,7 @@ import { type CSSProperties, type ReactNode } from "react";
 import { type DocxSource } from "./docx/importDocx";
 import { type CommentAuthor } from "./editor/commands/commentCommands";
 import { DocxImportError } from "./ooxml/errors";
+import type { EditableComments } from "./schema/protection";
 import type { FontFallbacks } from "./styles/fontStack";
 import type { DocxEditorPresets } from "./ui/presets";
 import { type DocxEditorZoom } from "./ui/zoom";
@@ -24,22 +25,37 @@ export interface DocxEditorHandle {
 /**
  * What the editor is for, which decides what it offers.
  *
- * A read-only editor takes no edits, so it has no toolbar and no right click menus either: what
- * used to be three booleans of which one silently emptied the other two is one choice here.
+ * The three kinds are the standings OOXML document protection names (`ST_DocProtect`) and the
+ * ones a shared document gives its readers: a reader, a commenter, an editor. A read-only editor
+ * takes no edits, so it has no toolbar and no right click menus either: what used to be three
+ * booleans of which one silently emptied the other two is one choice here. A `comment` editor is
+ * the `comments` protection - the body may not be changed, comments may be written, answered and
+ * settled - which is what a reviewer who must not touch the text is handed. Both kinds that write
+ * comments name whose they are, so a reader is never asked for an identity it has no use for.
+ *
+ * `editableComments` is whose comments the panel offers to edit or delete: one's own, which is a
+ * comment carrying no recognised identity or the very identity given here, or every one, which
+ * is a moderator's standing. Replying and resolving are open to every commenter either way.
+ *
  * `locking` is what a screen where a template is written gets: settling a part of a document is
  * an authoring act, not something every reader of a form should be handed. A lock the document
  * already carries holds whichever mode is chosen.
  *
- * `contextMenus: false` leaves the right click to the browser, for a consumer drawing menus of
- * its own. The plugins that take the browser's menu away go into the editor state, which is built
- * when the editor mounts, so this is read once there like `plugins`.
+ * The kind, the author and `editableComments` are read on every render and take effect on the
+ * open document. Whether the right click opens the editor's own menus is `contextMenus`, a prop
+ * of its own, since the plugins behind it are read when the editor mounts rather than per render.
  */
 export type DocxEditorMode = {
     kind: "readOnly";
+} | {
+    kind: "comment";
+    author: CommentAuthor;
+    editableComments?: EditableComments;
 } | {
     kind: "edit";
+    author: CommentAuthor;
+    editableComments?: EditableComments;
     toolbar?: boolean;
-    contextMenus?: boolean;
     locking?: boolean;
 };
 export interface DocxEditorProps {
@@ -58,8 +74,8 @@ export interface DocxEditorProps {
      * never silent either way. Hand one in to write the refusal in your own words.
      */
     renderImportError?: (error: DocxImportError) => ReactNode;
-    /** What the editor is for. Editing with the toolbar shown and no locking when none is given */
-    mode?: DocxEditorMode;
+    /** What the editor is for: a reader's, a commenter's or an editor's surface */
+    mode: DocxEditorMode;
     /** Whether to draw approximate page boundaries over the document's own paper. Drawn when read only too */
     showPageGuides?: boolean;
     /**
@@ -96,8 +112,6 @@ export interface DocxEditorProps {
      * takes effect without a remount.
      */
     presets?: DocxEditorPresets;
-    /** The identity written by the built-in comment and reply composers */
-    commentAuthor?: CommentAuthor;
     /**
      * ProseMirror plugins handed in by the consumer, which is how mentions, highlights,
      * autocomplete and the like are added from outside the package.
@@ -110,6 +124,16 @@ export interface DocxEditorProps {
      * `key` and remount.
      */
     plugins?: readonly Plugin[];
+    /**
+     * Whether the right click opens the editor's own menus. `false` leaves it to the browser,
+     * which is what a consumer drawing menus of its own wants. Defaults to `true`.
+     *
+     * Read once, when the editor mounts, like `plugins`: the plugins that take the browser's menu
+     * away go into the editor state, which is built there. A menu the protection has nothing to
+     * offer from stands down by itself, so a mode change needs nothing here. Later changes are
+     * ignored; to turn the menus around, change the `key` and remount.
+     */
+    contextMenus?: boolean;
     className?: string;
     style?: CSSProperties;
     onReady?: (view: EditorView) => void;

package/dist/DocxEditor.js

@@ -15,6 +15,7 @@ import {
 } from "./editor/commands/commentCommands.js";
 import { activeLinkSpan } from "./editor/commands/linkCommands.js";
 import { createEditorState, createEditorView } from "./editor/createEditor.js";
+import { setProtection } from "./editor/plugins/documentProtection.js";
 import { isLinkPanelOpen } from "./editor/plugins/linkPanel.js";
 import { tableMenuAnchor } from "./editor/plugins/tableContextMenu.js";
 import { textMenuAnchor } from "./editor/plugins/textContextMenu.js";
@@ -23,6 +24,7 @@ import { DocxImportError } from "./ooxml/errors.js";
 import { PageGuides } from "./page/PageGuides.js";
 import { A4_PAGE_PIXELS, pagePixels } from "./page/pageLayout.js";
 import { usePageLayout } from "./page/usePageLayout.js";
+import { editingProtection, protectionOf } from "./schema/protectionState.js";
 import { editorClassNames } from "./styles/classNames.js";
 import { CommentsPanel } from "./ui/CommentsPanel.js";
 import { LinkCard } from "./ui/LinkCard.js";
@@ -34,6 +36,38 @@ import { Toolbar } from "./ui/Toolbar.js";
 import { useFitWidthZoom } from "./ui/useFitWidthZoom.js";
 import { normalizeZoom } from "./ui/zoom.js";
 import { jsx, jsxs } from "react/jsx-runtime";
+function affordancesOf(mode) {
+  switch (mode.kind) {
+    case "readOnly":
+      return {
+        protection: "readOnly",
+        author: null,
+        editableComments: "own",
+        toolbar: false,
+        locking: false
+      };
+    case "comment":
+      return {
+        protection: "comments",
+        author: mode.author ?? null,
+        editableComments: mode.editableComments ?? "own",
+        toolbar: false,
+        locking: false
+      };
+    case "edit":
+      return {
+        protection: "none",
+        author: mode.author ?? null,
+        editableComments: mode.editableComments ?? "own",
+        toolbar: mode.toolbar ?? true,
+        locking: mode.locking ?? false
+      };
+    default: {
+      const unmodelled = mode;
+      return unmodelled;
+    }
+  }
+}
 function openDocument(bytes) {
   try {
     const { doc, session } = importDocx(bytes);
@@ -97,32 +131,28 @@ function zoomVariable(factor) {
 function DocxEditorSurface({
   document: source,
   renderImportError,
-  mode = { kind: "edit" },
+  mode,
   showPageGuides = true,
   zoom,
   defaultZoom = "fit-width",
   onZoomChange,
   fontFallbacks,
   presets,
-  commentAuthor = { name: "Anonymous" },
   plugins,
+  contextMenus,
   className,
   style,
   onReady,
   onChange
 }, ref) {
-  const readOnly = mode.kind === "readOnly";
-  const showToolbar = mode.kind === "edit" && (mode.toolbar ?? true);
-  const allowLocking = mode.kind === "edit" && (mode.locking ?? false);
+  const { protection, author, editableComments, toolbar, locking } = affordancesOf(mode);
   const bytes = useDocumentBytes(source);
   const opened = useMemo(
     () => bytes === null ? null : openDocument(bytes),
     [bytes]
   );
   const mountedPlugins = useRef(plugins).current;
-  const mountedContextMenus = useRef(
-    mode.kind !== "edit" || (mode.contextMenus ?? true)
-  ).current;
+  const mountedContextMenus = useRef(contextMenus ?? true).current;
   const mountedFontFallbacks = useRef(fontFallbacks).current;
   const layerRef = useRef(null);
   const rootRef = useRef(null);
@@ -173,11 +203,13 @@ function DocxEditorSurface({
           ...opened.session.comments.extendedOrdered.map(
             (extension) => extension.paraId
           )
-        ]
+        ],
+        protection,
+        author,
+        editableComments
       }),
       defaults: opened.session.defaults,
       geometry: opened.session.geometry,
-      readOnly,
       fontFallbacks: mountedFontFallbacks,
       onStateChange: (state) => {
         keptState.current = { of: opened, state };
@@ -196,19 +228,32 @@ function DocxEditorSurface({
     };
   }, [
     opened,
-    readOnly,
     mountedContextMenus,
     mountedFontFallbacks,
     mountedPlugins,
     latestOnReady,
     latestOnChange
   ]);
+  const authorId = author?.id ?? null;
+  const mounted = live !== null;
+  useLayoutEffect(() => {
+    if (protection === "readOnly") setCommentComposerOpen(false);
+    const view = viewRef.current;
+    if (!view || !mounted) return;
+    const held = protectionOf(view.state);
+    if (held.protection === protection && held.authorId === authorId && held.editableComments === editableComments) {
+      return;
+    }
+    view.dispatch(
+      setProtection(view.state.tr, { protection, author, editableComments })
+    );
+  }, [mounted, protection, authorId, editableComments]);
   useImperativeHandle(ref, () => {
     const view = viewRef.current;
     if (!view || opened?.status !== "opened") return null;
     const session = opened.session;
     return { view, exportBytes: () => exportDocx(view.state.doc, session) };
-  }, [opened, readOnly]);
+  }, [opened]);
   const overlay = usePageLayout({
     view: live?.view ?? null,
     layer: layerRef,
@@ -219,21 +264,22 @@ function DocxEditorSurface({
   if (opened?.status === "rejected") {
     return renderImportError ? renderImportError(opened.error) : /* @__PURE__ */ jsx(ImportRejection, { error: opened.error });
   }
-  const textAnchor = live && !readOnly ? textMenuAnchor(live.state) : null;
-  const tableAnchor = live && !readOnly && !textAnchor ? tableMenuAnchor(live.state) : null;
+  const bodyOpen = live !== null && editingProtection(live.state) === "none";
+  const commentsOpenToWrite = live !== null && editingProtection(live.state) !== "readOnly";
+  const textAnchor = live ? textMenuAnchor(live.state) : null;
+  const tableAnchor = live && !textAnchor ? tableMenuAnchor(live.state) : null;
   const linkAtCursor = live && !live.view.composing && !isLinkPanelOpen(live.state) ? activeLinkSpan(live.state) : null;
   const comments = live?.state === void 0 ? [] : documentComments(live.state);
   const hasUnresolvedComments = comments.some((comment) => !comment.resolved);
-  const effectiveComposerOpen = commentComposerOpen && !readOnly;
+  const effectiveComposerOpen = commentComposerOpen && commentsOpenToWrite;
   const showComments = live !== null && (commentsOpen || effectiveComposerOpen || hasUnresolvedComments);
   const commentsPanel = live && showComments && /* @__PURE__ */ jsx(
     CommentsPanel,
     {
       view: live.view,
       state: live.state,
-      readOnly,
       composerOpen: effectiveComposerOpen,
-      author: commentAuthor,
+      author,
       closeComposer: () => setCommentComposerOpen(false),
       scrollContainer: rootRef.current,
       allCommentsOpen: commentsOpen
@@ -245,7 +291,7 @@ function DocxEditorSurface({
       className: [editorClassNames.frame, className].filter(Boolean).join(" "),
       style,
       children: [
-        live && showToolbar && /* @__PURE__ */ jsx(
+        live && toolbar && /* @__PURE__ */ jsx(
           Toolbar,
           {
             view: live.view,
@@ -270,7 +316,7 @@ function DocxEditorSurface({
             "data-comments": showComments ? "visible" : void 0,
             style: zoomVariable(effectiveZoom),
             children: [
-              live && readOnly && comments.length > 0 && /* @__PURE__ */ jsx(
+              live && !bodyOpen && comments.length > 0 && /* @__PURE__ */ jsx(
                 "button",
                 {
                   type: "button",
@@ -306,14 +352,13 @@ function DocxEditorSurface({
             ]
           }
         ),
-        live && !readOnly && isLinkPanelOpen(live.state) && /* @__PURE__ */ jsx(LinkPanel, { view: live.view, state: live.state }),
+        live && bodyOpen && isLinkPanelOpen(live.state) && /* @__PURE__ */ jsx(LinkPanel, { view: live.view, state: live.state }),
         live && linkAtCursor && /* @__PURE__ */ jsx(
           LinkCard,
           {
             view: live.view,
             state: live.state,
-            link: linkAtCursor,
-            readOnly
+            link: linkAtCursor
           },
           linkAtCursor.from
         ),
@@ -323,7 +368,7 @@ function DocxEditorSurface({
             view: live.view,
             state: live.state,
             anchor: textAnchor,
-            allowLocking,
+            allowLocking: locking,
             onAddComment: () => {
               setCommentComposerOpen(true);
             }
@@ -335,7 +380,7 @@ function DocxEditorSurface({
             view: live.view,
             state: live.state,
             anchor: tableAnchor,
-            allowLocking
+            allowLocking: locking
           }
         )
       ]

package/dist/core.d.ts

@@ -5,6 +5,8 @@
 import type { Node as PMNode } from "prosemirror-model";
 import { type DocxBytes } from "./docx/importDocx";
 import type { DocxSession } from "./docx/session";
+export type { CommentOnlyVerdict } from "./docx/commentOnlyChange";
+export { onlyCommentsChangedBy } from "./docx/commentOnlyChange";
 export { exportDocx } from "./docx/exportDocx";
 export type { ParagraphStyleOption } from "./docx/formatting";
 export type { DocxBytes } from "./docx/importDocx";

package/dist/core.js

@@ -1,5 +1,6 @@
 // src/core.ts
 import { importDocx as openDocx } from "./docx/importDocx.js";
+import { onlyCommentsChangedBy } from "./docx/commentOnlyChange.js";
 import { exportDocx } from "./docx/exportDocx.js";
 import { documentNumbering, documentPartPath } from "./docx/session.js";
 import {
@@ -26,6 +27,7 @@ export {
   emuToPx,
   exportDocx,
   importDocx,
+  onlyCommentsChangedBy,
   parseNumbering,
   pxToEmu,
   toCellFormat,

package/dist/docx/commentOnlyChange.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Whether a file handed back changed in nothing but comments one author is allowed to have made.
+ *
+ * The editor's own refusal under a comment protection (`schema/protection`) is a courtesy to the
+ * user: the browser holds the file, so the rule is held again here, where a server takes it in.
+ * The judgement is over the package rather than over the document alone, since a submission is
+ * free to rewrite anything the story does not carry - the paper the document is written on, its
+ * styles, its headers - and a document comparison would see none of it.
+ */
+import { type EditableComments } from "../schema/protection";
+import { type DocxBytes } from "./importDocx";
+/**
+ * Why a file is not the one it claims to be. `part-changed` and `relationship-changed` name the
+ * part they were reached over; the other three are about the document story itself.
+ */
+export type CommentOnlyVerdict = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "body-changed" | "comment-not-owned" | "comment-author-forged";
+} | {
+    ok: false;
+    reason: "part-changed" | "relationship-changed";
+    part: string;
+};
+/**
+ * Whether the submitted file differs from the original in nothing but comments, every one of them
+ * added, edited, moved, deleted, replied to or settled by the author with this identity.
+ *
+ * Every part of the package has to arrive as it left, save for the three a comment is written
+ * across and the relationship and content type they are declared with; the document story itself
+ * has to read as it did, comments aside. A comment carrying no recorded identity is everyone's to
+ * edit here as it is in the editor (`schema/protection`), while a comment that appeared has to
+ * carry this identity: a file can claim any author, and the editor's own hand in writing it is
+ * not there to vouch for it. An identity already recorded is nobody's to rewrite.
+ *
+ * `editableComments: "all"` judges the file of an editor opened for a moderator, where every
+ * comment was theirs to edit; an identity is nobody's to rewrite under either setting.
+ *
+ * Bytes that are not a readable docx are turned down the way opening one is, with a
+ * `DocxImportError`, rather than being answered as a file that changed.
+ */
+export declare function onlyCommentsChangedBy(original: DocxBytes, submitted: DocxBytes, authorId: string, { editableComments }?: {
+    editableComments?: EditableComments;
+}): CommentOnlyVerdict;

package/dist/docx/commentOnlyChange.js

@@ -0,0 +1,145 @@
+// src/docx/commentOnlyChange.ts
+import { decodeUtf8, elementChildren, parseXml } from "../ooxml/xml.js";
+import {
+  changesOnlyComments,
+  commentAdditionsBy,
+  commentEditsOwned,
+  commentIdentitiesKept
+} 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 { importDocx } from "./importDocx.js";
+import {
+  readRelationships,
+  relsPathOf,
+  resolveTarget
+} from "./relationships.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 commentPartPaths(session) {
+  const related = readRelationships(
+    session.parts,
+    relsPathOf(session.mainPartPath)
+  ).filter(
+    (entry) => !entry.external && COMMENT_REL_TYPES.includes(entry.type)
+  );
+  return new Set(
+    related.map((entry) => resolveTarget(session.mainPartPath, entry.target))
+  );
+}
+function aroundTheStory(session) {
+  const preserved = session.blocks.filter(
+    (block) => block.node.type.name !== "paragraph" && block.node.type.name !== "table"
+  ).map((block) => block.xml).join("");
+  return session.documentPrefix + preserved + session.documentSuffix;
+}
+function relationshipsKept(before, after) {
+  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;
+  });
+  const ids = new Set(before.map((entry) => entry.id));
+  return kept && after.every(
+    (entry) => ids.has(entry.id) || COMMENT_REL_TYPES.includes(entry.type)
+  );
+}
+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 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)
+  )) {
+    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 storyKept(before, after, authorId, editableComments) {
+  if (!changesOnlyComments(before, after)) return refused("body-changed");
+  if (!commentIdentitiesKept(before, after) || !commentAdditionsBy(before, after, authorId)) {
+    return refused("comment-author-forged");
+  }
+  if (!commentEditsOwned(before, after, {
+    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);
+  return packaged.ok ? storyKept(before.doc, after.doc, authorId, editableComments) : packaged;
+}
+export {
+  onlyCommentsChangedBy
+};

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

@@ -6,3 +6,11 @@ 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";
+export declare const PEOPLE_REL_TYPE = "http://schemas.microsoft.com/office/2011/relationships/people";
+export declare const PEOPLE_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.people+xml";
+/**
+ * The `w15:providerId` under which this editor records a comment author's identity. An identity
+ * another provider recorded, Word's directory above all, is one this editor cannot vouch for and
+ * is read as none.
+ */
+export declare const COMMENT_AUTHOR_PROVIDER = "portone-docx-editor";

package/dist/docx/comments/constants.js

@@ -8,13 +8,19 @@ var CONTENT_TYPES_PATH = "[Content_Types].xml";
 var W14_NS = "http://schemas.microsoft.com/office/word/2010/wordml";
 var W15_NS = "http://schemas.microsoft.com/office/word/2012/wordml";
 var MC_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+var PEOPLE_REL_TYPE = "http://schemas.microsoft.com/office/2011/relationships/people";
+var PEOPLE_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.people+xml";
+var COMMENT_AUTHOR_PROVIDER = "portone-docx-editor";
 export {
   COMMENTS_CONTENT_TYPE,
   COMMENTS_EXTENDED_CONTENT_TYPE,
   COMMENTS_EXTENDED_REL_TYPE,
   COMMENTS_REL_TYPE,
+  COMMENT_AUTHOR_PROVIDER,
   CONTENT_TYPES_PATH,
   MC_NS,
+  PEOPLE_CONTENT_TYPE,
+  PEOPLE_REL_TYPE,
   W14_NS,
   W15_NS
 };

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

@@ -0,0 +1,7 @@
+/** Declares a part an export adds in `[Content_Types].xml`, leaving the original text as it came. */
+/**
+ * The content types part with an override for this part, or null when it already declares one.
+ * `current` is the part as an earlier addition in the same export left it, so that two additions
+ * do not each write over the other's declaration.
+ */
+export declare function withContentType(parts: Map<string, Uint8Array>, partPath: string, contentType: string, current: Uint8Array | undefined): Uint8Array | null;