@beyondwork/docx-react-component 1.0.28 → 1.0.30

package/src/api/session-state.ts

@@ -33,6 +33,7 @@ export function editorSessionStateFromPersistedSnapshot(
     warningLog: snapshot.warningLog,
     protectionSnapshot: snapshot.protectionSnapshot,
     sourcePackage: snapshot.sourcePackage,
+    workflowMetadata: snapshot.workflowMetadata,
   });
 }
 
@@ -56,5 +57,6 @@ export function persistedSnapshotFromEditorSessionState(
     warningLog: sessionState.warningLog,
     protectionSnapshot: sessionState.protectionSnapshot,
     sourcePackage: sessionState.sourcePackage,
+    workflowMetadata: sessionState.workflowMetadata,
   });
 }

package/src/core/commands/index.ts

@@ -305,16 +305,8 @@ export function executeEditorCommand(
     }
     case "paragraph.split":
       if (context.documentMode === "suggesting") {
-        return createTransaction(state, {
-          historyBoundary: "skip",
-          markDirty: false,
-          effects: {
-            commandBlocked: {
-              code: "suggesting_unsupported",
-              message: "Paragraph splits are not supported in suggesting mode.",
-            },
-          },
-        });
+        const suggestingResult = applySuggestingParagraphSplit(state, context);
+        if (suggestingResult) return suggestingResult;
       }
       return applyTextCommand(state, context.timestamp, (document, selection) =>
         splitParagraph(document, selection, context),
@@ -722,10 +714,31 @@ function normalizeSelection(selection: SelectionSnapshot): SelectionSnapshot {
   );
 
   if (activeRange.kind === "range") {
+    const rangeFrom = activeRange.range.from;
+    const rangeTo = activeRange.range.to;
+    const collapsed = rangeFrom === rangeTo;
+    const anchorWithinRange = selection.anchor >= rangeFrom && selection.anchor <= rangeTo;
+    const headWithinRange = selection.head >= rangeFrom && selection.head <= rangeTo;
+    const preserveDirectionalEndpoints = anchorWithinRange && headWithinRange;
+    const fallbackForward = selection.anchor <= selection.head;
+    const anchor = collapsed
+      ? rangeFrom
+      : preserveDirectionalEndpoints
+        ? selection.anchor
+        : fallbackForward
+          ? rangeFrom
+          : rangeTo;
+    const head = collapsed
+      ? rangeTo
+      : preserveDirectionalEndpoints
+        ? selection.head
+        : fallbackForward
+          ? rangeTo
+          : rangeFrom;
     return {
-      anchor: activeRange.range.from,
-      head: activeRange.range.to,
-      isCollapsed: activeRange.range.from === activeRange.range.to,
+      anchor,
+      head,
+      isCollapsed: collapsed,
       activeRange,
     };
   }
@@ -1056,6 +1069,10 @@ function createRevisionStoreFromState(
             source: revision.metadata?.source ?? "runtime",
             storyTarget: revision.metadata?.storyTarget,
             preserveOnlyReason: revision.metadata?.preserveOnlyReason,
+            suggestionId: revision.metadata?.suggestionId,
+            semanticKind: revision.metadata?.semanticKind,
+            linkedRevisionIds: revision.metadata?.linkedRevisionIds,
+            predecessorSuggestionId: revision.metadata?.predecessorSuggestionId,
             importedRevisionForm: revision.metadata?.importedRevisionForm,
             originalRevisionType: revision.metadata?.originalRevisionType,
             ooxmlRevisionId: revision.metadata?.ooxmlRevisionId,
@@ -1083,6 +1100,10 @@ function toEditorRevisionRecords(
           source: revision.metadata.source,
           storyTarget: revision.metadata.storyTarget,
           preserveOnlyReason: revision.metadata.preserveOnlyReason,
+          suggestionId: revision.metadata.suggestionId,
+          semanticKind: revision.metadata.semanticKind,
+          linkedRevisionIds: revision.metadata.linkedRevisionIds,
+          predecessorSuggestionId: revision.metadata.predecessorSuggestionId,
           importedRevisionForm: revision.metadata.importedRevisionForm,
           originalRevisionType: revision.metadata.originalRevisionType,
           ooxmlRevisionId: revision.metadata.ooxmlRevisionId,
@@ -1209,6 +1230,7 @@ function createAuthoredRevision(
   to: number,
   authorId: string,
   timestamp: string,
+  metadata: Partial<NonNullable<CanonicalRevisionRecord["metadata"]>> = {},
 ): CanonicalRevisionRecord {
   const changeId = createSuggestingRevisionId(existing, timestamp);
   return {
@@ -1224,11 +1246,33 @@ function createAuthoredRevision(
     warningIds: [],
     metadata: {
       source: "runtime",
+      ...metadata,
     },
     status: "open",
   };
 }
 
+function createSuggestionMetadata(args: {
+  suggestionId?: string;
+  semanticKind:
+    | "insertion"
+    | "deletion"
+    | "replacement"
+    | "formatting-change"
+    | "paragraph-property-change"
+    | "structural-change"
+    | "object-change";
+  linkedRevisionIds?: string[];
+  predecessorSuggestionId?: string;
+}): Partial<NonNullable<CanonicalRevisionRecord["metadata"]>> {
+  return {
+    suggestionId: args.suggestionId,
+    semanticKind: args.semanticKind,
+    linkedRevisionIds: args.linkedRevisionIds,
+    predecessorSuggestionId: args.predecessorSuggestionId,
+  };
+}
+
 function createSuggestingUnsupportedTransaction(
   state: EditorState,
   message: string,
@@ -1309,7 +1353,7 @@ function applySuggestingInsert(
   }
 
   if (isCollapsed) {
-    // Pure insertion at cursor: apply normally, then create or extend an insertion revision.
+    // Pure insertion at cursor: apply normally, then create insertion revision
     const result = insertText(state.document, selection, text, { timestamp: context.timestamp });
     const insertedFrom = from;
     const insertedTo = from + Array.from(text).length;
@@ -1321,53 +1365,28 @@ function applySuggestingInsert(
       result.mapping,
     );
 
-    // If there is an authored insertion revision that ends exactly where this
-    // text was inserted (i.e. the cursor was at the end of a prior insertion),
-    // extend that revision to cover the new text rather than creating a new one.
-    // This groups consecutive keystrokes into a single tracked change.
-    const adjacentInsertion = findAdjacentAuthoredInsertion(
+    // Create the revision with pre-mapping positions — it refers to content
+    // that was just inserted, so its anchors are already correct in the new document
+    const revision = createAuthoredRevision(
       reviewState.document.review.revisions,
+      "insertion",
       insertedFrom,
+      insertedTo,
+      authorId,
+      context.timestamp,
+      createSuggestionMetadata({
+        semanticKind: "insertion",
+      }),
     );
 
-    let finalRevisionId: string;
-    let finalRevisions: Record<string, CanonicalRevisionRecord>;
-
-    if (adjacentInsertion && adjacentInsertion.anchor.kind === "range") {
-      const extended: CanonicalRevisionRecord = {
-        ...adjacentInsertion,
-        anchor: {
-          kind: "range",
-          range: { from: adjacentInsertion.anchor.range.from, to: insertedTo },
-          assoc: { start: 1, end: -1 },
-        },
-      };
-      finalRevisionId = extended.changeId;
-      finalRevisions = {
-        ...reviewState.document.review.revisions,
-        [extended.changeId]: extended,
-      };
-    } else {
-      const revision = createAuthoredRevision(
-        reviewState.document.review.revisions,
-        "insertion",
-        insertedFrom,
-        insertedTo,
-        authorId,
-        context.timestamp,
-      );
-      finalRevisionId = revision.changeId;
-      finalRevisions = {
-        ...reviewState.document.review.revisions,
-        [revision.changeId]: revision,
-      };
-    }
-
     const finalDocument: CanonicalDocumentEnvelope = {
       ...reviewState.document,
       review: {
         ...reviewState.document.review,
-        revisions: finalRevisions,
+        revisions: {
+          ...reviewState.document.review.revisions,
+          [revision.changeId]: revision,
+        },
       },
     };
 
@@ -1388,7 +1407,7 @@ function applySuggestingInsert(
         mapping: result.mapping,
         effects: {
           ...reviewState.effects,
-          revisionAuthored: { changeId: finalRevisionId, kind: "insertion" },
+          revisionAuthored: { changeId: revision.changeId, kind: "insertion" },
         },
       },
     );
@@ -1407,16 +1426,24 @@ function applySuggestingInsert(
     result.document,
     result.mapping,
   );
+  const replacementSuggestionId = createSuggestingRevisionId(
+    reviewState.document.review.revisions,
+    context.timestamp,
+  );
 
   // Step 3: Create deletion revision for the selected range (text stays in place).
   // Deletion range uses pre-mapping positions since content was not removed.
-  const deletionRevision = createAuthoredRevision(
+  let deletionRevision = createAuthoredRevision(
     reviewState.document.review.revisions,
     "deletion",
     from,
     to,
     authorId,
     context.timestamp,
+    createSuggestionMetadata({
+      suggestionId: replacementSuggestionId,
+      semanticKind: "replacement",
+    }),
   );
 
   // Step 4: Create insertion revision for the new text (positions already correct)
@@ -1430,7 +1457,19 @@ function applySuggestingInsert(
     insertedTo,
     authorId,
     context.timestamp,
+    createSuggestionMetadata({
+      suggestionId: replacementSuggestionId,
+      semanticKind: "replacement",
+      linkedRevisionIds: [deletionRevision.changeId],
+    }),
   );
+  deletionRevision = {
+    ...deletionRevision,
+    metadata: {
+      ...deletionRevision.metadata,
+      linkedRevisionIds: [insertionRevision.changeId],
+    },
+  };
 
   const finalDocument: CanonicalDocumentEnvelope = {
     ...reviewState.document,
@@ -1579,6 +1618,9 @@ function applySuggestingDelete(
     deleteTo,
     authorId,
     context.timestamp,
+    createSuggestionMetadata({
+      semanticKind: "deletion",
+    }),
   );
 
   const nextDocument: CanonicalDocumentEnvelope = {
@@ -1644,9 +1686,12 @@ function applySuggestingInsertUnit(
     result.document,
     result.mapping,
   );
+  const replacementSuggestionId = from !== to
+    ? createSuggestingRevisionId(reviewState.document.review.revisions, context.timestamp)
+    : undefined;
 
   // If non-collapsed, mark selected range as deletion (positions are pre-mapping, content preserved)
-  const deletionRevision = from !== to
+  let deletionRevision = from !== to
     ? createAuthoredRevision(
         reviewState.document.review.revisions,
         "deletion",
@@ -1654,6 +1699,10 @@ function applySuggestingInsertUnit(
         to,
         authorId,
         context.timestamp,
+        createSuggestionMetadata({
+          suggestionId: replacementSuggestionId,
+          semanticKind: "replacement",
+        }),
       )
     : undefined;
 
@@ -1668,7 +1717,27 @@ function applySuggestingInsertUnit(
     insertPos + 1,
     authorId,
     context.timestamp,
+    createSuggestionMetadata(
+      from !== to
+        ? {
+            suggestionId: replacementSuggestionId,
+            semanticKind: "replacement",
+            linkedRevisionIds: deletionRevision ? [deletionRevision.changeId] : undefined,
+          }
+        : {
+            semanticKind: "insertion",
+          },
+    ),
   );
+  if (deletionRevision) {
+    deletionRevision = {
+      ...deletionRevision,
+      metadata: {
+        ...deletionRevision.metadata,
+        linkedRevisionIds: [insertionRevision.changeId],
+      },
+    };
+  }
 
   const finalDocument: CanonicalDocumentEnvelope = {
     ...reviewState.document,
@@ -1705,6 +1774,82 @@ function applySuggestingInsertUnit(
   );
 }
 
+function applySuggestingParagraphSplit(
+  state: EditorState,
+  context: CommandExecutionContext,
+): EditorTransaction | undefined {
+  if (state.readOnly) {
+    return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+  }
+
+  const selection = state.selection;
+  const from = Math.min(selection.anchor, selection.head);
+  const to = Math.max(selection.anchor, selection.head);
+  if (from !== to) {
+    return createSuggestingUnsupportedTransaction(
+      state,
+      "Suggesting mode paragraph split currently requires a collapsed selection.",
+    );
+  }
+
+  const authorId = context.defaultAuthorId ?? "unknown";
+  const result = splitParagraph(state.document, selection, { timestamp: context.timestamp });
+
+  const reviewState = remapReviewStateAfterContentChange(
+    state,
+    result.document,
+    result.mapping,
+  );
+  const revision = createAuthoredRevision(
+    reviewState.document.review.revisions,
+    "insertion",
+    from,
+    from,
+    authorId,
+    context.timestamp,
+    {
+      ...createSuggestionMetadata({
+        semanticKind: "structural-change",
+      }),
+      importedRevisionForm: "paragraph-insertion",
+      originalRevisionType: "paragraph-ins",
+    },
+  );
+
+  const finalDocument: CanonicalDocumentEnvelope = {
+    ...reviewState.document,
+    review: {
+      ...reviewState.document.review,
+      revisions: {
+        ...reviewState.document.review.revisions,
+        [revision.changeId]: revision,
+      },
+    },
+  };
+
+  return createTransaction(
+    {
+      ...state,
+      document: finalDocument,
+      selection: result.selection,
+      warnings: reviewState.warnings,
+      runtime: {
+        ...state.runtime,
+        activeCommentId: reviewState.activeCommentId,
+      },
+    },
+    {
+      historyBoundary: "push",
+      markDirty: true,
+      mapping: result.mapping,
+      effects: {
+        ...reviewState.effects,
+        revisionAuthored: { changeId: revision.changeId, kind: "insertion" },
+      },
+    },
+  );
+}
+
 function findOverlappingAuthoredDeletion(
   revisions: Record<string, CanonicalRevisionRecord>,
   from: number,
@@ -1732,26 +1877,3 @@ function findOverlappingAuthoredDeletion(
   }
   return undefined;
 }
-
-/**
- * Find an open authored insertion revision whose end position equals `cursorAt`.
- * Used to extend an existing insertion when the user keeps typing at the same
- * position rather than creating a new revision for every character.
- */
-function findAdjacentAuthoredInsertion(
-  revisions: Record<string, CanonicalRevisionRecord>,
-  cursorAt: number,
-): CanonicalRevisionRecord | undefined {
-  for (const revision of Object.values(revisions)) {
-    if (
-      revision.kind === "insertion" &&
-      revision.status === "open" &&
-      revision.metadata?.source === "runtime" &&
-      revision.anchor.kind === "range" &&
-      revision.anchor.range.to === cursorAt
-    ) {
-      return revision;
-    }
-  }
-  return undefined;
-}

package/src/core/commands/table-structure-commands.ts

@@ -1,4 +1,8 @@
-import type { RuntimeRenderSnapshot as PublicRuntimeRenderSnapshot } from "../../api/public-types";
+import type {
+  RuntimeRenderSnapshot as PublicRuntimeRenderSnapshot,
+  TableOperationCapabilitySnapshot,
+  TableStructureContextSnapshot,
+} from "../../api/public-types";
 import type {
   DocumentRootNode,
   ParagraphNode,
@@ -82,6 +86,110 @@ export function applyTableStructureOperation(
   }
 }
 
+export function getTableStructureContext(
+  document: CanonicalDocumentEnvelope,
+  snapshot: PublicRuntimeRenderSnapshot,
+  selectionDescriptor: TableSelectionDescriptor | null,
+): TableStructureContextSnapshot | null {
+  const root = document.content;
+  if (!root || root.type !== "doc") {
+    return null;
+  }
+
+  const effectiveSelection = selectionDescriptor ?? resolveTableSelectionFromSnapshot(snapshot);
+  if (!effectiveSelection) {
+    return null;
+  }
+
+  const target = root.children[effectiveSelection.tableBlockIndex];
+  if (!target || target.type !== "table") {
+    return null;
+  }
+
+  const row = target.rows[effectiveSelection.anchorCell.rowIndex];
+  const cellRef = row
+    ? findCellAtColumn(row, effectiveSelection.anchorCell.columnIndex)
+    : null;
+  if (!row || !cellRef) {
+    return null;
+  }
+
+  const simpleTable = isSimpleTable(target);
+  const columnCount = getLogicalColumnCount(target);
+  const splitWidth = Math.max(1, cellRef.cell.gridSpan ?? 1);
+  const splitHeight = Math.max(
+    1,
+    computeRowSpan(
+      target,
+      effectiveSelection.anchorCell.rowIndex,
+      effectiveSelection.anchorCell.columnIndex,
+      splitWidth,
+    ),
+  );
+  const selectedCellCount =
+    effectiveSelection.selectionKind === "cell"
+      ? Math.max(
+          1,
+          (effectiveSelection.rect.bottom - effectiveSelection.rect.top) *
+            (effectiveSelection.rect.right - effectiveSelection.rect.left),
+        )
+      : 1;
+
+  return {
+    tableBlockIndex: effectiveSelection.tableBlockIndex,
+    currentStyleId: target.styleId ?? null,
+    selectionKind: effectiveSelection.selectionKind,
+    rowCount: target.rows.length,
+    columnCount,
+    selectedCellCount,
+    isSimpleTable: simpleTable,
+    currentCell: {
+      rowIndex: effectiveSelection.anchorCell.rowIndex,
+      columnIndex: effectiveSelection.anchorCell.columnIndex,
+      isHeader: row.isHeader === true,
+    },
+    operations: {
+      setTableStyle: enabledCapability(),
+      setCellBackground: enabledCapability(),
+      addRowBefore: simpleTable
+        ? enabledCapability()
+        : disabledCapability("Only simple rectangular tables support row insertion right now."),
+      addRowAfter: simpleTable
+        ? enabledCapability()
+        : disabledCapability("Only simple rectangular tables support row insertion right now."),
+      deleteRow:
+        !simpleTable
+          ? disabledCapability("Only simple rectangular tables support row deletion right now.")
+          : target.rows.length <= 1
+            ? disabledCapability("At least two rows are required before a row can be deleted.")
+            : enabledCapability(),
+      addColumnBefore: simpleTable
+        ? enabledCapability()
+        : disabledCapability("Only simple rectangular tables support column insertion right now."),
+      addColumnAfter: simpleTable
+        ? enabledCapability()
+        : disabledCapability("Only simple rectangular tables support column insertion right now."),
+      deleteColumn:
+        !simpleTable
+          ? disabledCapability("Only simple rectangular tables support column deletion right now.")
+          : columnCount <= 1
+            ? disabledCapability("At least two columns are required before a column can be deleted.")
+            : enabledCapability(),
+      mergeCells:
+        !simpleTable
+          ? disabledCapability("Only simple rectangular tables support merging right now.")
+          : effectiveSelection.selectionKind !== "cell" || selectedCellCount <= 1
+            ? disabledCapability("Select more than one cell to merge them.")
+            : enabledCapability(),
+      splitCell:
+        splitWidth === 1 && splitHeight === 1
+          ? disabledCapability("Select a merged or spanning cell to split it.")
+          : enabledCapability(),
+      deleteTable: enabledCapability(),
+    },
+  };
+}
+
 function addRow(
   document: CanonicalDocumentEnvelope,
   root: DocumentRootNode,
@@ -405,13 +513,27 @@ function setCellBackground(
     return createNoopStructuralMutation(document, fallbackSelection);
   }
 
+  const activeRow = table.rows[selection.anchorCell.rowIndex];
+  const activeCellRef = activeRow
+    ? findCellAtColumn(activeRow, selection.anchorCell.columnIndex)
+    : null;
+  const activeCellWidth = Math.max(1, activeCellRef?.cell.gridSpan ?? 1);
+  const activeCellHeight = Math.max(
+    1,
+    computeRowSpan(
+      table,
+      selection.anchorCell.rowIndex,
+      selection.anchorCell.columnIndex,
+      activeCellWidth,
+    ),
+  );
   const targetRect =
     selection.selectionKind === "text"
       ? {
-          top: 0,
-          left: 0,
-          bottom: table.rows.length,
-          right: getLogicalColumnCount(table),
+          top: selection.anchorCell.rowIndex,
+          left: selection.anchorCell.columnIndex,
+          bottom: selection.anchorCell.rowIndex + activeCellHeight,
+          right: selection.anchorCell.columnIndex + activeCellWidth,
         }
       : selection.rect;
   let changed = false;
@@ -611,6 +733,17 @@ function toInternalSelectionSnapshot(
   };
 }
 
+function enabledCapability(): TableOperationCapabilitySnapshot {
+  return { enabled: true };
+}
+
+function disabledCapability(reason: string): TableOperationCapabilitySnapshot {
+  return {
+    enabled: false,
+    reason,
+  };
+}
+
 function isSimpleTable(table: TableNode): boolean {
   const width = getLogicalColumnCount(table);
   return table.rows.every((row) => {