@beyondwork/docx-react-component 1.0.42 → 1.0.45

package/src/runtime/edit-dispatch/dispatch-text-command.ts

@@ -0,0 +1,98 @@
+import type { DocumentRuntime } from "../document-runtime.ts";
+import {
+  applyListAwareTextCommand,
+  type DispatchTextCommand,
+  type ListAwareDispatchDeps,
+  type ListAwareMutationResult,
+  type StoryMutationContext,
+} from "./list-aware-dispatch.ts";
+
+export type { DispatchTextCommand };
+
+// TODO(Part 2): collapse DispatchContext into the runtime layer.
+// The four UI-private helpers (getStoryMutationContext, dispatchStoryMutationResult,
+// resolveActiveParagraphContext, toRuntimeSelectionSnapshot) currently live in
+// WordReviewEditor.tsx for historical reasons but are pure runtime adapters with
+// no React/UI dependencies. The four-shell refactor (R.1-R.4) will move them
+// into src/runtime/edit-dispatch/, at which point this DI bundle dissolves.
+export interface DispatchContext extends ListAwareDispatchDeps {
+  getStoryMutationContext(
+    runtime: DocumentRuntime,
+    command?: string,
+  ): StoryMutationContext | null;
+  dispatchStoryMutationResult(
+    runtime: DocumentRuntime,
+    context: StoryMutationContext,
+    result: ListAwareMutationResult,
+    timestamp: string,
+  ): void;
+}
+
+export function dispatchTextCommand(
+  runtime: DocumentRuntime,
+  command: DispatchTextCommand,
+  deps: DispatchContext,
+): void {
+  const context = deps.getStoryMutationContext(runtime, getMountedTextCommandName(command));
+  if (!context) {
+    return;
+  }
+
+  const effectiveSelectionMode = runtime.getInteractionGuardSnapshot().effectiveMode;
+  const listAwareResult = applyListAwareTextCommand(context, command, deps);
+  if (effectiveSelectionMode === "suggest" && listAwareResult) {
+    runtime.emitBlockedCommand(getMountedTextCommandName(command), [{
+      code: "suggesting_unsupported",
+      message: "List structure changes are not supported in suggesting mode.",
+    }]);
+    return;
+  }
+
+  if (listAwareResult) {
+    deps.dispatchStoryMutationResult(runtime, context, listAwareResult, context.timestamp);
+    return;
+  }
+
+  switch (command.type) {
+    case "insert-text":
+      runtime.applyActiveStoryTextCommand({ type: "text.insert", text: command.text });
+      return;
+    case "delete-backward":
+      runtime.applyActiveStoryTextCommand({ type: "text.delete-backward" });
+      return;
+    case "delete-forward":
+      runtime.applyActiveStoryTextCommand({ type: "text.delete-forward" });
+      return;
+    case "insert-tab":
+      runtime.applyActiveStoryTextCommand({ type: "text.insert-tab" });
+      return;
+    case "outdent-tab":
+      runtime.applyActiveStoryTextCommand({ type: "text.outdent-tab" });
+      return;
+    case "insert-hard-break":
+      runtime.applyActiveStoryTextCommand({ type: "text.insert-hard-break" });
+      return;
+    case "split-paragraph":
+      runtime.applyActiveStoryTextCommand({ type: "paragraph.split" });
+      return;
+  }
+}
+
+function getMountedTextCommandName(command: DispatchTextCommand): string {
+  switch (command.type) {
+    case "insert-text":
+      return "text.insert";
+    case "delete-backward":
+      return "text.delete-backward";
+    case "delete-forward":
+      return "text.delete-forward";
+    case "insert-tab":
+      return "text.insert-tab";
+    case "outdent-tab":
+      return "text.outdent-tab";
+    case "insert-hard-break":
+      return "text.insert-hard-break";
+    case "split-paragraph":
+      return "paragraph.split";
+  }
+}

package/src/runtime/edit-dispatch/index.ts

@@ -0,0 +1,2 @@
+export { dispatchTextCommand } from "./dispatch-text-command.ts";
+export type { DispatchTextCommand, DispatchContext } from "./dispatch-text-command.ts";

package/src/runtime/edit-dispatch/list-aware-dispatch.ts

@@ -0,0 +1,125 @@
+import type {
+  EditorSessionState,
+  EditorStoryTarget,
+  RuntimeRenderSnapshot,
+  SelectionSnapshot as PublicSelectionSnapshot,
+  SurfaceBlockSnapshot,
+} from "../../api/public-types";
+import { type SelectionSnapshot as InternalSelectionSnapshot } from "../../core/state/editor-state.ts";
+import {
+  backspaceAtListStart,
+  indentListItems,
+  outdentListItems,
+  splitListParagraph,
+} from "../../core/commands/list-commands.ts";
+
+export type DispatchTextCommand =
+  | { type: "insert-text"; text: string }
+  | { type: "delete-backward" }
+  | { type: "delete-forward" }
+  | { type: "insert-tab" }
+  | { type: "outdent-tab" }
+  | { type: "insert-hard-break" }
+  | { type: "split-paragraph" };
+
+export interface ListAwareParagraphContext {
+  paragraphIndex: number;
+  paragraph: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>;
+  atParagraphStart: boolean;
+  isEmpty: boolean;
+}
+
+export interface StoryMutationContext {
+  timestamp: string;
+  activeStory: EditorStoryTarget;
+  persistedDocument: EditorSessionState["canonicalDocument"];
+  localDocument: EditorSessionState["canonicalDocument"];
+  localSnapshot: RuntimeRenderSnapshot;
+}
+
+export interface ListAwareMutationResult {
+  changed: boolean;
+  document: EditorSessionState["canonicalDocument"];
+  selection: InternalSelectionSnapshot;
+}
+
+export interface ListAwareDispatchDeps {
+  resolveActiveParagraphContext(
+    snapshot: Pick<RuntimeRenderSnapshot, "surface" | "selection">,
+  ): ListAwareParagraphContext | null;
+  toRuntimeSelectionSnapshot(selection: PublicSelectionSnapshot): InternalSelectionSnapshot;
+}
+
+export function applyListAwareTextCommand(
+  context: StoryMutationContext,
+  command: DispatchTextCommand,
+  deps: ListAwareDispatchDeps,
+): ListAwareMutationResult | null {
+  const paragraphContext = deps.resolveActiveParagraphContext(context.localSnapshot);
+  if (!paragraphContext?.paragraph.numbering) {
+    return null;
+  }
+
+  switch (command.type) {
+    case "insert-tab": {
+      const result = indentListItems(
+        context.localDocument,
+        [paragraphContext.paragraphIndex],
+        { timestamp: context.timestamp },
+      );
+      return createListMutationResult(result, context.localSnapshot.selection, deps);
+    }
+    case "outdent-tab": {
+      const result = outdentListItems(
+        context.localDocument,
+        [paragraphContext.paragraphIndex],
+        { timestamp: context.timestamp },
+      );
+      return createListMutationResult(result, context.localSnapshot.selection, deps);
+    }
+    case "delete-backward": {
+      if (!paragraphContext.atParagraphStart || !context.localSnapshot.selection.isCollapsed) {
+        return null;
+      }
+      const result = backspaceAtListStart(
+        context.localDocument,
+        paragraphContext.paragraphIndex,
+        { timestamp: context.timestamp },
+      );
+      return result.handled
+        ? createListMutationResult(result, context.localSnapshot.selection, deps)
+        : null;
+    }
+    case "split-paragraph": {
+      if (!context.localSnapshot.selection.isCollapsed || !paragraphContext.isEmpty) {
+        return null;
+      }
+      const result = splitListParagraph(
+        context.localDocument,
+        paragraphContext.paragraphIndex,
+        true,
+        { timestamp: context.timestamp },
+      );
+      return result.action === "split"
+        ? null
+        : createListMutationResult(result, context.localSnapshot.selection, deps);
+    }
+    default:
+      return null;
+  }
+}
+
+function createListMutationResult(
+  result: {
+    document: EditorSessionState["canonicalDocument"];
+    affectedParagraphIndexes: number[];
+  },
+  selection: RuntimeRenderSnapshot["selection"],
+  deps: ListAwareDispatchDeps,
+): ListAwareMutationResult {
+  return {
+    changed: result.affectedParagraphIndexes.length > 0,
+    document: result.document,
+    selection: deps.toRuntimeSelectionSnapshot(selection),
+  };
+}