@beyondwork/docx-react-component 1.0.28 → 1.0.30

package/src/core/state/text-transaction.ts

@@ -11,7 +11,7 @@ import {
   type TextStory,
 } from "../schema/text-schema.ts";
 import { createEditorSurfaceSnapshot } from "../../runtime/surface-projection.ts";
-import type { DocumentRootNode, ParagraphNode, TableNode } from "../../model/canonical-document.ts";
+import type { DocumentRootNode, ParagraphNode, SdtNode, TableNode } from "../../model/canonical-document.ts";
 
 export type TextInsertion =
   | {
@@ -72,6 +72,26 @@ export function applyTextTransaction(
     timestamp: string;
   },
 ): TextTransactionResult {
+  const topLevelParagraphResult = tryApplyTopLevelParagraphTransaction(
+    document,
+    selection,
+    intent,
+    options,
+  );
+  if (topLevelParagraphResult) {
+    return topLevelParagraphResult;
+  }
+
+  const sdtScopedResult = tryApplyTopLevelSdtParagraphTransaction(
+    document,
+    selection,
+    intent,
+    options,
+  );
+  if (sdtScopedResult) {
+    return sdtScopedResult;
+  }
+
   const tableScopedResult = tryApplyTableParagraphTransaction(
     document,
     selection,
@@ -159,7 +179,6 @@ function tryApplyTableParagraphTransaction(
       "Text transactions inside table structures are only supported when the selection stays within one paragraph-backed table cell.",
     );
   }
-
   const localDocument: CanonicalDocumentEnvelope = {
     ...document,
     content: {
@@ -171,7 +190,12 @@ function tryApplyTableParagraphTransaction(
     selection.anchor - scope.paragraphStart,
     selection.head - scope.paragraphStart,
   );
-  const localResult = applyLinearTextTransaction(localDocument, localSelection, intent, options);
+  const localResult = applyLinearTextTransaction(
+    localDocument,
+    localSelection,
+    localizeTextTransactionIntent(intent, scope.paragraphStart),
+    options,
+  );
   const nextParagraphBlocks = (localResult.document.content as DocumentRootNode).children;
   const nextRoot: DocumentRootNode = {
     ...scope.root,
@@ -232,6 +256,138 @@ function tryApplyTableParagraphTransaction(
   };
 }
 
+function tryApplyTopLevelSdtParagraphTransaction(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+  intent: TextTransactionIntent,
+  options: {
+    timestamp: string;
+  },
+): TextTransactionResult | null {
+  const scope = resolveTopLevelSdtParagraphScope(document, selection);
+  if (!scope) {
+    return null;
+  }
+
+  const localDocument: CanonicalDocumentEnvelope = {
+    ...document,
+    content: {
+      type: "doc",
+      children: [scope.paragraph],
+    },
+  };
+  const localSelection = createSelectionSnapshot(
+    selection.anchor - scope.paragraphStart,
+    selection.head - scope.paragraphStart,
+  );
+  const localResult = applyLinearTextTransaction(
+    localDocument,
+    localSelection,
+    localizeTextTransactionIntent(intent, scope.paragraphStart),
+    options,
+  );
+  const nextParagraphBlocks = (localResult.document.content as DocumentRootNode).children;
+  const nextRoot: DocumentRootNode = {
+    ...scope.root,
+    children: scope.root.children.map((child, blockIndex) => {
+      if (blockIndex !== scope.blockIndex) {
+        return child;
+      }
+      return replaceParagraphInSdt(child as SdtNode, scope.childPath, nextParagraphBlocks);
+    }),
+  };
+
+  return {
+    document: {
+      ...document,
+      updatedAt: options.timestamp,
+      content: nextRoot,
+    },
+    selection: createSelectionSnapshot(
+      localResult.selection.anchor + scope.paragraphStart,
+      localResult.selection.head + scope.paragraphStart,
+    ),
+    mapping: {
+      ...localResult.mapping,
+      steps: localResult.mapping.steps.map((step) => ({
+        ...step,
+        from: step.from + scope.paragraphStart,
+        to: step.to + scope.paragraphStart,
+      })),
+    },
+    storyText: localResult.storyText,
+  };
+}
+
+function tryApplyTopLevelParagraphTransaction(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+  intent: TextTransactionIntent,
+  options: {
+    timestamp: string;
+  },
+): TextTransactionResult | null {
+  const scope = resolveTopLevelParagraphScope(document, selection);
+  if (!scope) {
+    return null;
+  }
+  if (
+    selection.isCollapsed &&
+    ((intent.type === "delete_backward" && selection.anchor === scope.paragraphStart) ||
+      (intent.type === "delete_forward" && selection.anchor === scope.paragraphEnd))
+  ) {
+    return null;
+  }
+
+  const localDocument: CanonicalDocumentEnvelope = {
+    ...document,
+    content: {
+      type: "doc",
+      children: [scope.paragraph],
+    },
+  };
+  const localSelection = createSelectionSnapshot(
+    selection.anchor - scope.paragraphStart,
+    selection.head - scope.paragraphStart,
+  );
+  const localResult = applyLinearTextTransaction(
+    localDocument,
+    localSelection,
+    localizeTextTransactionIntent(intent, scope.paragraphStart),
+    options,
+  );
+  const nextParagraphBlocks = (localResult.document.content as DocumentRootNode).children;
+  const nextRoot: DocumentRootNode = {
+    ...scope.root,
+    children: [
+      ...scope.root.children.slice(0, scope.blockIndex),
+      ...nextParagraphBlocks,
+      ...scope.root.children.slice(scope.blockIndex + 1),
+    ],
+  };
+
+  return {
+    document: {
+      ...document,
+      updatedAt: options.timestamp,
+      content: nextRoot,
+    },
+    selection: createSelectionSnapshot(
+      localResult.selection.anchor + scope.paragraphStart,
+      localResult.selection.head + scope.paragraphStart,
+    ),
+    mapping: {
+      ...localResult.mapping,
+      steps: localResult.mapping.steps.map((step) => ({
+        ...step,
+        from: step.from + scope.paragraphStart,
+        to: step.to + scope.paragraphStart,
+      })),
+    },
+    storyText: localResult.storyText,
+  };
+}
+
 function resolveTableParagraphScope(
   document: CanonicalDocumentEnvelope,
   selection: SelectionSnapshot,
@@ -327,6 +483,200 @@ function resolveTableParagraphScope(
   return null;
 }
 
+function resolveTopLevelParagraphScope(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+):
+  | {
+      root: DocumentRootNode;
+      blockIndex: number;
+      paragraph: ParagraphNode;
+      paragraphStart: number;
+      paragraphEnd: number;
+    }
+  | null {
+  const root = document.content as DocumentRootNode;
+  if (!root || root.type !== "doc" || !Array.isArray(root.children)) {
+    return null;
+  }
+
+  const surface = createEditorSurfaceSnapshot(document, selection);
+  const selectionFrom = Math.min(selection.anchor, selection.head);
+  const selectionTo = Math.max(selection.anchor, selection.head);
+
+  for (let blockIndex = 0; blockIndex < root.children.length; blockIndex += 1) {
+    const block = root.children[blockIndex];
+    const surfaceBlock = surface.blocks[blockIndex];
+    if (block?.type !== "paragraph" || surfaceBlock?.kind !== "paragraph") {
+      continue;
+    }
+
+    const insideParagraph = selectionFallsWithinSurfaceRange(
+      selectionFrom,
+      selectionTo,
+      surfaceBlock.from,
+      surfaceBlock.to,
+    );
+    const isCollapsedParagraphTailBeforeTable =
+      selectionFrom === selectionTo &&
+      selectionFrom === surfaceBlock.to &&
+      root.children[blockIndex + 1]?.type === "table";
+    if (!insideParagraph && !isCollapsedParagraphTailBeforeTable) {
+      continue;
+    }
+
+    return {
+      root,
+      blockIndex,
+      paragraph: block,
+      paragraphStart: surfaceBlock.from,
+      paragraphEnd: surfaceBlock.to,
+    };
+  }
+
+  return null;
+}
+
+function resolveTopLevelSdtParagraphScope(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+):
+  | {
+      root: DocumentRootNode;
+      blockIndex: number;
+      childPath: number[];
+      paragraph: ParagraphNode;
+      paragraphStart: number;
+    }
+  | null {
+  const root = document.content as DocumentRootNode;
+  if (!root || root.type !== "doc" || !Array.isArray(root.children)) {
+    return null;
+  }
+
+  const surface = createEditorSurfaceSnapshot(document, selection);
+  const selectionFrom = Math.min(selection.anchor, selection.head);
+  const selectionTo = Math.max(selection.anchor, selection.head);
+
+  for (let blockIndex = 0; blockIndex < root.children.length; blockIndex += 1) {
+    const block = root.children[blockIndex];
+    const surfaceBlock = surface.blocks[blockIndex];
+    if (block?.type !== "sdt" || surfaceBlock?.kind !== "sdt_block") {
+      continue;
+    }
+
+    const nested = resolveParagraphInSdtChildren(
+      block.children,
+      surfaceBlock.children,
+      selectionFrom,
+      selectionTo,
+      [],
+    );
+    if (nested) {
+      return {
+        root,
+        blockIndex,
+        childPath: nested.childPath,
+        paragraph: nested.paragraph,
+        paragraphStart: nested.paragraphStart,
+      };
+    }
+  }
+
+  return null;
+}
+
+function resolveParagraphInSdtChildren(
+  blocks: readonly DocumentRootNode["children"][number][],
+  surfaceBlocks: readonly {
+    kind: string;
+    from: number;
+    to: number;
+    children?: readonly { kind: string; from: number; to: number; children?: readonly unknown[] }[];
+  }[],
+  selectionFrom: number,
+  selectionTo: number,
+  path: number[],
+):
+  | {
+      childPath: number[];
+      paragraph: ParagraphNode;
+      paragraphStart: number;
+    }
+  | null {
+  for (let index = 0; index < Math.min(blocks.length, surfaceBlocks.length); index += 1) {
+    const block = blocks[index];
+    const surfaceBlock = surfaceBlocks[index];
+    if (!block || !surfaceBlock) {
+      continue;
+    }
+
+    if (block.type === "paragraph" && surfaceBlock.kind === "paragraph") {
+      const insideParagraph = selectionFallsWithinSurfaceRange(
+        selectionFrom,
+        selectionTo,
+        surfaceBlock.from,
+        surfaceBlock.to,
+      );
+      if (insideParagraph) {
+        return {
+          childPath: [...path, index],
+          paragraph: block,
+          paragraphStart: surfaceBlock.from,
+        };
+      }
+      continue;
+    }
+
+    if (block.type === "sdt" && surfaceBlock.kind === "sdt_block") {
+      const nested = resolveParagraphInSdtChildren(
+        block.children,
+        (surfaceBlock.children ?? []) as {
+          kind: string;
+          from: number;
+          to: number;
+          children?: readonly { kind: string; from: number; to: number; children?: readonly unknown[] }[];
+        }[],
+        selectionFrom,
+        selectionTo,
+        [...path, index],
+      );
+      if (nested) {
+        return nested;
+      }
+    }
+  }
+
+  return null;
+}
+
+function replaceParagraphInSdt(
+  sdt: SdtNode,
+  childPath: number[],
+  nextParagraphBlocks: DocumentRootNode["children"],
+): SdtNode {
+  if (childPath.length === 0) {
+    return sdt;
+  }
+
+  const [childIndex, ...restPath] = childPath;
+  return {
+    ...sdt,
+    children: sdt.children.map((child, index) => {
+      if (index !== childIndex) {
+        return child;
+      }
+      if (restPath.length === 0) {
+        return nextParagraphBlocks[0] ?? child;
+      }
+      if (child.type === "sdt") {
+        return replaceParagraphInSdt(child, restPath, nextParagraphBlocks);
+      }
+      return child;
+    }),
+  };
+}
+
 function selectionFallsWithinSurfaceRange(
   selectionFrom: number,
   selectionTo: number,
@@ -396,6 +746,23 @@ function resolveRange(
   };
 }
 
+function localizeTextTransactionIntent(
+  intent: TextTransactionIntent,
+  offset: number,
+): TextTransactionIntent {
+  if (intent.type !== "replace" || !intent.range) {
+    return intent;
+  }
+
+  return {
+    ...intent,
+    range: {
+      from: intent.range.from - offset,
+      to: intent.range.to - offset,
+    },
+  };
+}
+
 function createInsertionUnits(
   intent: TextTransactionIntent,
   story: TextStory,

package/src/index.ts

@@ -11,6 +11,8 @@ export type {
   EditorSessionState,
   EditorHostAdapter,
   WordReviewEditorProps,
+  WordReviewEditorChromePreset,
+  WordReviewEditorChromeOptions,
   WordReviewEditorChromeVisibility,
   WordReviewEditorRef,
   EditorUser,
@@ -50,11 +52,27 @@ export type {
   CommentSidebarThreadEntrySnapshot,
   TrackedChangesSnapshot,
   TrackedChangeEntrySnapshot,
+  SuggestionsSnapshot,
+  SuggestionEntrySnapshot,
   StyleCatalogSnapshot,
   StyleCatalogEntrySnapshot,
   DocumentNavigationSnapshot,
   DocumentPageSnapshot,
   DocumentHeadingSnapshot,
+  DocumentLocationSource,
+  DocumentLocationSnapshot,
+  RestorePointCheckpointType,
+  RestorePointSnapshot,
+  RestoreResult,
+  DocumentOutlineHeadingSnapshot,
+  DocumentOutlineSnapshot,
+  TocEntrySnapshot,
+  TocSnapshot,
+  DocumentSectionSnapshot,
+  SnapshotRefreshInvalidateTarget,
+  SnapshotRefreshStaleTarget,
+  SnapshotRefreshChangeKind,
+  SnapshotRefreshHints,
   AddCommentParams,
   ExportDocxOptions,
   ExportResult,
@@ -80,12 +98,17 @@ export type {
   WorkflowScope,
   WorkflowWorkItem,
   WorkflowOverlay,
+  WorkflowMetadataPersistence,
+  WorkflowMetadataDefinition,
+  WorkflowMetadataEntry,
+  WorkflowMetadataSnapshot,
   WorkflowBlockedCommandReason,
   WorkflowScopeSnapshot,
   InteractionGuardSnapshot,
   WorkflowMarkupKind,
   WorkflowMarkupBase,
   WorkflowHighlightMarkup,
+  WorkflowMetadataMarkup,
   WorkflowCommentMarkup,
   WorkflowRevisionMarkup,
   WorkflowFieldMarkup,
@@ -98,4 +121,22 @@ export type {
   HostAnnotationItem,
   HostAnnotationOverlay,
   HostAnnotationSnapshot,
+  ReviewQueueItem,
+  ReviewQueueItemKind,
+  ReviewQueueSnapshot,
+  DocumentTextToken,
+  StoryTextStreamSnapshot,
+  DocumentChunkKind,
+  DocumentChunkSnapshot,
+  ReviewWorkItemSnapshot,
+  ReviewWorkSnapshot,
+  RuntimeContextAnalyticsScopeKind,
+  RuntimeContextAnalyticsQuery,
+  RuntimeContextAnalyticsBadge,
+  RuntimeContextAnalyticsActionHint,
+  RuntimeContextAnalyticsCounts,
+  RuntimeContextAnalyticsState,
+  RuntimeContextAnalyticsUnavailableField,
+  RuntimeContextAnalyticsProvenance,
+  RuntimeContextAnalyticsSnapshot,
 } from "./api/public-types.ts";