@beyondwork/docx-react-component 1.0.1 → 1.0.2

package/src/core/commands/index.ts

@@ -0,0 +1,1013 @@
+import {
+  createSelectionSnapshot,
+  type CanonicalDocumentEnvelope,
+  type CommentThreadRecord,
+  type EditorState,
+  type EditorWarning,
+  normalizeCommentThreadRecord,
+  type SelectionSnapshot,
+} from "../state/editor-state.ts";
+import {
+  areAnchorsEqual,
+  createEmptyMapping,
+  mapAnchor,
+  type EditorAnchorProjection,
+  type MappingStep,
+  type TransactionMapping,
+} from "../selection/mapping.ts";
+import {
+  createAcceptRevisionCommand,
+  createRejectRevisionCommand,
+  type ReviewCommand,
+} from "./review-commands.ts";
+import {
+  deleteSelectionOrBackward,
+  deleteSelectionOrForward,
+  insertHardBreak,
+  insertTab,
+  insertText,
+  splitParagraph,
+} from "./text-commands.ts";
+import { remapCommentThreads } from "../../review/store/comment-remapping.ts";
+import { applyRevisionRuntimeCommand } from "../../runtime/revision-runtime.ts";
+import type { RevisionStore } from "../../review/store/revision-store.ts";
+
+export interface CommandOrigin {
+  source:
+    | "keyboard"
+    | "toolbar"
+    | "context_menu"
+    | "comment_panel"
+    | "review_panel"
+    | "api"
+    | "runtime";
+  timestamp: string;
+}
+
+export type EditorCommand =
+  | {
+      type: "selection.set";
+      selection: SelectionSnapshot;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "document.replace";
+      document: CanonicalDocumentEnvelope;
+      mapping?: TransactionMapping;
+      selection?: SelectionSnapshot;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "text.insert";
+      text: string;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "text.delete-backward";
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "text.delete-forward";
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "text.insert-tab";
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "text.insert-hard-break";
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "paragraph.split";
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "runtime.set-read-only";
+      readOnly: boolean;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "runtime.focus";
+      focused: boolean;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "warning.add";
+      warning: EditorWarning;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "warning.clear";
+      warningId: string;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "comment.add";
+      comment: CommentThreadRecord;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "comment.open";
+      commentId: string;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "comment.resolve";
+      commentId: string;
+      resolvedBy?: string;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "comment.reopen";
+      commentId: string;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "comment.add-reply";
+      commentId: string;
+      body: string;
+      authorId?: string;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "comment.edit-body";
+      commentId: string;
+      body: string;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "change.accept";
+      changeId: string;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "change.reject";
+      changeId: string;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "change.accept-all";
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "change.reject-all";
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "history.undo";
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "history.redo";
+      origin?: CommandOrigin;
+    };
+
+export interface TransactionEffects {
+  warningsAdded: EditorWarning[];
+  warningsCleared: Array<{ warningId: string; code: EditorWarning["code"] }>;
+  commentAdded?: { commentId: string; anchor: EditorAnchorProjection };
+  commentResolved?: { commentId: string };
+  commentReopened?: { commentId: string };
+  commentReplyAdded?: { commentId: string };
+  commentBodyEdited?: { commentId: string };
+  changeAccepted?: { changeId: string };
+  changeRejected?: { changeId: string };
+}
+
+export interface EditorTransaction {
+  nextState: EditorState;
+  mapping: TransactionMapping;
+  effects: TransactionEffects;
+  historyBoundary: "push" | "skip";
+  markDirty: boolean;
+}
+
+export interface CommandExecutionContext {
+  timestamp: string;
+}
+
+export function executeEditorCommand(
+  state: EditorState,
+  command: Exclude<EditorCommand, { type: "history.undo" } | { type: "history.redo" }>,
+  context: CommandExecutionContext,
+): EditorTransaction {
+  switch (command.type) {
+    case "selection.set":
+      return createTransaction(
+        {
+          ...state,
+          selection: normalizeSelection(command.selection),
+        },
+        {
+          historyBoundary: "skip",
+          markDirty: false,
+        },
+      );
+    case "document.replace": {
+      const mapping = command.mapping ?? createEmptyMapping();
+      const selection =
+        command.selection ?? remapSelection(state.selection, mapping);
+      const reviewState = remapReviewStateAfterContentChange(
+        state,
+        command.document,
+        mapping,
+      );
+
+      return createTransaction(
+        {
+          ...state,
+          document: reviewState.document,
+          selection,
+          warnings: reviewState.warnings,
+          runtime: {
+            ...state.runtime,
+            activeCommentId: reviewState.activeCommentId,
+          },
+          compatibility: {
+            ...state.compatibility,
+            generatedAt: context.timestamp,
+            warnings: reviewState.warnings,
+            featureEntries: state.compatibility.featureEntries.map((entry) =>
+              entry.affectedAnchor
+                ? {
+                    ...entry,
+                    affectedAnchor: mapAnchor(entry.affectedAnchor, mapping),
+                  }
+                : entry,
+            ),
+          },
+        },
+        {
+          historyBoundary: "push",
+          markDirty: true,
+          mapping,
+          effects: reviewState.effects,
+        },
+      );
+    }
+    case "text.insert":
+      return applyTextCommand(state, context.timestamp, (document, selection) =>
+        insertText(document, selection, command.text, context),
+      );
+    case "text.delete-backward":
+      return applyTextCommand(state, context.timestamp, (document, selection) =>
+        deleteSelectionOrBackward(document, selection, context),
+      );
+    case "text.delete-forward":
+      return applyTextCommand(state, context.timestamp, (document, selection) =>
+        deleteSelectionOrForward(document, selection, context),
+      );
+    case "text.insert-tab":
+      return applyTextCommand(state, context.timestamp, (document, selection) =>
+        insertTab(document, selection, context),
+      );
+    case "text.insert-hard-break":
+      return applyTextCommand(state, context.timestamp, (document, selection) =>
+        insertHardBreak(document, selection, context),
+      );
+    case "paragraph.split":
+      return applyTextCommand(state, context.timestamp, (document, selection) =>
+        splitParagraph(document, selection, context),
+      );
+    case "runtime.set-read-only":
+      return createTransaction(
+        {
+          ...state,
+          readOnly: command.readOnly,
+        },
+        {
+          historyBoundary: "skip",
+          markDirty: false,
+        },
+      );
+    case "runtime.focus":
+      return createTransaction(
+        {
+          ...state,
+          runtime: {
+            ...state.runtime,
+            hasFocus: command.focused,
+          },
+        },
+        {
+          historyBoundary: "skip",
+          markDirty: false,
+        },
+      );
+    case "warning.add": {
+      if (state.warnings.some((warning) => warning.warningId === command.warning.warningId)) {
+        return createTransaction(state, {
+          historyBoundary: "skip",
+          markDirty: false,
+        });
+      }
+
+      const warnings = [...state.warnings, command.warning];
+      return createTransaction(
+        {
+          ...state,
+          warnings,
+          compatibility: {
+            ...state.compatibility,
+            generatedAt: context.timestamp,
+            warnings,
+          },
+        },
+        {
+          historyBoundary: "skip",
+          markDirty: false,
+          effects: {
+            warningsAdded: [command.warning],
+          },
+        },
+      );
+    }
+    case "warning.clear": {
+      const existing = state.warnings.find((warning) => warning.warningId === command.warningId);
+
+      if (!existing) {
+        return createTransaction(state, {
+          historyBoundary: "skip",
+          markDirty: false,
+        });
+      }
+
+      const warnings = state.warnings.filter((warning) => warning.warningId !== command.warningId);
+      return createTransaction(
+        {
+          ...state,
+          warnings,
+          compatibility: {
+            ...state.compatibility,
+            generatedAt: context.timestamp,
+            warnings,
+          },
+        },
+        {
+          historyBoundary: "skip",
+          markDirty: false,
+          effects: {
+            warningsCleared: [
+              {
+                warningId: existing.warningId,
+                code: existing.code,
+              },
+            ],
+          },
+        },
+      );
+    }
+    case "comment.add": {
+      const comments = {
+        ...state.document.review.comments,
+        [command.comment.commentId]: normalizeCommentThreadRecord(command.comment),
+      };
+
+      return createTransaction(
+        {
+          ...state,
+          document: {
+            ...state.document,
+            updatedAt: context.timestamp,
+            review: {
+              ...state.document.review,
+              comments,
+            },
+          },
+          runtime: {
+            ...state.runtime,
+            activeCommentId: command.comment.commentId,
+          },
+        },
+        {
+          historyBoundary: "push",
+          markDirty: true,
+          effects: {
+            commentAdded: {
+              commentId: command.comment.commentId,
+              anchor: command.comment.anchor,
+            },
+          },
+        },
+      );
+    }
+    case "comment.open":
+      return createTransaction(
+        {
+          ...state,
+          runtime: {
+            ...state.runtime,
+            activeCommentId: command.commentId,
+          },
+        },
+        {
+          historyBoundary: "skip",
+          markDirty: false,
+        },
+      );
+    case "comment.resolve": {
+      const existing = state.document.review.comments[command.commentId];
+      if (!existing) {
+        return createTransaction(state, {
+          historyBoundary: "skip",
+          markDirty: false,
+        });
+      }
+
+      const comments = {
+        ...state.document.review.comments,
+        [command.commentId]: {
+          ...existing,
+          status: (existing.anchor.kind === "detached" ? "detached" : "resolved") as "detached" | "resolved",
+          resolution: {
+            resolvedAt: context.timestamp,
+            resolvedBy:
+              command.resolvedBy ??
+              existing.createdBy ??
+              existing.authorId ??
+              existing.entries?.[0]?.authorId ??
+              "unknown",
+          },
+          isResolved: true,
+          resolvedAt: context.timestamp,
+        },
+      };
+
+      return createTransaction(
+        {
+          ...state,
+          document: {
+            ...state.document,
+            updatedAt: context.timestamp,
+            review: {
+              ...state.document.review,
+              comments,
+            },
+          },
+        },
+        {
+          historyBoundary: "push",
+          markDirty: true,
+          effects: {
+            commentResolved: {
+              commentId: command.commentId,
+            },
+          },
+        },
+      );
+    }
+    case "comment.reopen": {
+      const existingThread = state.document.review.comments[command.commentId];
+      if (!existingThread || existingThread.status === "detached") {
+        return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+      }
+      const reopenedComments = {
+        ...state.document.review.comments,
+        [command.commentId]: {
+          ...existingThread,
+          status: "open" as const,
+          isResolved: false,
+          resolvedAt: undefined,
+          resolution: undefined,
+        },
+      };
+      return createTransaction(
+        {
+          ...state,
+          document: {
+            ...state.document,
+            updatedAt: context.timestamp,
+            review: { ...state.document.review, comments: reopenedComments },
+          },
+          runtime: { ...state.runtime, activeCommentId: command.commentId },
+        },
+        {
+          historyBoundary: "push",
+          markDirty: true,
+          effects: { commentReopened: { commentId: command.commentId } },
+        },
+      );
+    }
+    case "comment.add-reply": {
+      const threadForReply = state.document.review.comments[command.commentId];
+      if (!threadForReply) {
+        return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+      }
+      // Block reply on resolved or detached threads (must reopen first)
+      if (threadForReply.status === "resolved" || threadForReply.status === "detached") {
+        return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+      }
+      const entryId = `${command.commentId}-entry-${(threadForReply.entries?.length ?? 0) + 1}`;
+      const newEntry = {
+        entryId,
+        authorId: command.authorId ?? threadForReply.createdBy ?? "unknown",
+        body: command.body,
+        createdAt: context.timestamp,
+      };
+      const updatedThread = {
+        ...threadForReply,
+        entries: [...(threadForReply.entries ?? []), newEntry],
+      };
+      const replyComments = {
+        ...state.document.review.comments,
+        [command.commentId]: updatedThread,
+      };
+      return createTransaction(
+        {
+          ...state,
+          document: {
+            ...state.document,
+            updatedAt: context.timestamp,
+            review: { ...state.document.review, comments: replyComments },
+          },
+        },
+        {
+          historyBoundary: "push",
+          markDirty: true,
+          effects: { commentReplyAdded: { commentId: command.commentId } },
+        },
+      );
+    }
+    case "comment.edit-body": {
+      const threadToEdit = state.document.review.comments[command.commentId];
+      if (!threadToEdit || !threadToEdit.entries?.length) {
+        return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+      }
+      const editedEntries = [...threadToEdit.entries];
+      editedEntries[0] = { ...editedEntries[0], body: command.body };
+      const editedThread = { ...threadToEdit, entries: editedEntries };
+      const editedComments = {
+        ...state.document.review.comments,
+        [command.commentId]: editedThread,
+      };
+      return createTransaction(
+        {
+          ...state,
+          document: {
+            ...state.document,
+            updatedAt: context.timestamp,
+            review: { ...state.document.review, comments: editedComments },
+          },
+        },
+        {
+          historyBoundary: "push",
+          markDirty: true,
+          effects: { commentBodyEdited: { commentId: command.commentId } },
+        },
+      );
+    }
+    case "change.accept":
+      return applyReviewCommand(
+        state,
+        createAcceptRevisionCommand(command.changeId, command.origin),
+        context.timestamp,
+      );
+    case "change.reject":
+      return applyReviewCommand(
+        state,
+        createRejectRevisionCommand(command.changeId, command.origin),
+        context.timestamp,
+      );
+    case "change.accept-all":
+      return applyReviewCommand(
+        state,
+        {
+          type: "review.accept-all-revisions",
+          ...(command.origin ? { origin: command.origin } : {}),
+        },
+        context.timestamp,
+      );
+    case "change.reject-all":
+      return applyReviewCommand(
+        state,
+        {
+          type: "review.reject-all-revisions",
+          ...(command.origin ? { origin: command.origin } : {}),
+        },
+        context.timestamp,
+      );
+  }
+}
+
+export function remapSelection(
+  selection: SelectionSnapshot,
+  mapping: TransactionMapping,
+): SelectionSnapshot {
+  const activeRange = mapAnchor(selection.activeRange, mapping);
+
+  if (activeRange.kind === "range") {
+    return {
+      anchor: activeRange.range.from,
+      head: activeRange.range.to,
+      isCollapsed: activeRange.range.from === activeRange.range.to,
+      activeRange,
+    };
+  }
+
+  if (activeRange.kind === "node") {
+    return createSelectionSnapshot(activeRange.at, activeRange.at);
+  }
+
+  return {
+    anchor: selection.anchor,
+    head: selection.head,
+    isCollapsed: selection.anchor === selection.head,
+    activeRange,
+  };
+}
+
+export function selectionChanged(
+  left: SelectionSnapshot,
+  right: SelectionSnapshot,
+): boolean {
+  return (
+    left.anchor !== right.anchor ||
+    left.head !== right.head ||
+    left.isCollapsed !== right.isCollapsed ||
+    !areAnchorsEqual(left.activeRange, right.activeRange)
+  );
+}
+
+function createTransaction(
+  nextState: EditorState,
+  options: {
+    mapping?: TransactionMapping;
+    historyBoundary: "push" | "skip";
+    markDirty: boolean;
+    effects?: Partial<TransactionEffects>;
+  },
+): EditorTransaction {
+  return {
+    nextState,
+    mapping: options.mapping ?? createEmptyMapping(),
+    historyBoundary: options.historyBoundary,
+    markDirty: options.markDirty,
+    effects: {
+      warningsAdded: options.effects?.warningsAdded ?? [],
+      warningsCleared: options.effects?.warningsCleared ?? [],
+      commentAdded: options.effects?.commentAdded,
+      commentResolved: options.effects?.commentResolved,
+      changeAccepted: options.effects?.changeAccepted,
+      changeRejected: options.effects?.changeRejected,
+    },
+  };
+}
+
+function normalizeSelection(selection: SelectionSnapshot): SelectionSnapshot {
+  if (selection.activeRange.kind === "range") {
+    return {
+      ...selection,
+      anchor: selection.activeRange.range.from,
+      head: selection.activeRange.range.to,
+      isCollapsed: selection.activeRange.range.from === selection.activeRange.range.to,
+    };
+  }
+
+  if (selection.activeRange.kind === "node") {
+    return createSelectionSnapshot(selection.activeRange.at, selection.activeRange.at);
+  }
+
+  return selection;
+}
+
+function applyTextCommand(
+  state: EditorState,
+  timestamp: string,
+  apply: (
+    document: CanonicalDocumentEnvelope,
+    selection: SelectionSnapshot,
+  ) => {
+    document: CanonicalDocumentEnvelope;
+    selection: SelectionSnapshot;
+    mapping: TransactionMapping;
+  },
+): EditorTransaction {
+  if (state.readOnly) {
+    return createTransaction(state, {
+      historyBoundary: "skip",
+      markDirty: false,
+    });
+  }
+
+  const result = apply(state.document, state.selection);
+  const reviewState = remapReviewStateAfterContentChange(
+    state,
+    result.document,
+    result.mapping,
+  );
+
+  return createTransaction(
+    {
+      ...state,
+      document: reviewState.document,
+      selection: result.selection,
+      warnings: reviewState.warnings,
+      runtime: {
+        ...state.runtime,
+        activeCommentId: reviewState.activeCommentId,
+      },
+    },
+    {
+      historyBoundary: "push",
+      markDirty: true,
+      mapping: result.mapping,
+      effects: reviewState.effects,
+    },
+  );
+}
+
+function applyReviewCommand(
+  state: EditorState,
+  command: ReviewCommand,
+  timestamp: string,
+): EditorTransaction {
+  if (state.readOnly) {
+    return createTransaction(state, {
+      historyBoundary: "skip",
+      markDirty: false,
+    });
+  }
+
+  const result = applyRevisionRuntimeCommand({
+    state: {
+      document: state.document,
+      store: createRevisionStoreFromState(state),
+    },
+    command,
+    timestamp,
+  });
+  const hasAppliedOutcome = result.outcomes.some((outcome) => outcome.kind === "applied");
+
+  if (!hasAppliedOutcome) {
+    return createTransaction(state, {
+      historyBoundary: "skip",
+      markDirty: false,
+    });
+  }
+
+  let selection = state.selection;
+  let comments = result.document.review.comments;
+  let warnings = state.warnings;
+  let activeCommentId = state.runtime.activeCommentId;
+  const mappingSteps: MappingStep[] = [];
+
+  for (const entry of result.mappings) {
+    if (entry.steps === 0) {
+      continue;
+    }
+
+    selection = remapSelection(selection, entry.mapping);
+    mappingSteps.push(...entry.mapping.steps);
+
+    const remappedComments = remapCommentThreads({
+      comments,
+      mapping: entry.mapping,
+      nextContent: result.document.content,
+      existingWarnings: mapWarningsThroughMapping(warnings, entry.mapping),
+    });
+    comments = remappedComments.comments;
+    warnings = remappedComments.warnings;
+    activeCommentId =
+      activeCommentId && comments[activeCommentId]
+        ? activeCommentId
+        : undefined;
+  }
+
+  warnings = mergeDetachedRevisionWarnings(result.store, warnings);
+
+  const nextDocument = {
+    ...result.document,
+    review: {
+      ...result.document.review,
+      comments,
+      revisions: toEditorRevisionRecords(result.store),
+    },
+  };
+  const appliedRevisionIds = result.effects.appliedRevisionIds;
+
+  return createTransaction(
+    {
+      ...state,
+      document: nextDocument,
+      selection,
+      warnings,
+      runtime: {
+        ...state.runtime,
+        activeCommentId,
+      },
+    },
+    {
+      historyBoundary: "push",
+      markDirty: true,
+      mapping: combineMappingSteps(mappingSteps),
+      effects: {
+        ...buildWarningEffects(state.warnings, warnings),
+        changeAccepted:
+          command.type === "review.accept-revision" && appliedRevisionIds[0]
+            ? {
+                changeId: appliedRevisionIds[0],
+              }
+            : undefined,
+        changeRejected:
+          command.type === "review.reject-revision" && appliedRevisionIds[0]
+            ? {
+                changeId: appliedRevisionIds[0],
+              }
+            : undefined,
+      },
+    },
+  );
+}
+
+function remapReviewStateAfterContentChange(
+  state: EditorState,
+  nextDocument: CanonicalDocumentEnvelope,
+  mapping: TransactionMapping,
+): {
+  document: CanonicalDocumentEnvelope;
+  warnings: EditorWarning[];
+  activeCommentId?: string;
+  effects: Pick<TransactionEffects, "warningsAdded" | "warningsCleared">;
+} {
+  const mappedWarnings = mapWarningsThroughMapping(state.warnings, mapping);
+  const remappedComments = remapCommentThreads({
+    comments: nextDocument.review.comments,
+    mapping,
+    nextContent: nextDocument.content,
+    existingWarnings: mappedWarnings,
+  });
+  const revisions = Object.fromEntries(
+    Object.entries(nextDocument.review.revisions).map(([changeId, revision]) => [
+      changeId,
+      {
+        ...revision,
+        anchor: mapAnchor(revision.anchor, mapping),
+      },
+    ]),
+  );
+  const activeCommentId =
+    state.runtime.activeCommentId &&
+    remappedComments.comments[state.runtime.activeCommentId]
+      ? state.runtime.activeCommentId
+      : undefined;
+  const warnings = remappedComments.warnings;
+
+  return {
+    document: {
+      ...nextDocument,
+      review: {
+        ...nextDocument.review,
+        comments: remappedComments.comments,
+        revisions,
+      },
+    },
+    warnings,
+    activeCommentId,
+    effects: buildWarningEffects(state.warnings, warnings),
+  };
+}
+
+function createRevisionStoreFromState(
+  state: Pick<EditorState, "document">,
+): RevisionStore {
+  return {
+    version: "revision-store/1",
+    revisions: Object.fromEntries(
+      Object.values(state.document.review.revisions).map((revision) => [
+        revision.changeId,
+        {
+          revisionId: revision.changeId,
+          kind: revision.kind,
+          anchor: revision.anchor,
+          authorId: revision.authorId ?? "unknown",
+          createdAt: revision.createdAt,
+          status: revision.status === "open" ? "active" : revision.status,
+          warningIds: [...(revision.warningIds ?? [])],
+          metadata: {
+            source: revision.metadata?.source ?? "runtime",
+            preserveOnlyReason: revision.metadata?.preserveOnlyReason,
+            importedRevisionForm: revision.metadata?.importedRevisionForm,
+            originalRevisionType: revision.metadata?.originalRevisionType,
+            ooxmlRevisionId: revision.metadata?.ooxmlRevisionId,
+          },
+        },
+      ]),
+    ),
+  };
+}
+
+function toEditorRevisionRecords(
+  store: RevisionStore,
+): EditorState["document"]["review"]["revisions"] {
+  return Object.fromEntries(
+    Object.values(store.revisions).map((revision) => [
+      revision.revisionId,
+      {
+        changeId: revision.revisionId,
+        kind: revision.kind,
+        anchor: revision.anchor,
+        authorId: revision.authorId,
+        createdAt: revision.createdAt,
+        warningIds: [...revision.warningIds],
+        metadata: {
+          source: revision.metadata.source,
+          preserveOnlyReason: revision.metadata.preserveOnlyReason,
+          importedRevisionForm: revision.metadata.importedRevisionForm,
+          originalRevisionType: revision.metadata.originalRevisionType,
+          ooxmlRevisionId: revision.metadata.ooxmlRevisionId,
+        },
+        status: revision.status === "active" ? "open" : revision.status,
+      },
+    ]),
+  );
+}
+
+function mapWarningsThroughMapping(
+  warnings: EditorWarning[],
+  mapping: TransactionMapping,
+): EditorWarning[] {
+  return warnings.map((warning) =>
+    warning.affectedAnchor
+      ? {
+          ...warning,
+          affectedAnchor: mapAnchor(warning.affectedAnchor, mapping),
+        }
+      : warning,
+  );
+}
+
+function buildWarningEffects(
+  previousWarnings: EditorWarning[],
+  nextWarnings: EditorWarning[],
+): Pick<TransactionEffects, "warningsAdded" | "warningsCleared"> {
+  const previousById = new Set(previousWarnings.map((warning) => warning.warningId));
+  const nextById = new Set(nextWarnings.map((warning) => warning.warningId));
+
+  return {
+    warningsAdded: nextWarnings.filter((warning) => !previousById.has(warning.warningId)),
+    warningsCleared: previousWarnings
+      .filter((warning) => !nextById.has(warning.warningId))
+      .map((warning) => ({
+        warningId: warning.warningId,
+        code: warning.code,
+      })),
+  };
+}
+
+function mergeDetachedRevisionWarnings(
+  store: RevisionStore,
+  existingWarnings: EditorWarning[],
+): EditorWarning[] {
+  const retainedWarnings = existingWarnings.filter(
+    (warning) =>
+      warning.code !== "revision_anchor_detached" ||
+      !warning.details ||
+      typeof warning.details.changeId !== "string" ||
+      store.revisions[warning.details.changeId]?.status === "detached",
+  );
+
+  const knownDetachedIds = new Set(
+    retainedWarnings
+      .filter((warning) => warning.code === "revision_anchor_detached")
+      .map((warning) =>
+        typeof warning.details?.changeId === "string"
+          ? warning.details.changeId
+          : undefined,
+      )
+      .filter((value): value is string => Boolean(value)),
+  );
+
+  const detachedWarnings = Object.values(store.revisions)
+    .filter(
+      (revision) =>
+        revision.status === "detached" && !knownDetachedIds.has(revision.revisionId),
+    )
+    .map((revision) => ({
+      warningId: `warning:revision-anchor-detached:${revision.revisionId}`,
+      code: "revision_anchor_detached" as const,
+      severity: "warning" as const,
+      message: `Revision ${revision.revisionId} detached after review remapping.`,
+      source: "review" as const,
+      affectedAnchor: revision.anchor.kind === "detached" ? revision.anchor : undefined,
+      details: {
+        changeId: revision.revisionId,
+        reason:
+          revision.anchor.kind === "detached"
+            ? revision.anchor.reason
+            : undefined,
+      },
+    }));
+
+  return [...retainedWarnings, ...detachedWarnings];
+}
+
+function combineMappingSteps(
+  steps: MappingStep[],
+): TransactionMapping {
+  return steps.length > 0
+    ? {
+        steps,
+      }
+    : createEmptyMapping();
+}