@beyondwork/docx-react-component 1.0.27 → 1.0.29

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

@@ -1,394 +0,0 @@
-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

@@ -1,312 +0,0 @@
-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 type { RevisionRecord, RevisionKind, 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;
-  linkedMoveRevisionId?: string;
-  moveDirection?: "from" | "to";
-}
-
-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",
-      storyTarget: params.metadata?.storyTarget,
-      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);
-
-  const moveData = revision.metadata.moveData;
-
-  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,
-    linkedMoveRevisionId: moveData?.linkedRevisionId,
-    moveDirection: moveData?.direction,
-  };
-}
-
-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;
-  }
-}