@beyondwork/docx-react-component 1.0.1 → 1.0.2

package/src/review/store/revision-actions.ts

@@ -0,0 +1,394 @@
+import { createEmptyMapping, type TransactionMapping } from "../../core/selection/mapping.ts";
+import { parseTextStory } from "../../core/schema/text-schema.ts";
+import { createSelectionSnapshot, type CanonicalDocumentEnvelope } from "../../core/state/editor-state.ts";
+import { applyTextTransaction } from "../../core/state/text-transaction.ts";
+import {
+  remapRevisionStore,
+  setRevisionStatus,
+  type RevisionStore,
+} from "./revision-store.ts";
+import { getRevisionActionability, type RevisionRecord } from "./revision-types.ts";
+
+export type RevisionActionIntent = "accept" | "reject";
+
+export type RevisionActionSkipReason =
+  | "missing"
+  | "already-resolved"
+  | "detached-anchor"
+  | "preserve-only"
+  | "structural-range"
+  | "protected-range"
+  | "invalid-range";
+
+export interface ApplyRevisionActionOptions {
+  document: CanonicalDocumentEnvelope;
+  store: RevisionStore;
+  revisionId: string;
+  intent: RevisionActionIntent;
+  timestamp: string;
+}
+
+export interface AppliedRevisionAction {
+  kind: "applied";
+  revisionId: string;
+  intent: RevisionActionIntent;
+  resultingStatus: "accepted" | "rejected";
+  contentChanged: boolean;
+}
+
+export interface SkippedRevisionAction {
+  kind: "skipped";
+  revisionId: string;
+  intent: RevisionActionIntent;
+  reason: RevisionActionSkipReason;
+  detail: string;
+}
+
+export type RevisionActionOutcome =
+  | AppliedRevisionAction
+  | SkippedRevisionAction;
+
+export interface ApplyRevisionActionResult {
+  document: CanonicalDocumentEnvelope;
+  store: RevisionStore;
+  mapping: TransactionMapping;
+  outcome: RevisionActionOutcome;
+  detachedRevisionIds: string[];
+}
+
+export function applyRevisionAction(
+  options: ApplyRevisionActionOptions,
+): ApplyRevisionActionResult {
+  const revision = options.store.revisions[options.revisionId];
+
+  if (!revision) {
+    return skippedResult(options, "missing", "Revision record was not found.");
+  }
+
+  if (revision.status !== "active") {
+    return skippedResult(
+      options,
+      "already-resolved",
+      `Revision is already ${revision.status}.`,
+    );
+  }
+
+  if (revision.anchor.kind === "detached") {
+    return skippedResult(
+      options,
+      "detached-anchor",
+      "Detached revisions remain visible but cannot be accepted or rejected.",
+    );
+  }
+
+  if (getRevisionActionability(revision) !== "actionable") {
+    return skippedResult(
+      options,
+      "preserve-only",
+      revision.metadata.preserveOnlyReason ??
+        "This revision kind remains preserve-only in the current runtime.",
+    );
+  }
+
+  if (revision.anchor.kind !== "range") {
+    return skippedResult(
+      options,
+      "structural-range",
+      "Non-range revisions remain preserve-only in the current runtime.",
+    );
+  }
+
+  const story = parseTextStory(options.document.content);
+  const range = normalizeRange(
+    revision.anchor.range.from,
+    revision.anchor.range.to,
+  );
+
+  if (range.to > story.size) {
+    return skippedResult(
+      options,
+      "invalid-range",
+      `Revision range ${range.from}-${range.to} exceeds story size ${story.size}.`,
+    );
+  }
+
+  const paragraphMarkRange = resolveParagraphMarkDeletionRange(story, revision, options.intent);
+  if (paragraphMarkRange) {
+    const resultingStatus = toResultingStatus(options.intent);
+    const textResult = applyTextTransaction(
+      options.document,
+      createSelectionSnapshot(paragraphMarkRange.from, paragraphMarkRange.to),
+      {
+        type: "replace",
+        range: paragraphMarkRange,
+        insertion: [],
+      },
+      {
+        timestamp: options.timestamp,
+      },
+    );
+
+    const nextStore = remapRevisionStore(
+      setRevisionStatus(options.store, revision.revisionId, resultingStatus),
+      textResult.mapping,
+    );
+
+    return {
+      document: textResult.document,
+      store: nextStore,
+      mapping: textResult.mapping,
+      outcome: {
+        kind: "applied",
+        revisionId: revision.revisionId,
+        intent: options.intent,
+        resultingStatus,
+        contentChanged: true,
+      },
+      detachedRevisionIds: findNewDetachedRevisionIds(options.store, nextStore),
+    };
+  }
+  if (requiresParagraphBoundaryDeletion(revision, options.intent)) {
+    return skippedResult(
+      options,
+      "structural-range",
+      "Paragraph-boundary revisions need a stable paragraph break and remain blocked for this shape.",
+    );
+  }
+
+  const slice = story.units.slice(range.from, range.to);
+  if (
+    slice.some(
+      (unit) =>
+        unit.kind === "paragraph_break" || unit.kind === "opaque_block",
+    )
+  ) {
+    return skippedResult(
+      options,
+      "structural-range",
+      "Paragraph-boundary and structural revisions remain preserve-only.",
+    );
+  }
+
+  if (
+    slice.some(
+      (unit) =>
+        unit.kind === "image" || unit.kind === "opaque_inline",
+    )
+  ) {
+    return skippedResult(
+      options,
+      "protected-range",
+      "Revisions touching protected inline content remain preserve-only.",
+    );
+  }
+
+  const resultingStatus = toResultingStatus(options.intent);
+  const contentChanged = requiresContentDeletion(revision, options.intent);
+
+  if (!contentChanged) {
+    return {
+      document: options.document,
+      store: setRevisionStatus(options.store, revision.revisionId, resultingStatus),
+      mapping: createEmptyMapping(),
+      outcome: {
+        kind: "applied",
+        revisionId: revision.revisionId,
+        intent: options.intent,
+        resultingStatus,
+        contentChanged: false,
+      },
+      detachedRevisionIds: [],
+    };
+  }
+
+  const textResult = applyTextTransaction(
+    options.document,
+    createSelectionSnapshot(range.from, range.to),
+    {
+      type: "replace",
+      range,
+      insertion: [],
+    },
+    {
+      timestamp: options.timestamp,
+    },
+  );
+
+  const nextStore = remapRevisionStore(
+    setRevisionStatus(options.store, revision.revisionId, resultingStatus),
+    textResult.mapping,
+  );
+
+  return {
+    document: textResult.document,
+    store: nextStore,
+    mapping: textResult.mapping,
+    outcome: {
+      kind: "applied",
+      revisionId: revision.revisionId,
+      intent: options.intent,
+      resultingStatus,
+      contentChanged: true,
+    },
+    detachedRevisionIds: findNewDetachedRevisionIds(options.store, nextStore),
+  };
+}
+
+function skippedResult(
+  options: ApplyRevisionActionOptions,
+  reason: RevisionActionSkipReason,
+  detail: string,
+): ApplyRevisionActionResult {
+  return {
+    document: options.document,
+    store: options.store,
+    mapping: createEmptyMapping(),
+    outcome: {
+      kind: "skipped",
+      revisionId: options.revisionId,
+      intent: options.intent,
+      reason,
+      detail,
+    },
+    detachedRevisionIds: [],
+  };
+}
+
+function toResultingStatus(
+  intent: RevisionActionIntent,
+): "accepted" | "rejected" {
+  return intent === "accept" ? "accepted" : "rejected";
+}
+
+function requiresContentDeletion(
+  revision: Pick<RevisionRecord, "kind">,
+  intent: RevisionActionIntent,
+): boolean {
+  return (
+    (revision.kind === "insertion" && intent === "reject") ||
+    (revision.kind === "deletion" && intent === "accept")
+  );
+}
+
+function requiresParagraphBoundaryDeletion(
+  revision: RevisionRecord,
+  intent: RevisionActionIntent,
+): boolean {
+  return (
+    (revision.metadata.originalRevisionType === "paragraph-del" && intent === "accept") ||
+    (revision.metadata.originalRevisionType === "paragraph-ins" && intent === "reject")
+  );
+}
+
+function resolveParagraphMarkDeletionRange(
+  story: ReturnType<typeof parseTextStory>,
+  revision: RevisionRecord,
+  intent: RevisionActionIntent,
+): { from: number; to: number } | undefined {
+  const originalRevisionType = revision.metadata.originalRevisionType;
+  if (
+    revision.anchor.kind !== "range" ||
+    (originalRevisionType !== "paragraph-del" && originalRevisionType !== "paragraph-ins")
+  ) {
+    return undefined;
+  }
+
+  const shouldDeleteBoundary =
+    (originalRevisionType === "paragraph-del" && intent === "accept") ||
+    (originalRevisionType === "paragraph-ins" && intent === "reject");
+  if (!shouldDeleteBoundary) {
+    return undefined;
+  }
+
+  const paragraphs = mapParagraphRanges(story);
+  const anchorPosition = normalizeRange(
+    revision.anchor.range.from,
+    revision.anchor.range.to,
+  ).from;
+  const paragraph = paragraphs.find(
+    (candidate) =>
+      candidate.end === anchorPosition ||
+      (anchorPosition >= candidate.start && anchorPosition <= candidate.end),
+  );
+  if (!paragraph) {
+    return undefined;
+  }
+
+  if (originalRevisionType === "paragraph-del") {
+    const boundaryIndex = paragraph.end;
+    if (story.units[boundaryIndex]?.kind !== "paragraph_break") {
+      return undefined;
+    }
+
+    return {
+      from: boundaryIndex,
+      to: boundaryIndex + 1,
+    };
+  }
+
+  const boundaryIndex = paragraph.start - 1;
+  if (boundaryIndex < 0 || story.units[boundaryIndex]?.kind !== "paragraph_break") {
+    return undefined;
+  }
+
+  return {
+    from: boundaryIndex,
+    to: boundaryIndex + 1,
+  };
+}
+
+function mapParagraphRanges(
+  story: ReturnType<typeof parseTextStory>,
+): Array<{ start: number; end: number }> {
+  const paragraphs: Array<{ start: number; end: number }> = [];
+  let start = 0;
+  let hasPendingParagraph = true;
+
+  for (let index = 0; index < story.units.length; index += 1) {
+    const unit = story.units[index];
+    if (unit.kind === "paragraph_break") {
+      paragraphs.push({ start, end: index });
+      start = index + 1;
+      hasPendingParagraph = true;
+      continue;
+    }
+
+    if (unit.kind === "opaque_block") {
+      if (hasPendingParagraph) {
+        paragraphs.push({ start, end: index });
+      }
+      start = index + 1;
+      hasPendingParagraph = Boolean(unit.nextParagraph);
+    }
+  }
+
+  if (hasPendingParagraph) {
+    paragraphs.push({ start, end: story.units.length });
+  }
+  return paragraphs;
+}
+
+function normalizeRange(from: number, to: number): { from: number; to: number } {
+  return {
+    from: Math.min(from, to),
+    to: Math.max(from, to),
+  };
+}
+
+function findNewDetachedRevisionIds(
+  previousStore: RevisionStore,
+  nextStore: RevisionStore,
+): string[] {
+  const detachedRevisionIds: string[] = [];
+
+  for (const [revisionId, revision] of Object.entries(nextStore.revisions)) {
+    if (
+      revision.status === "detached" &&
+      previousStore.revisions[revisionId]?.status !== "detached"
+    ) {
+      detachedRevisionIds.push(revisionId);
+    }
+  }
+
+  return detachedRevisionIds;
+}

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

@@ -0,0 +1,303 @@
+import type { TransactionMapping } from "../../core/selection/mapping.ts";
+import {
+  describeRevisionKind,
+  getRevisionActionability,
+  isDetachedRevisionAnchor,
+  isRevisionActionable,
+  remapRevisionAnchor,
+  summarizeRevisionAnchor,
+  type RevisionActionability,
+  type RevisionKind,
+  type RevisionMetadataEnvelope,
+  type RevisionRecord,
+  type RevisionStatus,
+} from "./revision-types.ts";
+
+export interface RevisionStore {
+  version: "revision-store/1";
+  revisions: Record<string, RevisionRecord>;
+}
+
+export interface CreateRevisionRecordParams {
+  revisionId: string;
+  kind: RevisionKind;
+  anchor: RevisionRecord["anchor"];
+  authorId: string;
+  createdAt: string;
+  status?: Exclude<RevisionStatus, "detached">;
+  warningIds?: string[];
+  metadata?: Partial<RevisionMetadataEnvelope>;
+}
+
+export interface RevisionSidebarEntry {
+  revisionId: string;
+  kind: RevisionKind;
+  label: string;
+  status: RevisionStatus;
+  actionability: RevisionActionability;
+  anchorLabel: string;
+  createdAt: string;
+  authorId: string;
+  warningCount: number;
+  canAccept: boolean;
+  canReject: boolean;
+  preserveOnlyReason?: string;
+}
+
+export interface RevisionSidebarProjection {
+  totalCount: number;
+  activeRevisionIds: string[];
+  acceptedRevisionIds: string[];
+  rejectedRevisionIds: string[];
+  detachedRevisionIds: string[];
+  actionableRevisionIds: string[];
+  preserveOnlyRevisionIds: string[];
+  revisions: RevisionSidebarEntry[];
+}
+
+export function createRevisionStore(
+  revisions: Record<string, RevisionRecord> = {},
+): RevisionStore {
+  return {
+    version: "revision-store/1",
+    revisions,
+  };
+}
+
+export function createRevisionRecord(
+  params: CreateRevisionRecordParams,
+): RevisionRecord {
+  return normalizeRevisionRecord({
+    revisionId: params.revisionId,
+    kind: params.kind,
+    anchor: params.anchor,
+    authorId: params.authorId,
+    createdAt: params.createdAt,
+    status: params.status ?? "active",
+    warningIds: [...(params.warningIds ?? [])],
+    metadata: {
+      source: params.metadata?.source ?? "runtime",
+      preserveOnlyReason:
+        params.metadata?.preserveOnlyReason ??
+        (getRevisionActionability(params.kind) === "preserve-only"
+          ? "Imported preserve-only revision."
+          : undefined),
+      importedRevisionForm: params.metadata?.importedRevisionForm,
+      originalRevisionType: params.metadata?.originalRevisionType,
+      ooxmlRevisionId: params.metadata?.ooxmlRevisionId,
+      propertyChangeData: params.metadata?.propertyChangeData,
+      moveData: params.metadata?.moveData,
+    },
+  });
+}
+
+export function upsertRevisionRecord(
+  store: RevisionStore,
+  revision: RevisionRecord,
+): RevisionStore {
+  return {
+    ...store,
+    revisions: {
+      ...store.revisions,
+      [revision.revisionId]: normalizeRevisionRecord(revision),
+    },
+  };
+}
+
+export function setRevisionStatus(
+  store: RevisionStore,
+  revisionId: string,
+  status: Exclude<RevisionStatus, "detached">,
+): RevisionStore {
+  const existing = store.revisions[revisionId];
+  if (!existing) {
+    return store;
+  }
+
+  if (existing.status === "detached") {
+    return store;
+  }
+
+  if (
+    (status === "accepted" || status === "rejected") &&
+    getRevisionActionability(existing) !== "actionable"
+  ) {
+    return store;
+  }
+
+  return upsertRevisionRecord(store, {
+    ...existing,
+    status,
+  });
+}
+
+export function setRevisionWarnings(
+  store: RevisionStore,
+  revisionId: string,
+  warningIds: string[],
+): RevisionStore {
+  const existing = store.revisions[revisionId];
+  if (!existing) {
+    return store;
+  }
+
+  return upsertRevisionRecord(store, {
+    ...existing,
+    warningIds: [...warningIds],
+  });
+}
+
+export function remapRevisionStore(
+  store: RevisionStore,
+  mapping: TransactionMapping,
+): RevisionStore {
+  return createRevisionStore(
+    Object.fromEntries(
+      Object.entries(store.revisions).map(([revisionId, revision]) => {
+        const anchor = remapRevisionAnchor(revision.anchor, mapping);
+        const status =
+          anchor.kind === "detached"
+            ? "detached"
+            : revision.status === "accepted" || revision.status === "rejected"
+              ? revision.status
+              : "active";
+
+        return [
+          revisionId,
+          normalizeRevisionRecord({
+            ...revision,
+            anchor,
+            status,
+          }),
+        ];
+      }),
+    ),
+  );
+}
+
+export function createRevisionSidebarProjection(
+  store: RevisionStore,
+): RevisionSidebarProjection {
+  const revisions = Object.values(store.revisions)
+    .map(toSidebarEntry)
+    .sort(compareRevisionEntries);
+
+  return {
+    totalCount: revisions.length,
+    activeRevisionIds: revisions
+      .filter((revision) => revision.status === "active")
+      .map((revision) => revision.revisionId),
+    acceptedRevisionIds: revisions
+      .filter((revision) => revision.status === "accepted")
+      .map((revision) => revision.revisionId),
+    rejectedRevisionIds: revisions
+      .filter((revision) => revision.status === "rejected")
+      .map((revision) => revision.revisionId),
+    detachedRevisionIds: revisions
+      .filter((revision) => revision.status === "detached")
+      .map((revision) => revision.revisionId),
+    actionableRevisionIds: revisions
+      .filter((revision) => revision.actionability === "actionable")
+      .map((revision) => revision.revisionId),
+    preserveOnlyRevisionIds: revisions
+      .filter((revision) => revision.actionability === "preserve-only")
+      .map((revision) => revision.revisionId),
+    revisions,
+  };
+}
+
+function toSidebarEntry(revision: RevisionRecord): RevisionSidebarEntry {
+  const anchorSummary = summarizeRevisionAnchor(revision.anchor);
+  const actionability = getRevisionActionability(revision);
+
+  return {
+    revisionId: revision.revisionId,
+    kind: revision.kind,
+    label: describeRevisionKind(revision.kind),
+    status: revision.status,
+    actionability,
+    anchorLabel:
+      anchorSummary.state === "detached"
+        ? `Detached ${anchorSummary.range.from}-${anchorSummary.range.to}`
+        : `Range ${anchorSummary.range.from}-${anchorSummary.range.to}`,
+    createdAt: revision.createdAt,
+    authorId: revision.authorId,
+    warningCount: revision.warningIds.length,
+    canAccept: isRevisionActionable(revision),
+    canReject: isRevisionActionable(revision),
+    preserveOnlyReason: revision.metadata.preserveOnlyReason,
+  };
+}
+
+function normalizeRevisionRecord(revision: RevisionRecord): RevisionRecord {
+  const actionability = getRevisionActionability(revision);
+
+  if (isDetachedRevisionAnchor(revision.anchor)) {
+    return {
+      ...revision,
+      status: "detached",
+      metadata: {
+        ...revision.metadata,
+        preserveOnlyReason:
+          revision.metadata.preserveOnlyReason ??
+          (actionability === "preserve-only"
+            ? "Imported preserve-only revision."
+            : undefined),
+      },
+    };
+  }
+
+  if (actionability === "preserve-only" && revision.status !== "detached") {
+    return {
+      ...revision,
+      status: revision.status === "accepted" || revision.status === "rejected" ? "active" : revision.status,
+      metadata: {
+        ...revision.metadata,
+        preserveOnlyReason:
+          revision.metadata.preserveOnlyReason ?? "Imported preserve-only revision.",
+      },
+    };
+  }
+
+  return revision;
+}
+
+function compareRevisionEntries(
+  left: RevisionSidebarEntry,
+  right: RevisionSidebarEntry,
+): number {
+  const statusDelta = priorityForStatus(left.status) - priorityForStatus(right.status);
+  if (statusDelta !== 0) {
+    return statusDelta;
+  }
+
+  const actionabilityDelta =
+    priorityForActionability(left.actionability) - priorityForActionability(right.actionability);
+  if (actionabilityDelta !== 0) {
+    return actionabilityDelta;
+  }
+
+  return left.createdAt.localeCompare(right.createdAt);
+}
+
+function priorityForStatus(status: RevisionStatus): number {
+  switch (status) {
+    case "active":
+      return 0;
+    case "detached":
+      return 1;
+    case "accepted":
+      return 2;
+    case "rejected":
+      return 3;
+  }
+}
+
+function priorityForActionability(actionability: RevisionActionability): number {
+  switch (actionability) {
+    case "actionable":
+      return 0;
+    case "preserve-only":
+      return 1;
+  }
+}