@beyondwork/docx-react-component 1.0.29 → 1.0.30

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

@@ -0,0 +1,423 @@
+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.",
+    );
+  }
+
+  if (canResolveImportedDeletionWithoutContentMutation(revision, options.intent)) {
+    const resultingStatus = toResultingStatus(options.intent);
+    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 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 canResolveImportedDeletionWithoutContentMutation(
+  revision: RevisionRecord,
+  intent: RevisionActionIntent,
+): boolean {
+  return (
+    revision.kind === "deletion" &&
+    intent === "accept" &&
+    revision.metadata.source === "import" &&
+    revision.metadata.originalRevisionType !== "paragraph-del"
+  );
+}
+
+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;
+}