@beyondwork/docx-react-component 1.0.0 → 1.0.1

package/src/core/commands/index.ts

@@ -1,1013 +0,0 @@
-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",
-          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();
-}