@beyondwork/docx-react-component 1.0.28 → 1.0.30

package/src/ui/headless/selection-tool-resolver.ts

@@ -0,0 +1,752 @@
+import type {
+  EditorStoryTarget,
+  FormattingStateSnapshot,
+  SuggestionEntrySnapshot,
+  TrackedChangeEntrySnapshot,
+  WorkflowScopeSnapshot,
+} from "../../api/public-types";
+import { storyTargetsEqual } from "../../core/selection/mapping";
+import type { SelectionToolResolverInput } from "./selection-tool-context";
+import type {
+  ActiveSelectionToolModel,
+  BlockedExplainerSelectionToolModel,
+  CommentThreadSelectionToolModel,
+  FormattingInlineSelectionToolModel,
+  SelectionToolBadge,
+  StructureContextSelectionToolModel,
+  SuggestionReviewSelectionToolModel,
+  WorkflowTaskSelectionToolModel,
+} from "./selection-tool-types";
+
+export function resolveActiveSelectionTool(
+  input: SelectionToolResolverInput,
+): ActiveSelectionToolModel | null {
+  const suggestionTool = buildSuggestionReviewSelectionToolModel(input);
+  const commentTool = buildCommentThreadSelectionToolModel(input);
+  const workflowTool = buildWorkflowTaskSelectionToolModel(input);
+  const structureTool = buildStructureContextSelectionToolModel(input);
+  // Semantic targets beat generic range formatting so structure tools do not
+  // leak preview text when the user is acting on a table, image, or object.
+  const formattingTool = buildFormattingInlineSelectionToolModel(input);
+  const blockedTool = buildBlockedExplainerSelectionToolModel(input);
+  const resolvedTool =
+    suggestionTool ??
+    commentTool ??
+    workflowTool ??
+    structureTool ??
+    formattingTool ??
+    blockedTool;
+
+  return resolvedTool;
+}
+
+export function buildFormattingInlineSelectionToolModel(
+  input: SelectionToolResolverInput,
+): FormattingInlineSelectionToolModel | null {
+  const {
+    snapshot,
+    viewState,
+    capabilities,
+    documentNavigation,
+    styleCatalog,
+    formattingState,
+    workflowScopeSnapshot,
+    interactionGuardSnapshot,
+    addCommentDisabledReason,
+  } = input;
+
+  if (
+    !snapshot.surface ||
+    snapshot.selection.isCollapsed ||
+    snapshot.selection.activeRange.kind !== "range" ||
+    viewState.viewMode === "view"
+  ) {
+    return null;
+  }
+
+  const previewText = summarizeSelectionPreview(snapshot);
+  if (!previewText) {
+    return null;
+  }
+
+  const workflowPosture = resolveSelectionWorkflowPosture(
+    snapshot,
+    viewState.activeStory,
+    workflowScopeSnapshot,
+    interactionGuardSnapshot,
+  );
+  const targetAccess = getSelectionTargetAccess(input, workflowPosture);
+  const formattingCapability = getCommandCapability(input, "formatting", workflowPosture);
+
+  if (!capabilities.canEdit && !formattingCapability.supported) {
+    return null;
+  }
+  if (targetAccess === "comment-only" || targetAccess === "view-only" || targetAccess === "blocked") {
+    return null;
+  }
+  if (Boolean(input.preferListStructureContext) && Boolean(viewState.activeListContext?.isOrdered)) {
+    return null;
+  }
+  const badges = [
+    createSelectionToolStoryBadge(viewState.activeStory),
+    createSelectionToolWorkflowBadge(workflowPosture),
+    viewState.workspaceMode === "page" && documentNavigation.pageCount > 0
+      ? { label: `Page ${documentNavigation.activePageIndex + 1}` as const }
+      : null,
+    formattingState ? createSelectionToolStyleBadge(styleCatalog.paragraphs, formattingState) : null,
+    createSelectionToolListBadge(viewState.activeListContext),
+  ].filter((badge): badge is SelectionToolBadge => Boolean(badge));
+
+  const canToggleFormatting = formattingCapability.supported;
+  const canAddComment = capabilities.canAddComment;
+  const disabledReason = resolveToolDisabledReason(
+    canToggleFormatting ? undefined : formattingCapability.blockedReason,
+    workflowPosture.disabledReason,
+    canAddComment ? undefined : addCommentDisabledReason,
+  );
+
+  return {
+    kind: "formatting-inline",
+    previewText,
+    badges,
+    canToggleFormatting,
+    boldActive: formattingState?.bold ?? false,
+    italicActive: formattingState?.italic ?? false,
+    underlineActive: formattingState?.underline ?? false,
+    canAddComment,
+    ...(disabledReason ? { disabledReason } : {}),
+  };
+}
+
+export function buildSuggestionReviewSelectionToolModel(
+  input: SelectionToolResolverInput,
+): SuggestionReviewSelectionToolModel | null {
+  const {
+    snapshot,
+    viewState,
+    capabilities,
+    workflowScopeSnapshot,
+    interactionGuardSnapshot,
+    suggestionsSnapshot,
+    activeRevisionId,
+    suppressedSuggestionRevisionId,
+    addCommentDisabledReason,
+    activeTableContext,
+    activeImageContext,
+    activeObjectContext,
+    activeListContext,
+    preferListStructureContext,
+  } = input;
+
+  if (
+    !snapshot.surface ||
+    !capabilities.canEdit ||
+    viewState.viewMode === "view"
+  ) {
+    return null;
+  }
+  if (
+    activeTableContext ||
+    activeImageContext ||
+    activeObjectContext ||
+    (preferListStructureContext && activeListContext)
+  ) {
+    return null;
+  }
+
+  const activeRange =
+    !snapshot.selection.isCollapsed && snapshot.selection.activeRange.kind === "range"
+      ? snapshot.selection.activeRange
+      : null;
+  const selectionFrom = activeRange
+    ? Math.min(activeRange.from, activeRange.to)
+    : null;
+  const selectionTo = activeRange
+    ? Math.max(activeRange.from, activeRange.to)
+    : null;
+  const matchingScope = findSelectionMatchingScope(
+    activeRange,
+    viewState.activeStory,
+    workflowScopeSnapshot,
+  );
+
+  const candidateSuggestions = suggestionsSnapshot?.suggestions.filter((suggestion) =>
+    storyTargetsEqual(suggestion.storyTarget, viewState.activeStory) &&
+    suggestion.status === "active" &&
+    suggestion.actionability === "actionable" &&
+    suggestion.anchor.kind === "range" &&
+    (
+      (
+        activeRevisionId !== undefined &&
+        suggestion.changeIds.includes(activeRevisionId) &&
+        selectionMatchesSuggestion(snapshot.selection, suggestion)
+      ) ||
+      (
+        selectionFrom !== null &&
+        selectionTo !== null &&
+        rangesOverlap(
+          selectionFrom,
+          selectionTo,
+          suggestion.anchor.from,
+          suggestion.anchor.to,
+        )
+      )
+    )
+  ) ?? [];
+
+  const focusedSuggestion = (
+    activeRevisionId
+      ? candidateSuggestions.find((suggestion) => suggestion.changeIds.includes(activeRevisionId))
+      : null
+  ) ?? candidateSuggestions[0];
+
+  if (!focusedSuggestion || focusedSuggestion.suggestionId === suppressedSuggestionRevisionId) {
+    return null;
+  }
+
+  const badges = [
+    createSelectionToolStoryBadge(viewState.activeStory),
+    matchingScope?.label
+      ? {
+          label: matchingScope.label,
+          tone: "accent" as const,
+        }
+      : workflowScopeSnapshot?.activeWorkItem?.title
+        ? {
+            label: workflowScopeSnapshot.activeWorkItem.title,
+            tone: "accent" as const,
+          }
+        : null,
+  ].filter((badge): badge is SelectionToolBadge => Boolean(badge));
+  const workflowPosture = resolveSelectionWorkflowPosture(
+    snapshot,
+    viewState.activeStory,
+    workflowScopeSnapshot,
+    interactionGuardSnapshot,
+  );
+  const targetAccess = getSelectionTargetAccess(input, workflowPosture);
+  const canReviewSuggestion = workflowPosture.mode === "edit" || workflowPosture.mode === "suggest";
+  const canAddComment = targetAccess === "view-only" || targetAccess === "blocked"
+    ? false
+    : capabilities.canAddComment;
+  const disabledReason = resolveToolDisabledReason(
+    workflowPosture.disabledReason,
+    canAddComment ? undefined : addCommentDisabledReason,
+  );
+
+  return {
+    kind: "suggestion-review",
+    suggestionId: focusedSuggestion.suggestionId,
+    changeIds: focusedSuggestion.changeIds,
+    kindLabel: getSuggestionKindLabel(focusedSuggestion.kind),
+    previewText:
+      focusedSuggestion.excerpt ??
+      focusedSuggestion.detail ??
+      "Suggested change",
+    badges,
+    canAccept: canReviewSuggestion && capabilities.canAcceptChange && focusedSuggestion.canAccept,
+    canReject: canReviewSuggestion && capabilities.canRejectChange && focusedSuggestion.canReject,
+    canEditSuggestion: canReviewSuggestion && focusedSuggestion.editable,
+    canAddComment,
+    ...(disabledReason ? { disabledReason } : {}),
+  };
+}
+
+function selectionMatchesSuggestion(
+  selection: SelectionToolResolverInput["snapshot"]["selection"],
+  suggestion: SuggestionEntrySnapshot,
+): boolean {
+  if (suggestion.anchor.kind !== "range" || selection.activeRange.kind !== "range") {
+    return false;
+  }
+  if (selection.isCollapsed) {
+    const point = selection.activeRange.from;
+    return point >= suggestion.anchor.from && point <= suggestion.anchor.to;
+  }
+  const selectionFrom = Math.min(selection.activeRange.from, selection.activeRange.to);
+  const selectionTo = Math.max(selection.activeRange.from, selection.activeRange.to);
+  return rangesOverlap(
+    selectionFrom,
+    selectionTo,
+    suggestion.anchor.from,
+    suggestion.anchor.to,
+  );
+}
+
+function findSelectionMatchingScope(
+  activeRange: SelectionToolResolverInput["snapshot"]["selection"]["activeRange"] | null,
+  activeStory: EditorStoryTarget,
+  workflowScopeSnapshot?: WorkflowScopeSnapshot | null,
+) {
+  if (!activeRange || activeRange.kind !== "range" || !workflowScopeSnapshot) {
+    return null;
+  }
+  return workflowScopeSnapshot.scopes.find((scope) => {
+    const scopeStoryTarget = scope.storyTarget ?? { kind: "main" as const };
+    if (!storyTargetsEqual(scopeStoryTarget, activeStory)) {
+      return false;
+    }
+    if (scope.anchor.kind === "detached") {
+      return false;
+    }
+    const scopeFrom = scope.anchor.kind === "range" ? scope.anchor.from : scope.anchor.at;
+    const scopeTo = scope.anchor.kind === "range" ? scope.anchor.to : scope.anchor.at;
+    return activeRange.from >= scopeFrom && activeRange.to <= scopeTo;
+  }) ?? null;
+}
+
+export function buildStructureContextSelectionToolModel(
+  input: SelectionToolResolverInput,
+): StructureContextSelectionToolModel | null {
+  const workflowPosture = resolveSelectionWorkflowPosture(
+    input.snapshot,
+    input.viewState.activeStory,
+    input.workflowScopeSnapshot,
+    input.interactionGuardSnapshot,
+  );
+  const structureCapability = getCommandCapability(input, "structure", workflowPosture);
+  const canMutate = structureCapability.supported;
+  const badges = [
+    createSelectionToolStoryBadge(input.viewState.activeStory),
+    createSelectionToolWorkflowBadge(workflowPosture),
+  ].filter((badge): badge is SelectionToolBadge => Boolean(badge));
+  const disabledReason = resolveToolDisabledReason(
+    canMutate ? undefined : structureCapability.blockedReason,
+    canMutate ? undefined : workflowPosture.disabledReason,
+  );
+
+  if (!structureCapability.supported) {
+    return null;
+  }
+
+  if (input.activeImageContext) {
+    return {
+      kind: "structure-context",
+      structureKind: "image",
+      badges,
+      activeImage: input.activeImageContext,
+      canMutate,
+      ...(disabledReason ? { disabledReason } : {}),
+    };
+  }
+
+  if (input.activeObjectContext) {
+    return {
+      kind: "structure-context",
+      structureKind: "object",
+      badges,
+      activeObject: input.activeObjectContext,
+      canMutate,
+      ...(disabledReason ? { disabledReason } : {}),
+    };
+  }
+
+  const isTableContext = Boolean(
+    input.formattingState?.breadcrumb.some(
+      (item) => item.kind === "table" || item.kind === "table_cell" || item.kind === "table_row",
+    ),
+  );
+  const isTableTextRangeContext =
+    input.activeTableContext?.selectionKind === "text" &&
+    !input.snapshot.selection.isCollapsed;
+  if (isTableTextRangeContext) {
+    return null;
+  }
+  if (isTableContext) {
+    return {
+      kind: "structure-context",
+      structureKind: "table",
+      badges,
+      tableStyles: input.styleCatalog.tables,
+      activeTable: input.activeTableContext ?? null,
+      canMutate,
+      ...(disabledReason ? { disabledReason } : {}),
+    };
+  }
+
+  if (Boolean(input.preferListStructureContext) && Boolean(input.viewState.activeListContext?.isOrdered)) {
+    return {
+      kind: "structure-context",
+      structureKind: "list",
+      badges,
+      activeListContext: input.viewState.activeListContext,
+      canMutate,
+      ...(disabledReason ? { disabledReason } : {}),
+    };
+  }
+
+  return null;
+}
+
+export function buildWorkflowTaskSelectionToolModel(
+  input: SelectionToolResolverInput,
+): WorkflowTaskSelectionToolModel | null {
+  const workflowPosture = resolveSelectionWorkflowPosture(
+    input.snapshot,
+    input.viewState.activeStory,
+    input.workflowScopeSnapshot,
+    input.interactionGuardSnapshot,
+  );
+  const targetAccess = getSelectionTargetAccess(input, workflowPosture);
+  const activeWorkItem = input.workflowScopeSnapshot?.activeWorkItem;
+  if (!activeWorkItem || targetAccess === "direct-edit" || targetAccess === "blocked") {
+    return null;
+  }
+
+  return {
+    kind: "workflow-task",
+    badges: [
+      { label: activeWorkItem.title, tone: "accent" },
+      ...(
+        workflowPosture.mode === "suggest"
+          ? [{ label: "Suggest", tone: "accent" as const }]
+          : workflowPosture.mode === "comment"
+            ? [{ label: "Comment only", tone: "accent" as const }]
+            : workflowPosture.mode === "view"
+              ? [{ label: "View only" }]
+              : [{ label: "Blocked" }]
+      ),
+    ],
+    workflowTitle: activeWorkItem.title,
+    workflowDetail: activeWorkItem.description,
+    ...(workflowPosture.disabledReason ? { disabledReason: workflowPosture.disabledReason } : {}),
+  };
+}
+
+export function buildCommentThreadSelectionToolModel(
+  input: SelectionToolResolverInput,
+): CommentThreadSelectionToolModel | null {
+  const workflowPosture = resolveSelectionWorkflowPosture(
+    input.snapshot,
+    input.viewState.activeStory,
+    input.workflowScopeSnapshot,
+    input.interactionGuardSnapshot,
+  );
+  const targetAccess = getSelectionTargetAccess(input, workflowPosture);
+  if (!input.activeCommentThread || !input.snapshot.selection.isCollapsed) {
+    return null;
+  }
+
+  const canAddComment = targetAccess !== "view-only" &&
+    targetAccess !== "blocked" &&
+    input.capabilities.canAddComment;
+  return {
+    kind: "comment-thread",
+    badges: [
+      { label: input.activeCommentThread.status === "open" ? "Comment" : "Resolved comment", tone: "accent" },
+    ],
+    previewText: input.activeCommentThread.excerpt,
+    thread: input.activeCommentThread,
+    canAddComment,
+    ...(workflowPosture.disabledReason ? { disabledReason: workflowPosture.disabledReason } : {}),
+  };
+}
+
+export function buildBlockedExplainerSelectionToolModel(
+  input: SelectionToolResolverInput,
+): BlockedExplainerSelectionToolModel | null {
+  const workflowPosture = resolveSelectionWorkflowPosture(
+    input.snapshot,
+    input.viewState.activeStory,
+    input.workflowScopeSnapshot,
+    input.interactionGuardSnapshot,
+  );
+
+  if (!workflowPosture.disabledReason) {
+    return null;
+  }
+
+  if (workflowPosture.mode === "edit") {
+    return null;
+  }
+
+  return {
+    kind: "blocked-explainer",
+    badges: [
+      createSelectionToolStoryBadge(input.viewState.activeStory),
+      createSelectionToolWorkflowBadge(workflowPosture),
+    ].filter((badge): badge is SelectionToolBadge => Boolean(badge)),
+    disabledReason: workflowPosture.disabledReason,
+  };
+}
+
+function createSelectionToolStoryBadge(target: EditorStoryTarget): SelectionToolBadge | null {
+  if (target.kind === "main") {
+    return null;
+  }
+
+  return {
+    label:
+      target.kind === "header"
+        ? target.variant === "default"
+          ? "Header"
+          : `Header ${target.variant}`
+        : target.kind === "footer"
+          ? target.variant === "default"
+            ? "Footer"
+            : `Footer ${target.variant}`
+          : target.kind === "footnote"
+            ? "Footnote"
+            : "Endnote",
+    tone: "accent",
+  };
+}
+
+function createSelectionToolStyleBadge(
+  paragraphStyles: Array<{ styleId: string; displayName: string; isDefault: boolean }>,
+  formattingState: FormattingStateSnapshot,
+): SelectionToolBadge | null {
+  if (!formattingState.paragraphStyleId) {
+    return null;
+  }
+
+  const styleEntry = paragraphStyles.find(
+    (entry) => entry.styleId === formattingState.paragraphStyleId,
+  );
+  if (!styleEntry || styleEntry.isDefault) {
+    return null;
+  }
+
+  return { label: styleEntry.displayName };
+}
+
+function createSelectionToolListBadge(
+  activeListContext: SelectionToolResolverInput["viewState"]["activeListContext"],
+): SelectionToolBadge | null {
+  if (!activeListContext) {
+    return null;
+  }
+
+  return {
+    label: activeListContext.isOrdered ? "Numbered list" : "Bulleted list",
+  };
+}
+
+function createSelectionToolWorkflowBadge(
+  posture: ReturnType<typeof resolveSelectionWorkflowPosture>,
+): SelectionToolBadge | null {
+  switch (posture.mode) {
+    case "suggest":
+      return { label: "Suggest", tone: "accent" };
+    case "comment":
+      return { label: "Comment only", tone: "accent" };
+    case "view":
+      return { label: "View only" };
+    case "blocked":
+      return { label: "Blocked" };
+    default:
+      return null;
+  }
+}
+
+function getSelectionTargetAccess(
+  input: SelectionToolResolverInput,
+  workflowPosture: ReturnType<typeof resolveSelectionWorkflowPosture>,
+): NonNullable<NonNullable<SelectionToolResolverInput["interactionGuardSnapshot"]>["targetAccess"]> {
+  if (input.interactionGuardSnapshot?.targetAccess) {
+    return input.interactionGuardSnapshot.targetAccess;
+  }
+
+  switch (workflowPosture.mode) {
+    case "suggest":
+      return "suggest";
+    case "comment":
+      return "comment-only";
+    case "view":
+      return "view-only";
+    case "blocked":
+      return "blocked";
+    default:
+      return "direct-edit";
+  }
+}
+
+function getCommandCapability(
+  input: SelectionToolResolverInput,
+  family: "text" | "formatting" | "structure",
+  workflowPosture: ReturnType<typeof resolveSelectionWorkflowPosture>,
+): {
+  supported: boolean;
+  blockedReason?: string;
+} {
+  const explicitCapability = input.interactionGuardSnapshot?.commandCapabilities?.find(
+    (entry) => entry.family === family,
+  );
+  if (explicitCapability) {
+    return {
+      supported: explicitCapability.supported,
+      blockedReason: explicitCapability.blockedReasons[0]?.message,
+    };
+  }
+
+  const targetAccess = getSelectionTargetAccess(input, workflowPosture);
+  const supported = Boolean(input.capabilities.canEdit) && targetAccess === "direct-edit";
+  return {
+    supported,
+    blockedReason: supported ? undefined : input.interactionGuardSnapshot?.disabledReason,
+  };
+}
+
+function resolveToolDisabledReason(
+  ...reasons: Array<string | null | undefined>
+): string | undefined {
+  return reasons.find((reason): reason is string => typeof reason === "string" && reason.length > 0);
+}
+
+export function resolveSelectionWorkflowPosture(
+  snapshot: SelectionToolResolverInput["snapshot"],
+  activeStory: EditorStoryTarget,
+  workflowScopeSnapshot?: WorkflowScopeSnapshot | null,
+  interactionGuardSnapshot?: SelectionToolResolverInput["interactionGuardSnapshot"],
+): {
+  mode: "edit" | "suggest" | "comment" | "view" | "blocked";
+  disabledReason?: string;
+} {
+  const blockedReasons =
+    interactionGuardSnapshot?.blockedReasons ??
+    workflowScopeSnapshot?.blockedReasons ??
+    [];
+  const blockingReason = blockedReasons[0];
+  if (blockingReason) {
+    if (blockingReason.code === "workflow_comment_only") {
+      return {
+        mode: "comment",
+        disabledReason: blockingReason.message,
+      };
+    }
+    if (blockingReason.code === "workflow_view_only") {
+      return {
+        mode: "view",
+        disabledReason: blockingReason.message,
+      };
+    }
+    return {
+      mode: "blocked",
+      disabledReason: blockingReason.message,
+    };
+  }
+
+  if (interactionGuardSnapshot) {
+    if (interactionGuardSnapshot.effectiveMode === "suggest") {
+      return {
+        mode: "suggest",
+        disabledReason:
+          interactionGuardSnapshot.disabledReason ??
+          "Suggestion authoring is active here; direct formatting changes are blocked.",
+      };
+    }
+    if (interactionGuardSnapshot.effectiveMode === "comment") {
+      return {
+        mode: "comment",
+        disabledReason: interactionGuardSnapshot.disabledReason,
+      };
+    }
+    if (interactionGuardSnapshot.effectiveMode === "view") {
+      return {
+        mode: "view",
+        disabledReason: interactionGuardSnapshot.disabledReason,
+      };
+    }
+    if (interactionGuardSnapshot.effectiveMode === "blocked") {
+      return {
+        mode: "blocked",
+        disabledReason: interactionGuardSnapshot.disabledReason,
+      };
+    }
+  }
+
+  const activeRange =
+    !snapshot.selection.isCollapsed && snapshot.selection.activeRange.kind === "range"
+      ? snapshot.selection.activeRange
+      : null;
+  const matchingScope = activeRange && workflowScopeSnapshot
+    ? workflowScopeSnapshot.scopes.find((scope) => {
+        const scopeStoryTarget = scope.storyTarget ?? { kind: "main" as const };
+        if (!storyTargetsEqual(scopeStoryTarget, activeStory)) {
+          return false;
+        }
+        if (scope.anchor.kind === "detached") {
+          return false;
+        }
+        const scopeFrom = scope.anchor.kind === "range" ? scope.anchor.from : scope.anchor.at;
+        const scopeTo = scope.anchor.kind === "range" ? scope.anchor.to : scope.anchor.at;
+        return activeRange.from >= scopeFrom && activeRange.to <= scopeTo;
+      })
+    : null;
+
+  if (matchingScope?.mode === "suggest") {
+    return {
+      mode: "suggest",
+      disabledReason: "Suggestion authoring is active here; direct formatting changes are blocked.",
+    };
+  }
+  if (matchingScope?.mode === "comment") {
+    return {
+      mode: "comment",
+      disabledReason: `Scope "${matchingScope.label ?? matchingScope.scopeId}" allows comments only.`,
+    };
+  }
+  if (matchingScope?.mode === "view") {
+    return {
+      mode: "view",
+      disabledReason: `Scope "${matchingScope.label ?? matchingScope.scopeId}" is view-only.`,
+    };
+  }
+  return { mode: "edit" };
+}
+
+function summarizeSelectionPreview(snapshot: SelectionToolResolverInput["snapshot"]): string | null {
+  if (!snapshot.surface || snapshot.selection.isCollapsed) {
+    return null;
+  }
+
+  const range = snapshot.selection.activeRange;
+  if (range.kind !== "range") {
+    return "Selected range";
+  }
+
+  const preview = snapshot.surface.plainText
+    .slice(range.from, range.to)
+    .replace(/\s+/g, " ")
+    .trim();
+
+  if (!preview) {
+    return "Selected range";
+  }
+
+  return preview.length > 48 ? `${preview.slice(0, 45)}...` : preview;
+}
+
+function rangesOverlap(
+  leftFrom: number,
+  leftTo: number,
+  rightFrom: number,
+  rightTo: number,
+): boolean {
+  return leftFrom < rightTo && rightFrom < leftTo;
+}
+
+function getSuggestionKindLabel(
+  kind: TrackedChangeEntrySnapshot["kind"] | SuggestionEntrySnapshot["kind"],
+): string {
+  switch (kind) {
+    case "insertion":
+      return "Suggested insertion";
+    case "deletion":
+      return "Suggested deletion";
+    case "replacement":
+      return "Suggested replacement";
+    case "formatting":
+    case "formatting-change":
+      return "Suggested formatting change";
+    case "property-change":
+    case "paragraph-property-change":
+      return "Suggested property change";
+    case "move":
+      return "Suggested move";
+    case "structural-change":
+      return "Suggested structural change";
+    case "object-change":
+      return "Suggested object change";
+  }
+}