@beyondwork/docx-react-component 1.0.1 → 1.0.2

package/src/review/store/comment-store.ts

@@ -0,0 +1,331 @@
+import type { TransactionMapping } from "../../core/selection/mapping.ts";
+import {
+  isDetachedCommentAnchor,
+  remapCommentAnchor,
+  summarizeCommentAnchor,
+  type CommentAnchor,
+} from "./comment-anchors.ts";
+
+export interface CommentEntry {
+  entryId: string;
+  authorId: string;
+  body: string;
+  createdAt: string;
+  metadata?: CommentEntryMetadata;
+}
+
+export interface CommentEntryMetadata {
+  ooxmlCommentId?: string;
+  paraId?: string;
+  parentParaId?: string;
+  durableId?: string;
+  initials?: string;
+}
+
+export interface CommentResolution {
+  resolvedAt: string;
+  resolvedBy: string;
+}
+
+export type CommentThreadStatus = "open" | "resolved" | "detached";
+
+export interface CommentThread {
+  commentId: string;
+  anchor: CommentAnchor;
+  status: CommentThreadStatus;
+  entries: CommentEntry[];
+  createdBy: string;
+  createdAt: string;
+  resolution?: CommentResolution;
+  warningIds: string[];
+  metadata?: CommentThreadMetadata;
+}
+
+export interface CommentThreadMetadata {
+  source?: "runtime" | "import";
+  rootOoxmlCommentId?: string;
+  rootParaId?: string;
+}
+
+export interface CommentStore {
+  version: "comment-store/1";
+  threads: Record<string, CommentThread>;
+}
+
+export interface CreateCommentThreadParams {
+  commentId: string;
+  anchor: CommentAnchor;
+  createdBy: string;
+  createdAt: string;
+  body: string;
+  entryId?: string;
+  warningIds?: string[];
+}
+
+export interface AppendCommentEntryParams {
+  commentId: string;
+  entry: CommentEntry;
+}
+
+export interface ResolveCommentThreadParams {
+  commentId: string;
+  resolvedAt: string;
+  resolvedBy: string;
+}
+
+export interface CommentSidebarThread {
+  commentId: string;
+  status: CommentThreadStatus;
+  excerpt: string;
+  entryCount: number;
+  createdAt: string;
+  createdBy: string;
+  warningCount: number;
+  anchorLabel: string;
+  isActive: boolean;
+  resolvedAt?: string;
+  resolvedBy?: string;
+}
+
+export interface CommentSidebarProjection {
+  totalCount: number;
+  openCommentIds: string[];
+  resolvedCommentIds: string[];
+  detachedCommentIds: string[];
+  threads: CommentSidebarThread[];
+}
+
+export function createCommentStore(
+  threads: Record<string, CommentThread> = {},
+): CommentStore {
+  return {
+    version: "comment-store/1",
+    threads,
+  };
+}
+
+export function createCommentThread(
+  params: CreateCommentThreadParams,
+): CommentThread {
+  return {
+    commentId: params.commentId,
+    anchor: params.anchor,
+    status: isDetachedCommentAnchor(params.anchor) ? "detached" : "open",
+    entries: [
+      {
+        entryId: params.entryId ?? `${params.commentId}-entry-1`,
+        authorId: params.createdBy,
+        body: params.body,
+        createdAt: params.createdAt,
+      },
+    ],
+    createdBy: params.createdBy,
+    createdAt: params.createdAt,
+    warningIds: [...(params.warningIds ?? [])],
+  };
+}
+
+export function upsertCommentThread(
+  store: CommentStore,
+  thread: CommentThread,
+): CommentStore {
+  return {
+    ...store,
+    threads: {
+      ...store.threads,
+      [thread.commentId]: normalizeThread(thread),
+    },
+  };
+}
+
+export function appendCommentEntry(
+  store: CommentStore,
+  params: AppendCommentEntryParams,
+): CommentStore {
+  const existing = store.threads[params.commentId];
+  if (!existing) {
+    return store;
+  }
+
+  return upsertCommentThread(store, {
+    ...existing,
+    entries: [...existing.entries, params.entry],
+  });
+}
+
+export function resolveCommentThread(
+  store: CommentStore,
+  params: ResolveCommentThreadParams,
+): CommentStore {
+  const existing = store.threads[params.commentId];
+  if (!existing) {
+    return store;
+  }
+
+  return upsertCommentThread(store, {
+    ...existing,
+    status: existing.status === "detached" ? "detached" : "resolved",
+    resolution: {
+      resolvedAt: params.resolvedAt,
+      resolvedBy: params.resolvedBy,
+    },
+  });
+}
+
+export function reopenCommentThread(
+  store: CommentStore,
+  commentId: string,
+): CommentStore {
+  const existing = store.threads[commentId];
+  if (!existing) {
+    return store;
+  }
+
+  return upsertCommentThread(store, {
+    ...existing,
+    status: isDetachedCommentAnchor(existing.anchor) ? "detached" : "open",
+    resolution: undefined,
+  });
+}
+
+export function setCommentThreadWarnings(
+  store: CommentStore,
+  commentId: string,
+  warningIds: string[],
+): CommentStore {
+  const existing = store.threads[commentId];
+  if (!existing) {
+    return store;
+  }
+
+  return upsertCommentThread(store, {
+    ...existing,
+    warningIds: [...warningIds],
+  });
+}
+
+export function remapCommentStore(
+  store: CommentStore,
+  mapping: TransactionMapping,
+): CommentStore {
+  return createCommentStore(
+    Object.fromEntries(
+      Object.entries(store.threads).map(([commentId, thread]) => {
+        const anchor = remapCommentAnchor(thread.anchor, mapping);
+        const nextStatus =
+          anchor.kind === "detached"
+            ? "detached"
+            : thread.status === "resolved"
+              ? "resolved"
+              : "open";
+
+        return [
+          commentId,
+          normalizeThread({
+            ...thread,
+            anchor,
+            status: nextStatus,
+          }),
+        ];
+      }),
+    ),
+  );
+}
+
+export function createCommentSidebarProjection(
+  store: CommentStore,
+  activeCommentId?: string,
+): CommentSidebarProjection {
+  const threads = Object.values(store.threads)
+    .map((thread) => toSidebarThread(thread, activeCommentId))
+    .sort(compareSidebarThreads);
+
+  return {
+    totalCount: threads.length,
+    openCommentIds: threads
+      .filter((thread) => thread.status === "open")
+      .map((thread) => thread.commentId),
+    resolvedCommentIds: threads
+      .filter((thread) => thread.status === "resolved")
+      .map((thread) => thread.commentId),
+    detachedCommentIds: threads
+      .filter((thread) => thread.status === "detached")
+      .map((thread) => thread.commentId),
+    threads,
+  };
+}
+
+function toSidebarThread(
+  thread: CommentThread,
+  activeCommentId?: string,
+): CommentSidebarThread {
+  const firstEntry = thread.entries[0];
+  const anchorSummary = summarizeCommentAnchor(thread.anchor);
+
+  return {
+    commentId: thread.commentId,
+    status: thread.status,
+    excerpt: firstEntry ? summarizeBody(firstEntry.body) : "Empty thread",
+    entryCount: thread.entries.length,
+    createdAt: thread.createdAt,
+    createdBy: thread.createdBy,
+    warningCount: thread.warningIds.length,
+    anchorLabel:
+      anchorSummary.state === "detached"
+        ? `Detached ${anchorSummary.range.from}-${anchorSummary.range.to}`
+        : `Range ${anchorSummary.range.from}-${anchorSummary.range.to}`,
+    isActive: activeCommentId === thread.commentId,
+    resolvedAt: thread.resolution?.resolvedAt,
+    resolvedBy: thread.resolution?.resolvedBy,
+  };
+}
+
+function normalizeThread(thread: CommentThread): CommentThread {
+  if (isDetachedCommentAnchor(thread.anchor)) {
+    return {
+      ...thread,
+      status: "detached",
+    };
+  }
+
+  if (thread.status === "detached") {
+    return {
+      ...thread,
+      status: thread.resolution ? "resolved" : "open",
+    };
+  }
+
+  return thread;
+}
+
+function compareSidebarThreads(
+  left: CommentSidebarThread,
+  right: CommentSidebarThread,
+): number {
+  const statusDelta = priorityForStatus(left.status) - priorityForStatus(right.status);
+  if (statusDelta !== 0) {
+    return statusDelta;
+  }
+
+  return left.createdAt.localeCompare(right.createdAt);
+}
+
+function priorityForStatus(status: CommentThreadStatus): number {
+  switch (status) {
+    case "open":
+      return 0;
+    case "detached":
+      return 1;
+    case "resolved":
+      return 2;
+  }
+}
+
+function summarizeBody(body: string): string {
+  const collapsed = body.replace(/\s+/g, " ").trim();
+  if (!collapsed) {
+    return "Empty thread";
+  }
+
+  return collapsed.length > 80 ? `${collapsed.slice(0, 77)}...` : collapsed;
+}

package/src/review/store/comment-thread.ts

@@ -0,0 +1,109 @@
+import { createDetachedAnchor } from "../../core/selection/mapping.ts";
+import type {
+  CommentEntry,
+  CommentEntryMetadata,
+  CommentThread,
+  CommentThreadMetadata,
+} from "./comment-store.ts";
+import { createCommentRangeAnchor } from "./comment-anchors.ts";
+
+export interface ImportedCommentEntryInput {
+  entryId?: string;
+  authorId?: string;
+  body: string;
+  createdAt?: string;
+  metadata?: CommentEntryMetadata;
+}
+
+export interface ImportedCommentThreadInput {
+  commentId: string;
+  body: string;
+  createdBy?: string;
+  createdAt?: string;
+  range?:
+    | {
+        from: number;
+      to: number;
+      }
+    | undefined;
+  warningIds?: string[];
+  entries?: CommentEntry[];
+  status?: CommentThread["status"];
+  resolution?: CommentThread["resolution"];
+  metadata?: CommentThreadMetadata;
+}
+
+export function createImportedCommentThread(
+  input: ImportedCommentThreadInput,
+): CommentThread {
+  const createdAt = input.createdAt ?? "1970-01-01T00:00:00.000Z";
+  const createdBy = input.createdBy ?? "unknown";
+  const entries =
+    input.entries && input.entries.length > 0
+      ? input.entries
+      : [
+          {
+            entryId: `${input.commentId}-entry-1`,
+            authorId: createdBy,
+            body: input.body,
+            createdAt,
+          },
+        ];
+  const status =
+    input.status ??
+    (input.range ? "open" : "detached");
+
+  return {
+    commentId: input.commentId,
+    anchor:
+      status === "detached"
+        ? createDetachedAnchor(input.range ?? { from: 0, to: 0 }, "importAmbiguity")
+        : input.range
+          ? createCommentRangeAnchor(input.range.from, input.range.to)
+          : createDetachedAnchor({ from: 0, to: 0 }, "importAmbiguity"),
+    status,
+    entries,
+    createdBy,
+    createdAt,
+    resolution: input.resolution,
+    warningIds: [...(input.warningIds ?? [])],
+    metadata: input.metadata,
+  };
+}
+
+export function createImportedCommentReply(
+  commentId: string,
+  input: ImportedCommentEntryInput,
+) {
+  return {
+    entryId: input.entryId ?? `${commentId}-entry-reply`,
+    authorId: input.authorId ?? "unknown",
+    body: input.body,
+    createdAt: input.createdAt ?? "1970-01-01T00:00:00.000Z",
+  };
+}
+
+export function updateCommentThreadBody(
+  thread: CommentThread,
+  body: string,
+): CommentThread {
+  const firstEntry = thread.entries[0];
+  if (!firstEntry) {
+    return thread;
+  }
+
+  return {
+    ...thread,
+    entries: [
+      {
+        ...firstEntry,
+        body,
+      },
+      ...thread.entries.slice(1),
+    ],
+  };
+}
+
+export function getCommentThreadBody(thread: CommentThread): string {
+  return thread.entries.map((entry) => entry.body).join("\n");
+}