@beyondwork/docx-react-component 1.0.41 → 1.0.43

package/src/runtime/comment-negotiation.ts

@@ -0,0 +1,158 @@
+import type {
+  CommentNegotiationAction,
+  CommentNegotiationActionType,
+  CommentNegotiationEntry,
+  CommentNegotiationState,
+  NegotiationBlockReason,
+  NegotiationHistoryRow,
+  NegotiationRole,
+} from "../api/comment-negotiation-types.ts";
+
+export interface ReduceContext {
+  role: NegotiationRole;
+  now: string;
+}
+
+export type ReduceResult =
+  | { ok: true; entry: CommentNegotiationEntry }
+  | { ok: false; reason: NegotiationBlockReason };
+
+export function createInitialEntry(commentId: string): CommentNegotiationEntry {
+  return {
+    commentId,
+    state: "proposed",
+    requiredApprovers: [],
+    votes: [],
+    counterProposals: [],
+    history: [],
+  };
+}
+
+const ALLOWED_BY_STATE: Record<
+  CommentNegotiationState,
+  ReadonlyArray<CommentNegotiationActionType>
+> = {
+  proposed: ["propose-change", "counter-propose", "reject"],
+  negotiating: ["counter-propose", "vote", "accept", "reject"],
+  accepted: ["lock"],
+  rejected: ["lock"],
+  resolved: ["reopen"],
+};
+
+export function reduceNegotiation(
+  entry: CommentNegotiationEntry,
+  action: CommentNegotiationAction,
+  ctx: ReduceContext,
+): ReduceResult {
+  if (ctx.role === "observer") {
+    return { ok: false, reason: "collab_observer_readonly" };
+  }
+  if (
+    ctx.role === "reviewer" &&
+    (action.type === "accept" || action.type === "lock")
+  ) {
+    return { ok: false, reason: "collab_role_restricted" };
+  }
+  if (!ALLOWED_BY_STATE[entry.state].includes(action.type)) {
+    return { ok: false, reason: "negotiation_invalid_transition" };
+  }
+  if (action.type === "accept" && !quorumMet(entry)) {
+    return { ok: false, reason: "negotiation_quorum_not_met" };
+  }
+  return { ok: true, entry: applyAction(entry, action, ctx) };
+}
+
+export function quorumMet(entry: CommentNegotiationEntry): boolean {
+  if (entry.requiredApprovers.length > 0) {
+    return entry.requiredApprovers.every(
+      (userId) =>
+        entry.votes.find((v) => v.authorId === userId)?.verdict === "approve",
+    );
+  }
+  const approves = entry.votes.filter((v) => v.verdict === "approve").length;
+  const rejects = entry.votes.filter((v) => v.verdict === "reject").length;
+  return approves >= 1 && rejects === 0;
+}
+
+function applyAction(
+  entry: CommentNegotiationEntry,
+  action: CommentNegotiationAction,
+  ctx: ReduceContext,
+): CommentNegotiationEntry {
+  const from = entry.state;
+  let next: CommentNegotiationEntry = { ...entry };
+
+  switch (action.type) {
+    case "propose-change":
+      next.state = "negotiating";
+      break;
+
+    case "counter-propose": {
+      next.state = from === "proposed" ? "negotiating" : from;
+      next.counterProposals = [
+        ...entry.counterProposals,
+        {
+          id: action.proposalId,
+          authorId: action.authorId,
+          createdAt: action.createdAt,
+          body: action.body,
+          proposedRangeEdit: action.proposedRangeEdit,
+        },
+      ];
+      break;
+    }
+
+    case "vote":
+      next.votes = [
+        ...entry.votes.filter((v) => v.authorId !== action.authorId),
+        {
+          authorId: action.authorId,
+          verdict: action.verdict,
+          castAt: ctx.now,
+        },
+      ];
+      break;
+
+    case "accept":
+      next.state = "accepted";
+      next.acceptedProposalId = action.acceptedProposalId;
+      break;
+
+    case "reject":
+      next.state = "rejected";
+      break;
+
+    case "lock":
+      next.state = "resolved";
+      next.lockedAt = ctx.now;
+      next.lockedBy = action.actorId;
+      break;
+
+    case "reopen":
+      next.state = "negotiating";
+      next.lockedAt = undefined;
+      next.lockedBy = undefined;
+      break;
+  }
+
+  if (next.state !== from) {
+    const row: NegotiationHistoryRow = {
+      from,
+      to: next.state,
+      actorId: actorOf(action),
+      at: ctx.now,
+      action: action.type,
+    };
+    if (action.type === "reject" && action.reasonCode !== undefined) {
+      row.reasonCode = action.reasonCode;
+    }
+    next.history = [...entry.history, row];
+  }
+
+  return next;
+}
+
+function actorOf(action: CommentNegotiationAction): string {
+  if ("actorId" in action) return action.actorId;
+  return action.authorId;
+}

package/src/runtime/comment-presentation.ts

@@ -0,0 +1,223 @@
+import * as Y from "yjs";
+
+import type {
+  CommentAudience,
+  CommentAttachment,
+  CommentBody,
+  CommentLabel,
+  CommentMention,
+  CommentPresentation,
+  CommentPresentationAction,
+  CommentPresentationReply,
+  CommentPresentationSnapshot,
+  CommentReaction,
+} from "../api/comment-presentation-types.ts";
+import { sanitizeMarkdown, sha256Hex } from "./markdown-sanitizer.ts";
+
+const MAP_KEY = "commentPresentation";
+
+export interface PresentationStoreHandle {
+  get(commentId: string): CommentPresentation | undefined;
+  snapshot(): CommentPresentationSnapshot;
+  apply(action: CommentPresentationAction): Promise<CommentPresentation>;
+  ingestRemote(entry: CommentPresentation): void;
+  subscribe(fn: (changedIds: string[]) => void): () => void;
+  destroy(): void;
+}
+
+export function createPresentationStore(ydoc: Y.Doc): PresentationStoreHandle {
+  const yMap = ydoc.getMap<CommentPresentation>(MAP_KEY);
+  const listeners = new Set<(ids: string[]) => void>();
+
+  const onChange = (event: Y.YMapEvent<CommentPresentation>): void => {
+    if (listeners.size === 0) return;
+    const ids = Array.from(event.keysChanged);
+    for (const fn of listeners) fn(ids);
+  };
+  yMap.observe(onChange);
+
+  const seed = (commentId: string): CommentPresentation =>
+    yMap.get(commentId) ?? {
+      commentId,
+      audience: "internal",
+      body: emptyBody(),
+      replies: [],
+      mentions: [],
+      attachments: [],
+      reactions: [],
+      labels: [],
+    };
+
+  return {
+    get: (id) => cloneMaybe(yMap.get(id)),
+    snapshot: () => ({
+      schemaVersion: 1,
+      entries: Array.from(yMap.values()).map(clone),
+    }),
+    ingestRemote: (entry) => {
+      yMap.set(entry.commentId, clone(entry));
+    },
+    subscribe: (fn) => {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    },
+    destroy: () => {
+      yMap.unobserve(onChange);
+      listeners.clear();
+    },
+    async apply(action) {
+      const prev = seed(action.commentId);
+      const next = await reducePresentation(prev, action);
+      yMap.set(action.commentId, next);
+      return clone(next);
+    },
+  };
+}
+
+export async function reducePresentation(
+  prev: CommentPresentation,
+  action: CommentPresentationAction,
+): Promise<CommentPresentation> {
+  switch (action.type) {
+    case "set-body": {
+      const body = await buildBody(action.text);
+      const next: CommentPresentation = { ...prev, body };
+      if (action.audience) next.audience = action.audience;
+      return next;
+    }
+    case "set-audience":
+      return { ...prev, audience: action.audience };
+    case "set-reply-body": {
+      const body = await buildBody(action.text);
+      return { ...prev, replies: upsertReply(prev.replies, action.entryId, body) };
+    }
+    case "add-mention":
+      return { ...prev, mentions: [...prev.mentions, { ...action.mention }] };
+    case "add-attachment":
+      return {
+        ...prev,
+        attachments: [...prev.attachments, { ...action.attachment }],
+      };
+    case "remove-attachment":
+      return {
+        ...prev,
+        attachments: prev.attachments.filter((a) => a.id !== action.attachmentId),
+      };
+    case "toggle-reaction": {
+      const match = (r: CommentReaction): boolean =>
+        r.emoji === action.emoji && r.authorId === action.authorId;
+      if (prev.reactions.some(match)) {
+        return { ...prev, reactions: prev.reactions.filter((r) => !match(r)) };
+      }
+      return {
+        ...prev,
+        reactions: [
+          ...prev.reactions,
+          {
+            emoji: action.emoji,
+            authorId: action.authorId,
+            reactedAt: action.now,
+          },
+        ],
+      };
+    }
+    case "set-labels":
+      return { ...prev, labels: action.labels.map((l) => ({ ...l })) };
+  }
+}
+
+async function buildBody(raw: string): Promise<CommentBody> {
+  const { text, sanitized } = sanitizeMarkdown(raw);
+  const digest = `sha256:${await sha256Hex(text)}`;
+  const body: CommentBody = { format: "markdown", text, digest };
+  if (sanitized) body.sanitized = true;
+  return body;
+}
+
+function emptyBody(): CommentBody {
+  return {
+    format: "markdown",
+    text: "",
+    digest:
+      "sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  };
+}
+
+function upsertReply(
+  replies: CommentPresentationReply[],
+  entryId: string,
+  body: CommentBody,
+): CommentPresentationReply[] {
+  const idx = replies.findIndex((r) => r.entryId === entryId);
+  if (idx < 0) return [...replies, { entryId, body }];
+  const next = replies.slice();
+  next[idx] = { entryId, body };
+  return next;
+}
+
+function clone(entry: CommentPresentation): CommentPresentation {
+  return {
+    commentId: entry.commentId,
+    audience: entry.audience,
+    body: cloneBody(entry.body),
+    replies: entry.replies.map((r) => ({
+      entryId: r.entryId,
+      body: cloneBody(r.body),
+    })),
+    mentions: entry.mentions.map(cloneMention),
+    attachments: entry.attachments.map(cloneAttachment),
+    reactions: entry.reactions.map((r) => ({ ...r })),
+    labels: entry.labels.map(cloneLabel),
+  };
+}
+
+function cloneMaybe(
+  entry: CommentPresentation | undefined,
+): CommentPresentation | undefined {
+  return entry ? clone(entry) : undefined;
+}
+
+function cloneBody(body: CommentBody): CommentBody {
+  const copy: CommentBody = {
+    format: body.format,
+    text: body.text,
+    digest: body.digest,
+  };
+  if (body.sanitized) copy.sanitized = true;
+  return copy;
+}
+
+function cloneMention(mention: CommentMention): CommentMention {
+  const copy: CommentMention = {
+    userId: mention.userId,
+    displayName: mention.displayName,
+    offsetInBody: mention.offsetInBody,
+  };
+  if (mention.entryId !== undefined) copy.entryId = mention.entryId;
+  return copy;
+}
+
+function cloneAttachment(a: CommentAttachment): CommentAttachment {
+  const copy: CommentAttachment = {
+    id: a.id,
+    kind: a.kind,
+    displayName: a.displayName,
+  };
+  if (a.mimeType !== undefined) copy.mimeType = a.mimeType;
+  if (a.relationshipId !== undefined) copy.relationshipId = a.relationshipId;
+  if (a.href !== undefined) copy.href = a.href;
+  if (a.byteLength !== undefined) copy.byteLength = a.byteLength;
+  if (a.width !== undefined) copy.width = a.width;
+  if (a.height !== undefined) copy.height = a.height;
+  return copy;
+}
+
+function cloneLabel(label: CommentLabel): CommentLabel {
+  const copy: CommentLabel = { key: label.key, text: label.text };
+  if (label.color !== undefined) copy.color = label.color;
+  return copy;
+}
+
+export type { CommentAudience };