@portone/docx-editor 0.3.0 → 0.5.0

package/dist/editor/clipboard/readers.d.ts

@@ -0,0 +1,33 @@
+import { type ResolvedPos, Slice } from "prosemirror-model";
+import { type PastedContent } from "./htmlReader";
+import type { HtmlReadContext } from "./readContext";
+/** What one reader is handed: the markup on the clipboard, and the document it is read into */
+export interface ClipboardInput {
+    dom: Node;
+    /** The name the markup carries for a slice this editor kept (`./internalChannel`). Null when it carries none */
+    token: string | null;
+    /** The open document the markup is being read into. Null for a state built without one */
+    sessionId: string | null;
+    context: HtmlReadContext;
+}
+/**
+ * One way of reading a clipboard. The chain is tried in order and the first reader to answer
+ * decides what goes in, so a reader that does not recognize what it was handed answers nothing.
+ */
+export type ClipboardReader = (input: ClipboardInput) => PastedContent | null;
+/**
+ * A copy made in this same open document, handed back as the slice it was.
+ *
+ * It leads the chain because it is the only reader that loses nothing: everything below reads
+ * markup, and markup is all a copy from anywhere else amounts to here.
+ */
+export declare const internalSliceReader: ClipboardReader;
+/** Everything the editor did not write itself, read for the formatting the markup states */
+export declare const foreignHtmlReader: ClipboardReader;
+export declare const DEFAULT_READERS: readonly ClipboardReader[];
+/**
+ * Plain text as content of this document: docx has no character for a line break or a tab stop,
+ * so those become the elements it does have, and the rest keeps the formatting in force where it
+ * is put.
+ */
+export declare function plainTextSlice(text: string, $context: ResolvedPos): Slice;

package/dist/editor/clipboard/readers.js

@@ -0,0 +1,37 @@
+// src/editor/clipboard/readers.ts
+import { Fragment, Slice } from "prosemirror-model";
+import { NO_NEW_LISTS } from "../../numbering/listRegistry.js";
+import { docxSchema } from "../../schema/index.js";
+import { toPieces } from "../plainText.js";
+import { readHtml } from "./htmlReader.js";
+import { recallCopied } from "./internalChannel.js";
+var internalSliceReader = ({ token, sessionId }) => {
+  const recalled = recallCopied(token, sessionId);
+  return recalled === null ? null : { ...recalled, newLists: NO_NEW_LISTS };
+};
+var foreignHtmlReader = ({ dom, context }) => dom instanceof Element || dom instanceof DocumentFragment ? readHtml(dom, context) : null;
+var DEFAULT_READERS = [
+  internalSliceReader,
+  foreignHtmlReader
+];
+function plainTextSlice(text, $context) {
+  const marks = $context.marks();
+  const nodes = toPieces(text).map((piece) => {
+    if ("text" in piece) return docxSchema.text(piece.text, marks);
+    if (piece.node === "hardBreak") {
+      return docxSchema.nodes.hardBreak.create(null, null, marks);
+    }
+    const beside = marks.filter((mark) => mark.type !== docxSchema.marks.tab);
+    return docxSchema.text(
+      "	",
+      docxSchema.marks.tab.create().addToSet(beside)
+    );
+  });
+  return nodes.length === 0 ? Slice.empty : new Slice(Fragment.fromArray(nodes), 0, 0);
+}
+export {
+  DEFAULT_READERS,
+  foreignHtmlReader,
+  internalSliceReader,
+  plainTextSlice
+};

package/dist/editor/commands/comments/editing.d.ts

@@ -1,16 +1,30 @@
 /** Edits Word comments through their range markers and reference nodes. */
+import type { Node as PMNode } from "prosemirror-model";
 import { type Command, type EditorState } from "prosemirror-state";
-import type { NewComment } from "./model";
-/** Adds a plain-text comment to the current text selection. */
-export declare function addComment(comment: NewComment): Command;
+import { type CommentRange, type NewComment } from "./model";
 /**
- * Whether a non-empty selection in one paragraph can receive a comment.
+ * Adds a plain-text comment to a stretch of text: the one given, or the current text selection.
+ *
+ * A composer that was opened over one stretch and submitted later names it, so that what the
+ * comment marks is the text it was written about rather than wherever the caret has since gone.
+ */
+export declare function addComment(comment: NewComment, at?: CommentRange): Command;
+/**
+ * Whether that stretch of text, or the current selection, can receive a comment.
  * This is the command itself asked without a dispatch, over a comment standing in for the one the
  * user would write, so the button and the click cannot answer differently.
  */
-export declare function canAddComment(state: EditorState): boolean;
+export declare function canAddComment(state: EditorState, at?: CommentRange): boolean;
 /** Replaces the plain-text body of one comment, retaining its author and anchor. */
 export declare function updateComment(id: string, text: string): Command;
+/**
+ * Replaces the body of one comment with a formatted one, retaining its author and anchor.
+ *
+ * The body is a document of `docxSchema`, the same schema the page is edited in, so a paragraph
+ * style, a bold run and a second paragraph all survive being written, exported and read back.
+ * `updateComment` is the same command for a body that is only text.
+ */
+export declare function setCommentBody(id: string, body: PMNode): Command;
 /** Marks a comment thread resolved or open without deleting it. */
 export declare function setCommentResolved(id: string, resolved: boolean): Command;
 /** Adds a plain-text reply and reopens the thread when it was resolved. */
@@ -19,7 +33,13 @@ export declare function addCommentReply(id: string, reply: NewComment): Command;
 export declare function updateCommentReply(commentId: string, replyId: string, text: string): Command;
 /** Removes one reply while retaining its root comment and anchor. */
 export declare function removeCommentReply(commentId: string, replyId: string): Command;
-/** Removes a comment's range markers, reference and Comments-part entry. */
+/**
+ * Removes a comment's range markers, reference and Comments-part entry.
+ *
+ * What the comment and its replies said goes with them: a body is a story on the document node,
+ * and one left behind for a comment nothing refers to would ride every later comparison of the
+ * document without standing for anything.
+ */
 export declare function removeComment(id: string): Command;
 /** Selects the text anchored by a comment, or places the caret at a point comment. */
 export declare function selectComment(id: string): Command;

package/dist/editor/commands/comments/editing.js

@@ -3,16 +3,39 @@ import {
   TextSelection
 } from "prosemirror-state";
 import { commentParaId } from "../../../docx/comments.js";
+import {
+  sameStory,
+  setStory,
+  storyFromText,
+  storyKey,
+  storyOf,
+  storyText,
+  withoutStories
+} from "../../../docx/story.js";
 import { docxSchema } from "../../../schema/index.js";
 import { guardedCommand } from "../../../schema/guards.js";
 import {
   reservedCommentIds,
   reservedCommentParaIds
 } from "../../editorDocument.js";
-import { documentComments, repliesAttr, stringAttr } from "./reading.js";
-function validCommentSelection(state) {
+import {
+  repliesAttr,
+  stringAttr
+} from "./model.js";
+import { commentById } from "./reading.js";
+function anchorableRange(doc, { from, to }) {
+  if (!Number.isInteger(from) || !Number.isInteger(to) || from >= to || from < 0 || to > doc.content.size)
+    return null;
+  const $from = doc.resolve(from);
+  if (!$from.sameParent(doc.resolve(to))) return null;
+  if ($from.parent.type.name !== "paragraph") return null;
+  return { from, to };
+}
+function commentedRange(state, at) {
+  if (at) return anchorableRange(state.doc, at);
   const { selection } = state;
-  return selection instanceof TextSelection && !selection.empty && selection.$from.sameParent(selection.$to) && selection.$from.parent.type.name === "paragraph";
+  if (!(selection instanceof TextSelection)) return null;
+  return anchorableRange(state.doc, selection);
 }
 function nextCommentId(state) {
   const taken = /* @__PURE__ */ new Set();
@@ -73,14 +96,13 @@ function wrapperMarksAt(state, pos, side) {
     (mark) => mark.type.name === "sdt" || mark.type.name === "link"
   );
 }
-function addCommentTransaction(state, comment) {
-  if (!validCommentSelection(state) || comment.text.trim().length === 0) {
-    return null;
-  }
+function addCommentTransaction(state, comment, at) {
+  const range = commentedRange(state, at);
+  if (range === null || comment.text.trim().length === 0) return null;
   const id = nextCommentId(state);
   const date = comment.date ?? (/* @__PURE__ */ new Date()).toISOString();
   const paraId = nextCommentParaId(state, `comment-${id}-${date}`);
-  const { from, to } = state.selection;
+  const { from, to } = range;
   const startMarks = wrapperMarksAt(state, from, "after");
   const endMarks = wrapperMarksAt(state, to, "before");
   const end = docxSchema.nodes.commentEnd.create(
@@ -96,9 +118,6 @@ function addCommentTransaction(state, comment) {
       authorId: comment.authorId ?? null,
       initials: comment.initials ?? null,
       date,
-      text: comment.text,
-      commentXml: null,
-      imported: false,
       paraId,
       resolved: false,
       extensionXml: null,
@@ -113,39 +132,63 @@ function addCommentTransaction(state, comment) {
     null,
     startMarks
   );
-  return state.tr.insert(to, end).insert(to + 1, reference).insert(from, start);
+  return setStory(
+    state.tr.insert(to, end).insert(to + 1, reference).insert(from, start),
+    storyKey("comment", id),
+    storyFromText(comment.text)
+  );
 }
-function addComment(comment) {
-  return guardedCommand((state) => addCommentTransaction(state, comment));
+function addComment(comment, at) {
+  return guardedCommand((state) => addCommentTransaction(state, comment, at));
 }
-function canAddComment(state) {
-  return addComment({
-    text: "comment",
-    author: "Author",
-    date: "1970-01-01T00:00:00.000Z"
-  })(state);
+function canAddComment(state, at) {
+  return addComment(
+    {
+      text: "comment",
+      author: "Author",
+      date: "1970-01-01T00:00:00.000Z"
+    },
+    at
+  )(state);
 }
-function updateComment(id, text) {
-  return guardedCommand((state) => {
-    if (text.trim().length === 0) return null;
-    let transaction = state.tr;
-    let changed = false;
-    state.doc.descendants((node, pos) => {
-      if (node.type.name === "commentReference" && stringAttr(node.attrs.id) === id && stringAttr(node.attrs.text) !== text) {
-        transaction = transaction.setNodeMarkup(pos, null, {
-          ...node.attrs,
-          text,
-          commentXml: null,
-          imported: false
-        });
-        changed = true;
-      }
-      return true;
-    });
-    return changed ? transaction : null;
+function referenceAt(state, id) {
+  let at = null;
+  state.doc.descendants((node, pos) => {
+    if (at !== null) return false;
+    if (node.type.name === "commentReference" && stringAttr(node.attrs.id) === id) {
+      at = pos;
+    }
+    return at === null;
   });
+  return at;
+}
+function bodyTransaction(state, referenceId, bodyId, body) {
+  if (body.type !== docxSchema.nodes.doc) return null;
+  if (storyText(body).trim().length === 0) return null;
+  const at = referenceAt(state, referenceId);
+  const reference = at === null ? null : state.doc.nodeAt(at);
+  if (at === null || reference === null) return null;
+  const key = storyKey("comment", bodyId);
+  if (sameStory(storyOf(state.doc, key), body)) return null;
+  return setStory(state.tr, key, body).setNodeMarkup(
+    at,
+    null,
+    reference.attrs,
+    reference.marks
+  );
 }
-function updateReference(id, change) {
+function textBodyTransaction(state, referenceId, bodyId, text) {
+  const held = storyOf(state.doc, storyKey("comment", bodyId));
+  if (held !== null && storyText(held) === text) return null;
+  return bodyTransaction(state, referenceId, bodyId, storyFromText(text));
+}
+function updateComment(id, text) {
+  return guardedCommand((state) => textBodyTransaction(state, id, id, text));
+}
+function setCommentBody(id, body) {
+  return guardedCommand((state) => bodyTransaction(state, id, id, body));
+}
+function updateReference(id, change, alongside = (tr) => tr) {
   return guardedCommand((state) => {
     let transaction = state.tr;
     let changed = false;
@@ -160,7 +203,7 @@ function updateReference(id, change) {
       }
       return false;
     });
-    return changed ? transaction : null;
+    return changed ? alongside(transaction) : null;
   });
 }
 function setCommentResolved(id, resolved) {
@@ -179,84 +222,110 @@ function addCommentReply(id, reply) {
     if (reply.text.trim().length === 0) return false;
     const replyId = nextCommentId(state);
     const date = reply.date ?? (/* @__PURE__ */ new Date()).toISOString();
-    return updateReference(id, (node) => {
-      const parentParaId = stringAttr(node.attrs.paraId) ?? nextCommentParaId(state, `comment-${id}`);
-      const paraId = nextCommentParaId(state, `comment-${replyId}-${date}`, [
-        parentParaId
-      ]);
-      return {
-        ...node.attrs,
-        paraId: parentParaId,
-        resolved: false,
-        extensionXml: null,
-        threadImported: false,
-        replies: [
-          ...repliesAttr(node.attrs.replies),
-          {
-            id: replyId,
-            author: reply.author,
-            authorId: reply.authorId ?? null,
-            initials: reply.initials ?? null,
-            date,
-            text: reply.text,
-            commentXml: null,
-            imported: false,
-            paraId,
-            parentParaId,
-            extensionXml: null
-          }
-        ]
-      };
-    })(state, dispatch);
+    return updateReference(
+      id,
+      (node) => {
+        const parentParaId = stringAttr(node.attrs.paraId) ?? nextCommentParaId(state, `comment-${id}`);
+        const paraId = nextCommentParaId(state, `comment-${replyId}-${date}`, [
+          parentParaId
+        ]);
+        return {
+          ...node.attrs,
+          paraId: parentParaId,
+          resolved: false,
+          extensionXml: null,
+          threadImported: false,
+          replies: [
+            ...repliesAttr(node.attrs.replies),
+            {
+              id: replyId,
+              author: reply.author,
+              authorId: reply.authorId ?? null,
+              initials: reply.initials ?? null,
+              date,
+              paraId,
+              parentParaId,
+              extensionXml: null
+            }
+          ]
+        };
+      },
+      (tr) => setStory(tr, storyKey("comment", replyId), storyFromText(reply.text))
+    )(state, dispatch);
   };
 }
 function updateCommentReply(commentId, replyId, text) {
-  return updateReference(commentId, (node) => {
-    if (text.trim().length === 0) return null;
-    const replies = repliesAttr(node.attrs.replies);
-    const index = replies.findIndex((reply) => reply.id === replyId);
-    if (index < 0 || replies[index].text === text) return null;
-    return {
-      ...node.attrs,
-      replies: replies.map(
-        (reply, at) => at === index ? { ...reply, text, commentXml: null, imported: false } : reply
-      )
-    };
+  return guardedCommand((state) => {
+    const holdsReply = repliesOf(state, commentId).some(
+      (reply) => reply.id === replyId
+    );
+    if (!holdsReply) return null;
+    return textBodyTransaction(state, commentId, replyId, text);
   });
 }
-function removeCommentReply(commentId, replyId) {
-  return updateReference(commentId, (node) => {
-    const replies = repliesAttr(node.attrs.replies);
-    if (!replies.some((reply) => reply.id === replyId)) return null;
-    const removedIds = /* @__PURE__ */ new Set([replyId]);
-    const removedParaIds = new Set(
-      replies.filter((reply) => removedIds.has(reply.id)).map((reply) => reply.paraId)
-    );
-    let changed = true;
-    while (changed) {
-      changed = false;
-      for (const reply of replies) {
-        if (!removedIds.has(reply.id) && removedParaIds.has(reply.parentParaId)) {
-          removedIds.add(reply.id);
-          removedParaIds.add(reply.paraId);
-          changed = true;
-        }
-      }
+function repliesOf(state, commentId) {
+  let replies = [];
+  state.doc.descendants((node) => {
+    if (node.type.name !== "commentReference" || stringAttr(node.attrs.id) !== commentId) {
+      return true;
     }
-    return {
-      ...node.attrs,
-      replies: replies.filter((reply) => !removedIds.has(reply.id)),
-      threadImported: false
-    };
+    replies = repliesAttr(node.attrs.replies);
+    return false;
   });
+  return replies;
+}
+function dropBodies(ids) {
+  return (tr) => withoutStories(
+    tr,
+    Array.from(ids, (id) => storyKey("comment", id))
+  );
+}
+function removeCommentReply(commentId, replyId) {
+  return (state, dispatch) => {
+    const removedReplyIds = /* @__PURE__ */ new Set();
+    return updateReference(
+      commentId,
+      (node) => {
+        const replies = repliesAttr(node.attrs.replies);
+        if (!replies.some((reply) => reply.id === replyId)) return null;
+        const removedIds = /* @__PURE__ */ new Set([replyId]);
+        const removedParaIds = new Set(
+          replies.filter((reply) => removedIds.has(reply.id)).map((reply) => reply.paraId)
+        );
+        let changed = true;
+        while (changed) {
+          changed = false;
+          for (const reply of replies) {
+            if (!removedIds.has(reply.id) && removedParaIds.has(reply.parentParaId)) {
+              removedIds.add(reply.id);
+              removedParaIds.add(reply.paraId);
+              changed = true;
+            }
+          }
+        }
+        for (const id of removedIds) removedReplyIds.add(id);
+        return {
+          ...node.attrs,
+          replies: replies.filter((reply) => !removedIds.has(reply.id)),
+          threadImported: false
+        };
+      },
+      dropBodies(removedReplyIds)
+    )(state, dispatch);
+  };
 }
 function removeComment(id) {
   return guardedCommand((state) => {
     const positions = [];
+    const bodies = /* @__PURE__ */ new Set([id]);
     state.doc.descendants((node, pos) => {
       if ((node.type.name === "commentStart" || node.type.name === "commentEnd" || node.type.name === "commentReference") && stringAttr(node.attrs.id) === id) {
         positions.push({ pos, size: node.nodeSize });
       }
+      if (node.type.name === "commentReference" && stringAttr(node.attrs.id) === id) {
+        for (const reply of repliesAttr(node.attrs.replies))
+          bodies.add(reply.id);
+      }
       return true;
     });
     if (positions.length === 0) return null;
@@ -264,12 +333,12 @@ function removeComment(id) {
     for (const marker of positions.sort((a, b) => b.pos - a.pos)) {
       transaction.delete(marker.pos, marker.pos + marker.size);
     }
-    return transaction;
+    return dropBodies(bodies)(transaction);
   });
 }
 function selectComment(id) {
   return (state, dispatch) => {
-    const comment = documentComments(state).find((entry) => entry.id === id);
+    const comment = commentById(state, id);
     if (!comment) return false;
     dispatch?.(
       state.tr.setSelection(
@@ -286,6 +355,7 @@ export {
   removeComment,
   removeCommentReply,
   selectComment,
+  setCommentBody,
   setCommentResolved,
   updateComment,
   updateCommentReply

package/dist/editor/commands/comments/model.d.ts

@@ -1,4 +1,6 @@
 /** Public comment values and shared attribute readers. */
+import type { CommentReplyData } from "../../../docx/comments";
+/** Who a comment is written by: the name it is shown under, and the identity behind it. */
 export interface CommentAuthor {
     /**
      * The identity behind the name, an opaque string the host application chooses. Recorded in the
@@ -8,6 +10,14 @@ export interface CommentAuthor {
     name: string;
     initials?: string;
 }
+/**
+ * A stretch of text a comment is written for: a pair of document positions, the way a comment
+ * already in the document reports its own (`DocumentComment.from`, `.to`).
+ */
+export interface CommentRange {
+    from: number;
+    to: number;
+}
 export interface NewComment {
     text: string;
     author: string;
@@ -17,24 +27,31 @@ export interface NewComment {
     /** ISO 8601 timestamp. The current time is used when omitted. */
     date?: string;
 }
+/**
+ * One comment as a reader of the document sees it. Every field is readonly: the record is the
+ * editor's own, worked out once per edit and handed to whoever asks (`editor/plugins/documentProjection`).
+ */
 export interface DocumentComment {
-    id: string;
-    author: string | null;
-    authorId: string | null;
-    initials: string | null;
-    date: string | null;
-    text: string;
-    from: number;
-    to: number;
-    referencePos: number;
-    resolved: boolean;
-    replies: readonly DocumentCommentReply[];
+    readonly id: string;
+    readonly author: string | null;
+    readonly authorId: string | null;
+    readonly initials: string | null;
+    readonly date: string | null;
+    /** What it says, as plain text. The formatting behind it is `setCommentBody`'s to write */
+    readonly text: string;
+    readonly from: number;
+    readonly to: number;
+    readonly referencePos: number;
+    readonly resolved: boolean;
+    readonly replies: readonly DocumentCommentReply[];
 }
 export interface DocumentCommentReply {
-    id: string;
-    author: string | null;
-    authorId: string | null;
-    initials: string | null;
-    date: string | null;
-    text: string;
+    readonly id: string;
+    readonly author: string | null;
+    readonly authorId: string | null;
+    readonly initials: string | null;
+    readonly date: string | null;
+    readonly text: string;
 }
+export declare function stringAttr(value: unknown): string | null;
+export declare function repliesAttr(value: unknown): readonly CommentReplyData[];

package/dist/editor/commands/comments/model.js

@@ -0,0 +1,11 @@
+// src/editor/commands/comments/model.ts
+function stringAttr(value) {
+  return typeof value === "string" ? value : null;
+}
+function repliesAttr(value) {
+  return Array.isArray(value) ? value : [];
+}
+export {
+  repliesAttr,
+  stringAttr
+};

package/dist/editor/commands/comments/reading.d.ts

@@ -1,11 +1,13 @@
 /** Reads comment threads and anchors from the editor document. */
 import type { EditorState } from "prosemirror-state";
-import type { CommentReplyData } from "../../../docx/comments";
 import type { DocumentComment } from "./model";
-export declare function stringAttr(value: unknown): string | null;
-export declare function repliesAttr(value: unknown): readonly CommentReplyData[];
 /** Comments in document order, including point comments that have no explicit range. */
 export declare function documentComments(state: EditorState): readonly DocumentComment[];
+/**
+ * The comment this id names, or undefined where the document holds none. Answered off the lookup
+ * the projection built, so a command asking after one comment does not read the whole list.
+ */
+export declare function commentById(state: EditorState, id: string): DocumentComment | undefined;
 /**
  * Whether the body of this comment, or of one of its replies, may be edited or deleted here: the
  * protection lets comments be edited at all, and the body is one of one's own to edit

package/dist/editor/commands/comments/reading.js

@@ -1,72 +1,22 @@
 // src/editor/commands/comments/reading.ts
 import { commentOwned } from "../../../schema/protection.js";
 import { protectionOf } from "../../../schema/protectionState.js";
-function stringAttr(value) {
-  return typeof value === "string" ? value : null;
-}
-function repliesAttr(value) {
-  return Array.isArray(value) ? value : [];
-}
-function markerPositions(doc) {
-  const starts = /* @__PURE__ */ new Map();
-  const ends = /* @__PURE__ */ new Map();
-  const references = [];
-  doc.descendants((node, pos) => {
-    const id = stringAttr(node.attrs.id);
-    if (id === null) return true;
-    if (node.type.name === "commentStart" && !starts.has(id)) {
-      starts.set(id, pos);
-    } else if (node.type.name === "commentEnd" && !ends.has(id)) {
-      ends.set(id, pos);
-    } else if (node.type.name === "commentReference") {
-      references.push({ node, pos });
-    }
-    return true;
-  });
-  return { starts, ends, references };
-}
+import { commentProjection } from "../../plugins/commentDecorations.js";
 function documentComments(state) {
-  const markers = markerPositions(state.doc);
-  return markers.references.map(({ node, pos }) => {
-    const id = stringAttr(node.attrs.id) ?? "";
-    const start = markers.starts.get(id);
-    const end = markers.ends.get(id);
-    const hasRange = start !== void 0 && end !== void 0 && start < end;
-    const point = start ?? end ?? pos;
-    return {
-      id,
-      author: stringAttr(node.attrs.author),
-      authorId: stringAttr(node.attrs.authorId),
-      initials: stringAttr(node.attrs.initials),
-      date: stringAttr(node.attrs.date),
-      text: stringAttr(node.attrs.text) ?? "",
-      from: hasRange ? start + 1 : point,
-      to: hasRange ? end : point,
-      referencePos: pos,
-      resolved: node.attrs.resolved === true,
-      replies: repliesAttr(node.attrs.replies).map((reply) => ({
-        id: reply.id,
-        author: reply.author,
-        authorId: reply.authorId,
-        initials: reply.initials,
-        date: reply.date,
-        text: reply.text
-      }))
-    };
-  });
+  return commentProjection.read(state).comments;
+}
+function commentById(state, id) {
+  return commentProjection.read(state).byId.get(id);
 }
 function canEditComment(state, commentId, replyId = null) {
   const rules = protectionOf(state);
   if (rules.protection === "readOnly") return false;
-  const comment = documentComments(state).find(
-    (entry) => entry.id === commentId
-  );
+  const comment = commentById(state, commentId);
   const body = replyId === null ? comment : comment?.replies.find((reply) => reply.id === replyId);
   return body !== void 0 && commentOwned(rules, body.authorId);
 }
 export {
   canEditComment,
-  documentComments,
-  repliesAttr,
-  stringAttr
+  commentById,
+  documentComments
 };