@beyondwork/docx-react-component 1.0.41 → 1.0.43

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(
@@ -1224,22 +1791,46 @@ function combineMappingSteps(
 // Suggesting mode: creates revision records instead of (or alongside) text mutations
 // ---------------------------------------------------------------------------
 
-let suggestingRevisionCounter = 0;
-
+/**
+ * Builds a suggesting-mode revision id that is deterministic across
+ * clients. The id is a pure function of `(existing, timestamp, authorId)`
+ * so that origin and replica — both of whom see the same `existing`
+ * revisions record after a Yjs-ordered replay and receive the same
+ * `timestamp` + `authorId` on the broadcast command event — produce
+ * the same id for the same authored revision.
+ *
+ * Previously this used a module-level counter; that counter was shared
+ * across every `DocumentRuntime` in a single process and drifted between
+ * origin and replica whenever either side had other suggesting-mode work
+ * bump the counter before replay. Cross-client `change.accept(changeId)`
+ * / `change.reject(changeId)` then missed because the target id only
+ * existed on one side.
+ */
 function createSuggestingRevisionId(
   existing: Record<string, unknown>,
   timestamp: string,
+  authorId: string,
 ): string {
-  suggestingRevisionCounter += 1;
   const ts = timestamp.replace(/[^0-9]/gu, "");
-  let id = `change-${ts}-s${suggestingRevisionCounter}`;
+  const authorMarker = sanitizeAuthorMarker(authorId);
+  const prefix = `change-${authorMarker}-${ts}-s`;
+  let n = 1;
+  let id = `${prefix}${n}`;
   while (existing[id]) {
-    suggestingRevisionCounter += 1;
-    id = `change-${ts}-s${suggestingRevisionCounter}`;
+    n += 1;
+    id = `${prefix}${n}`;
   }
   return id;
 }
 
+function sanitizeAuthorMarker(authorId: string): string {
+  // OOXML `w:id` accepts alphanumerics plus `._-`; keep within that set so
+  // the id survives round-trips unchanged (see `sanitizeRevisionId` on the
+  // serializer side).
+  const cleaned = authorId.replace(/[^A-Za-z0-9._-]/g, "-");
+  return cleaned.length > 0 ? cleaned : "u";
+}
+
 function createAuthoredRevision(
   existing: Record<string, unknown>,
   kind: "insertion" | "deletion",
@@ -1249,7 +1840,7 @@ function createAuthoredRevision(
   timestamp: string,
   metadata: Partial<NonNullable<CanonicalRevisionRecord["metadata"]>> = {},
 ): CanonicalRevisionRecord {
-  const changeId = createSuggestingRevisionId(existing, timestamp);
+  const changeId = createSuggestingRevisionId(existing, timestamp, authorId);
   return {
     changeId,
     kind,
@@ -1499,6 +2090,7 @@ function applySuggestingInsert(
   const replacementSuggestionId = createSuggestingRevisionId(
     reviewState.document.review.revisions,
     context.timestamp,
+    authorId,
   );
 
   // Step 3: Create deletion revision for the selected range (text stays in place).
@@ -1757,7 +2349,7 @@ function applySuggestingInsertUnit(
     result.mapping,
   );
   const replacementSuggestionId = from !== to
-    ? createSuggestingRevisionId(reviewState.document.review.revisions, context.timestamp)
+    ? createSuggestingRevisionId(reviewState.document.review.revisions, context.timestamp, authorId)
     : undefined;
 
   // If non-collapsed, mark selected range as deletion (positions are pre-mapping, content preserved)

package/src/core/search/search-text.ts

@@ -26,7 +26,7 @@ export interface SecondaryStorySearchResult extends SurfaceSearchResult {
   storyTarget: EditorStoryTarget;
 }
 
-interface ProjectedSurfaceText {
+export interface ProjectedSurfaceText {
   text: string;
   offsetMap: Array<number | null>;
 }
@@ -112,7 +112,20 @@ export function searchSurfaceBlocks(
   query: string,
   options: SearchTextOptions = {},
 ): SurfaceSearchResult[] {
-  const projection = projectSurfaceText(blocks);
+  return searchProjectedSurfaceText(projectSurfaceText(blocks), query, options);
+}
+
+/**
+ * Search a pre-projected surface text. Hoist `projectSurfaceText(blocks)` out
+ * of a per-query loop to avoid rebuilding the projection N times for N queries
+ * against the same surface — L7 Phase 1.5 discovered this cost dominates
+ * `collectFieldMarkup` on the CCEP large-tables fixture.
+ */
+export function searchProjectedSurfaceText(
+  projection: ProjectedSurfaceText,
+  query: string,
+  options: SearchTextOptions = {},
+): SurfaceSearchResult[] {
   return findSearchMatches(projection.text, query, options)
     .map((match) => {
       const range = resolveProjectedRuntimeRange(