@beyondwork/docx-react-component 1.0.41 → 1.0.42

package/src/core/commands/index.ts

@@ -38,6 +38,52 @@ import { remapCommentThreads } from "../../review/store/comment-remapping.ts";
 import { collectScopeTagTouches } from "../../review/store/scope-tag-diff.ts";
 import { applyRevisionRuntimeCommand } from "../../runtime/revision-runtime.ts";
 import type { RevisionStore } from "../../review/store/revision-store.ts";
+import type {
+  HeaderFooterLinkPatch,
+  HostAnnotationOverlay,
+  InsertTableOptions,
+  RuntimeRenderSnapshot,
+  SectionBreakType,
+  SectionLayoutPatch,
+  SectionPageNumberingPatch,
+  WorkflowMetadataDefinition,
+  WorkflowMetadataEntry,
+  WorkflowOverlay,
+} from "../../api/public-types.ts";
+import {
+  applyFormattingOperationToDocument,
+  type FormattingOperation,
+} from "./formatting-commands.ts";
+import {
+  applyParagraphStyleToDocument,
+  applyTableStyleToDocument,
+} from "./style-commands.ts";
+import {
+  continueNumbering,
+  indentListItems,
+  outdentListItems,
+  restartNumbering,
+  toggleBulletedList,
+  toggleNumberedList,
+} from "./list-commands.ts";
+import {
+  applyTableStructureOperation,
+  type TableStructureOperation,
+} from "./table-structure-commands.ts";
+import {
+  insertImage,
+  repositionFloatingImage,
+  resizeImage,
+} from "./image-commands.ts";
+import {
+  insertSectionBreakAfterSectionIndex,
+  deleteSectionBreakAtSectionIndex,
+  updateSectionLayoutAtSectionIndex,
+  setSectionPageNumberingAtSectionIndex,
+  setHeaderFooterLinkAtSectionIndex,
+} from "./section-layout-commands.ts";
+import { insertPageBreak, insertTable } from "./text-commands.ts";
+import type { TableSelectionDescriptor } from "../../runtime/table-commands.ts";
 
 export interface CommandOrigin {
   source:
@@ -170,6 +216,149 @@ export type EditorCommand =
   | {
       type: "history.redo";
       origin?: CommandOrigin;
+    }
+  | {
+      type: "workflow.set-overlay";
+      overlay: WorkflowOverlay;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "workflow.clear-overlay";
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "workflow.set-metadata-definitions";
+      definitions: WorkflowMetadataDefinition[];
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "workflow.clear-metadata-definitions";
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "workflow.set-metadata-entries";
+      entries: WorkflowMetadataEntry[];
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "workflow.clear-metadata-entries";
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "host-annotation.set-overlay";
+      overlay: HostAnnotationOverlay;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "host-annotation.clear-overlay";
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "formatting.apply";
+      operation: FormattingOperation;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "style.set-paragraph";
+      styleId: string | null;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "style.set-table";
+      styleId: string | null;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "list.toggle";
+      kind: "bulleted" | "numbered";
+      paragraphIndexes: readonly number[];
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "list.indent";
+      paragraphIndexes: readonly number[];
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "list.outdent";
+      paragraphIndexes: readonly number[];
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "list.restart-numbering";
+      paragraphIndex: number;
+      startAt?: number;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "list.continue-numbering";
+      paragraphIndex: number;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "table.apply-structure";
+      operation: TableStructureOperation;
+      selectionDescriptor: TableSelectionDescriptor | null;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "image.insert";
+      data: string;
+      mimeType: string;
+      width?: number;
+      height?: number;
+      altText?: string;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "image.set-layout";
+      mediaId: string;
+      dimensions: { widthEmu: number; heightEmu: number };
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "image.set-frame";
+      mediaId: string;
+      offsets: { horizontalOffsetEmu?: number; verticalOffsetEmu?: number };
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "section.insert-break";
+      sectionIndex: number;
+      breakType: SectionBreakType;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "section.delete-break";
+      sectionIndex: number;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "section.update-layout";
+      sectionIndex: number;
+      patch: SectionLayoutPatch;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "section.set-page-numbering";
+      sectionIndex: number;
+      patch: SectionPageNumberingPatch | null;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "section.set-header-footer-link";
+      sectionIndex: number;
+      params: HeaderFooterLinkPatch;
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "content.insert-page-break";
+      origin?: CommandOrigin;
+    }
+  | {
+      type: "content.insert-table";
+      options: InsertTableOptions;
+      origin?: CommandOrigin;
     };
 
 export interface TransactionEffects {
@@ -198,11 +387,40 @@ export interface CommandExecutionContext {
   timestamp: string;
   documentMode?: "editing" | "suggesting" | "viewing" | "commenting";
   defaultAuthorId?: string;
+  /**
+   * Runtime-owned render snapshot made available for document-mutating
+   * commands that need per-paragraph surface lookups (formatting, styles,
+   * section layout). Populated by the runtime at dispatch time; absent for
+   * callers that cannot produce it.
+   */
+  renderSnapshot?: RuntimeRenderSnapshot;
 }
 
+/**
+ * Commands that are surfaced on the event log but do NOT mutate `EditorState`.
+ * They mutate runtime-scoped overlays (workflow, host annotations) and are
+ * applied directly by the runtime rather than through `executeEditorCommand`.
+ */
+export type RuntimeStateCommandType =
+  | "history.undo"
+  | "history.redo"
+  | "workflow.set-overlay"
+  | "workflow.clear-overlay"
+  | "workflow.set-metadata-definitions"
+  | "workflow.clear-metadata-definitions"
+  | "workflow.set-metadata-entries"
+  | "workflow.clear-metadata-entries"
+  | "host-annotation.set-overlay"
+  | "host-annotation.clear-overlay";
+
+export type StateMutatingCommand = Exclude<
+  EditorCommand,
+  { type: RuntimeStateCommandType }
+>;
+
 export function executeEditorCommand(
   state: EditorState,
-  command: Exclude<EditorCommand, { type: "history.undo" } | { type: "history.redo" }>,
+  command: StateMutatingCommand,
   context: CommandExecutionContext,
 ): EditorTransaction {
   switch (command.type) {
@@ -633,7 +851,356 @@ export function executeEditorCommand(
         },
         context.timestamp,
       );
+    case "formatting.apply": {
+      if (!context.renderSnapshot) {
+        return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+      }
+      const result = applyFormattingOperationToDocument(
+        state.document,
+        context.renderSnapshot,
+        command.operation,
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.changed,
+        document: result.document,
+        selection: toInternalSelection(result.selection, state.selection),
+      });
+    }
+    case "style.set-paragraph": {
+      if (!context.renderSnapshot) {
+        return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+      }
+      const result = applyParagraphStyleToDocument(
+        state.document,
+        context.renderSnapshot,
+        command.styleId,
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.changed,
+        document: result.document,
+        selection: toInternalSelection(result.selection, state.selection),
+      });
+    }
+    case "style.set-table": {
+      if (!context.renderSnapshot) {
+        return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+      }
+      const result = applyTableStyleToDocument(
+        state.document,
+        context.renderSnapshot,
+        command.styleId,
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.changed,
+        document: result.document,
+        selection: toInternalSelection(result.selection, state.selection),
+      });
+    }
+    case "list.toggle": {
+      const result = command.kind === "bulleted"
+        ? toggleBulletedList(state.document, command.paragraphIndexes, { timestamp: context.timestamp })
+        : toggleNumberedList(state.document, command.paragraphIndexes, { timestamp: context.timestamp });
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.affectedParagraphIndexes.length > 0,
+        document: result.document,
+        selection: state.selection,
+      });
+    }
+    case "list.indent": {
+      const result = indentListItems(state.document, command.paragraphIndexes, { timestamp: context.timestamp });
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.affectedParagraphIndexes.length > 0,
+        document: result.document,
+        selection: state.selection,
+      });
+    }
+    case "list.outdent": {
+      const result = outdentListItems(state.document, command.paragraphIndexes, { timestamp: context.timestamp });
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.affectedParagraphIndexes.length > 0,
+        document: result.document,
+        selection: state.selection,
+      });
+    }
+    case "list.restart-numbering": {
+      const result = restartNumbering(
+        state.document,
+        command.paragraphIndex,
+        { timestamp: context.timestamp },
+        command.startAt,
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.affectedParagraphIndexes.length > 0,
+        document: result.document,
+        selection: state.selection,
+      });
+    }
+    case "list.continue-numbering": {
+      const result = continueNumbering(
+        state.document,
+        command.paragraphIndex,
+        { timestamp: context.timestamp },
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.affectedParagraphIndexes.length > 0,
+        document: result.document,
+        selection: state.selection,
+      });
+    }
+    case "table.apply-structure": {
+      if (!context.renderSnapshot) {
+        return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+      }
+      const result = applyTableStructureOperation(
+        state.document,
+        context.renderSnapshot,
+        command.selectionDescriptor,
+        command.operation,
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.changed,
+        document: result.document,
+        selection: result.selection,
+        mapping: result.mapping,
+      });
+    }
+    case "image.insert": {
+      const dataBytes = decodeBase64ToBytes(command.data);
+      const result = insertImage(
+        state.document,
+        state.selection,
+        dataBytes,
+        command.mimeType,
+        command.width,
+        command.height,
+        {
+          timestamp: context.timestamp,
+          ...(command.altText ? { altText: command.altText } : {}),
+        },
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: true,
+        document: result.document,
+        selection: result.selection,
+        mapping: result.mapping,
+      });
+    }
+    case "image.set-layout": {
+      try {
+        const result = resizeImage(
+          state.document,
+          command.mediaId,
+          command.dimensions,
+          context.timestamp,
+        );
+        return buildDocumentReplaceTransaction(state, context, {
+          changed: true,
+          document: result.document,
+          selection: state.selection,
+        });
+      } catch {
+        return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+      }
+    }
+    case "image.set-frame": {
+      try {
+        const result = repositionFloatingImage(
+          state.document,
+          command.mediaId,
+          command.offsets,
+          context.timestamp,
+        );
+        return buildDocumentReplaceTransaction(state, context, {
+          changed: true,
+          document: result.document,
+          selection: state.selection,
+        });
+      } catch {
+        return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+      }
+    }
+    case "section.insert-break": {
+      const result = insertSectionBreakAfterSectionIndex(
+        state.document,
+        command.sectionIndex,
+        command.breakType,
+        { timestamp: context.timestamp },
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.changed,
+        document: result.document,
+        selection: state.selection,
+      });
+    }
+    case "section.delete-break": {
+      const result = deleteSectionBreakAtSectionIndex(
+        state.document,
+        command.sectionIndex,
+        { timestamp: context.timestamp },
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.changed,
+        document: result.document,
+        selection: state.selection,
+      });
+    }
+    case "section.update-layout": {
+      const result = updateSectionLayoutAtSectionIndex(
+        state.document,
+        command.sectionIndex,
+        command.patch,
+        { timestamp: context.timestamp },
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.changed,
+        document: result.document,
+        selection: state.selection,
+      });
+    }
+    case "section.set-page-numbering": {
+      const normalizedPatch = command.patch === null
+        ? null
+        : stripNullsFromRecord(command.patch as unknown as Record<string, unknown>);
+      const result = setSectionPageNumberingAtSectionIndex(
+        state.document,
+        command.sectionIndex,
+        normalizedPatch as never,
+        { timestamp: context.timestamp },
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.changed,
+        document: result.document,
+        selection: state.selection,
+      });
+    }
+    case "section.set-header-footer-link": {
+      const result = setHeaderFooterLinkAtSectionIndex(
+        state.document,
+        command.sectionIndex,
+        command.params,
+        { timestamp: context.timestamp },
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.changed,
+        document: result.document,
+        selection: state.selection,
+      });
+    }
+    case "content.insert-page-break": {
+      const result = insertPageBreak(
+        state.document,
+        state.selection,
+        { timestamp: context.timestamp },
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.changed,
+        document: result.document,
+        selection: result.selection,
+        mapping: result.mapping,
+      });
+    }
+    case "content.insert-table": {
+      const result = insertTable(
+        state.document,
+        state.selection,
+        command.options,
+        { timestamp: context.timestamp },
+      );
+      return buildDocumentReplaceTransaction(state, context, {
+        changed: result.changed,
+        document: result.document,
+        selection: result.selection,
+        mapping: result.mapping,
+      });
+    }
+  }
+}
+
+function buildDocumentReplaceTransaction(
+  state: EditorState,
+  context: CommandExecutionContext,
+  result: {
+    changed: boolean;
+    document: EditorState["document"];
+    selection: SelectionSnapshot;
+    mapping?: TransactionMapping;
+  },
+): EditorTransaction {
+  if (!result.changed) {
+    return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+  }
+  const mapping = result.mapping ?? createEmptyMapping();
+  const reviewState = remapReviewStateAfterContentChange(
+    state,
+    result.document,
+    mapping,
+  );
+  return createTransaction(
+    {
+      ...state,
+      document: reviewState.document,
+      selection: result.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,
+    },
+  );
+}
+
+function decodeBase64ToBytes(value: string): Uint8Array {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+function toInternalSelection(
+  publicSelection: RuntimeRenderSnapshot["selection"],
+  fallback: SelectionSnapshot,
+): SelectionSnapshot {
+  if (
+    publicSelection.anchor === fallback.anchor &&
+    publicSelection.head === fallback.head
+  ) {
+    return fallback;
+  }
+  return createSelectionSnapshot(publicSelection.anchor, publicSelection.head);
+}
+
+function stripNullsFromRecord<T extends Record<string, unknown>>(
+  value: T,
+): { [K in keyof T]?: Exclude<T[K], null> } {
+  const out: Record<string, unknown> = {};
+  for (const key of Object.keys(value) as Array<keyof T>) {
+    const v = value[key];
+    if (v !== null && v !== undefined) {
+      out[key as string] = v;
+    }
   }
+  return out as { [K in keyof T]?: Exclude<T[K], null> };
 }
 
 export function remapSelection(