@beyondwork/docx-react-component 1.0.21 → 1.0.23

package/src/core/commands/index.ts

@@ -33,6 +33,7 @@ import {
   insertText,
   splitParagraph,
 } from "./text-commands.ts";
+import type { RevisionRecord as CanonicalRevisionRecord } from "../../model/canonical-document.ts";
 import { remapCommentThreads } from "../../review/store/comment-remapping.ts";
 import { applyRevisionRuntimeCommand } from "../../runtime/revision-runtime.ts";
 import type { RevisionStore } from "../../review/store/revision-store.ts";
@@ -180,6 +181,8 @@ export interface TransactionEffects {
   commentBodyEdited?: { commentId: string };
   changeAccepted?: { changeId: string };
   changeRejected?: { changeId: string };
+  revisionAuthored?: { changeId: string; kind: "insertion" | "deletion" };
+  commandBlocked?: { code: string; message: string };
 }
 
 export interface EditorTransaction {
@@ -192,6 +195,8 @@ export interface EditorTransaction {
 
 export interface CommandExecutionContext {
   timestamp: string;
+  documentMode?: "editing" | "suggesting" | "viewing";
+  defaultAuthorId?: string;
 }
 
 export function executeEditorCommand(
@@ -253,27 +258,64 @@ export function executeEditorCommand(
         },
       );
     }
-    case "text.insert":
+    case "text.insert": {
+      const suggestingResult = context.documentMode === "suggesting"
+        ? applySuggestingInsert(state, command.text, context)
+        : undefined;
+      if (suggestingResult) return suggestingResult;
       return applyTextCommand(state, context.timestamp, (document, selection) =>
         insertText(document, selection, command.text, context),
       );
-    case "text.delete-backward":
+    }
+    case "text.delete-backward": {
+      const suggestingResult = context.documentMode === "suggesting"
+        ? applySuggestingDelete(state, "backward", context)
+        : undefined;
+      if (suggestingResult) return suggestingResult;
       return applyTextCommand(state, context.timestamp, (document, selection) =>
         deleteSelectionOrBackward(document, selection, context),
       );
-    case "text.delete-forward":
+    }
+    case "text.delete-forward": {
+      const suggestingResult = context.documentMode === "suggesting"
+        ? applySuggestingDelete(state, "forward", context)
+        : undefined;
+      if (suggestingResult) return suggestingResult;
       return applyTextCommand(state, context.timestamp, (document, selection) =>
         deleteSelectionOrForward(document, selection, context),
       );
-    case "text.insert-tab":
+    }
+    case "text.insert-tab": {
+      const suggestingResult = context.documentMode === "suggesting"
+        ? applySuggestingInsertUnit(state, "tab", context)
+        : undefined;
+      if (suggestingResult) return suggestingResult;
       return applyTextCommand(state, context.timestamp, (document, selection) =>
         insertTab(document, selection, context),
       );
-    case "text.insert-hard-break":
+    }
+    case "text.insert-hard-break": {
+      const suggestingResult = context.documentMode === "suggesting"
+        ? applySuggestingInsertUnit(state, "hard_break", context)
+        : undefined;
+      if (suggestingResult) return suggestingResult;
       return applyTextCommand(state, context.timestamp, (document, selection) =>
         insertHardBreak(document, selection, context),
       );
+    }
     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.",
+            },
+          },
+        });
+      }
       return applyTextCommand(state, context.timestamp, (document, selection) =>
         splitParagraph(document, selection, context),
       );
@@ -666,6 +708,8 @@ function createTransaction(
       commentResolved: options.effects?.commentResolved,
       changeAccepted: options.effects?.changeAccepted,
       changeRejected: options.effects?.changeRejected,
+      revisionAuthored: options.effects?.revisionAuthored,
+      commandBlocked: options.effects?.commandBlocked,
     },
   };
 }
@@ -1010,6 +1054,7 @@ function createRevisionStoreFromState(
           warningIds: [...(revision.warningIds ?? [])],
           metadata: {
             source: revision.metadata?.source ?? "runtime",
+            storyTarget: revision.metadata?.storyTarget,
             preserveOnlyReason: revision.metadata?.preserveOnlyReason,
             importedRevisionForm: revision.metadata?.importedRevisionForm,
             originalRevisionType: revision.metadata?.originalRevisionType,
@@ -1036,6 +1081,7 @@ function toEditorRevisionRecords(
         warningIds: [...revision.warningIds],
         metadata: {
           source: revision.metadata.source,
+          storyTarget: revision.metadata.storyTarget,
           preserveOnlyReason: revision.metadata.preserveOnlyReason,
           importedRevisionForm: revision.metadata.importedRevisionForm,
           originalRevisionType: revision.metadata.originalRevisionType,
@@ -1135,3 +1181,526 @@ function combineMappingSteps(
       }
     : createEmptyMapping();
 }
+
+// ---------------------------------------------------------------------------
+// Suggesting mode: creates revision records instead of (or alongside) text mutations
+// ---------------------------------------------------------------------------
+
+let suggestingRevisionCounter = 0;
+
+function createSuggestingRevisionId(
+  existing: Record<string, unknown>,
+  timestamp: string,
+): string {
+  suggestingRevisionCounter += 1;
+  const ts = timestamp.replace(/[^0-9]/gu, "");
+  let id = `change-${ts}-s${suggestingRevisionCounter}`;
+  while (existing[id]) {
+    suggestingRevisionCounter += 1;
+    id = `change-${ts}-s${suggestingRevisionCounter}`;
+  }
+  return id;
+}
+
+function createAuthoredRevision(
+  existing: Record<string, unknown>,
+  kind: "insertion" | "deletion",
+  from: number,
+  to: number,
+  authorId: string,
+  timestamp: string,
+): CanonicalRevisionRecord {
+  const changeId = createSuggestingRevisionId(existing, timestamp);
+  return {
+    changeId,
+    kind,
+    anchor: {
+      kind: "range",
+      range: { from, to },
+      assoc: { start: 1, end: -1 },
+    },
+    authorId,
+    createdAt: timestamp,
+    warningIds: [],
+    metadata: {
+      source: "runtime",
+    },
+    status: "open",
+  };
+}
+
+function createSuggestingUnsupportedTransaction(
+  state: EditorState,
+  message: string,
+): EditorTransaction {
+  return createTransaction(state, {
+    historyBoundary: "skip",
+    markDirty: false,
+    effects: {
+      commandBlocked: {
+        code: "suggesting_unsupported",
+        message,
+      },
+    },
+  });
+}
+
+function isSingleParagraphSuggestingRange(
+  document: CanonicalDocumentEnvelope,
+  from: number,
+  to: number,
+): boolean {
+  const ranges: Array<{ start: number; end: number }> = [];
+  let cursor = 0;
+  let previousWasParagraph = false;
+
+  for (const block of document.content.children) {
+    if (block.type === "paragraph") {
+      if (previousWasParagraph) {
+        cursor += 1;
+      }
+      const start = cursor;
+      cursor += block.children.reduce<number>((size, child) => {
+        if (child.type === "text") {
+          return size + child.text.length;
+        }
+        if (child.type === "hyperlink") {
+          return size + child.children.reduce<number>((childSize, entry) => {
+            if (entry.type === "text") {
+              return childSize + entry.text.length;
+            }
+            return childSize + 1;
+          }, 0);
+        }
+        return size + 1;
+      }, 0);
+      ranges.push({ start, end: cursor });
+      previousWasParagraph = true;
+      continue;
+    }
+
+    cursor += 1;
+    previousWasParagraph = false;
+  }
+
+  return ranges.some((range) => from >= range.start && to <= range.end);
+}
+
+function applySuggestingInsert(
+  state: EditorState,
+  text: string,
+  context: CommandExecutionContext,
+): EditorTransaction | undefined {
+  if (state.readOnly) {
+    return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+  }
+
+  const authorId = context.defaultAuthorId ?? "unknown";
+  const selection = state.selection;
+  const from = Math.min(selection.anchor, selection.head);
+  const to = Math.max(selection.anchor, selection.head);
+  const isCollapsed = from === to;
+
+  if (!isCollapsed && !isSingleParagraphSuggestingRange(state.document, from, to)) {
+    return createSuggestingUnsupportedTransaction(
+      state,
+      "Suggesting mode does not yet support multi-paragraph replacement ranges.",
+    );
+  }
+
+  if (isCollapsed) {
+    // 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;
+
+    // Remap existing review state first (comments, pre-existing revisions)
+    const reviewState = remapReviewStateAfterContentChange(
+      state,
+      result.document,
+      result.mapping,
+    );
+
+    // 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,
+    );
+
+    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" },
+        },
+      },
+    );
+  }
+
+  // Non-collapsed selection: mark selected text as deletion, insert new text after selection
+  // Step 1: Insert new text at the end of the selection
+  const insertSelection = createSelectionSnapshot(to, to);
+  const result = insertText(state.document, insertSelection, text, { timestamp: context.timestamp });
+  const insertedFrom = to;
+  const insertedTo = to + Array.from(text).length;
+
+  // Step 2: Remap existing review state through the mapping first
+  const reviewState = remapReviewStateAfterContentChange(
+    state,
+    result.document,
+    result.mapping,
+  );
+
+  // 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(
+    reviewState.document.review.revisions,
+    "deletion",
+    from,
+    to,
+    authorId,
+    context.timestamp,
+  );
+
+  // Step 4: Create insertion revision for the new text (positions already correct)
+  const insertionRevision = createAuthoredRevision(
+    {
+      ...reviewState.document.review.revisions,
+      [deletionRevision.changeId]: deletionRevision,
+    },
+    "insertion",
+    insertedFrom,
+    insertedTo,
+    authorId,
+    context.timestamp,
+  );
+
+  const finalDocument: CanonicalDocumentEnvelope = {
+    ...reviewState.document,
+    review: {
+      ...reviewState.document.review,
+      revisions: {
+        ...reviewState.document.review.revisions,
+        [deletionRevision.changeId]: deletionRevision,
+        [insertionRevision.changeId]: insertionRevision,
+      },
+    },
+  };
+
+  // Move cursor to after inserted text
+  const caretPos = insertedTo;
+
+  return createTransaction(
+    {
+      ...state,
+      document: finalDocument,
+      selection: createSelectionSnapshot(caretPos, caretPos),
+      warnings: reviewState.warnings,
+      runtime: {
+        ...state.runtime,
+        activeCommentId: reviewState.activeCommentId,
+      },
+    },
+    {
+      historyBoundary: "push",
+      markDirty: true,
+      mapping: result.mapping,
+      effects: {
+        ...reviewState.effects,
+        revisionAuthored: { changeId: insertionRevision.changeId, kind: "insertion" },
+      },
+    },
+  );
+}
+
+function applySuggestingDelete(
+  state: EditorState,
+  direction: "backward" | "forward",
+  context: CommandExecutionContext,
+): EditorTransaction | undefined {
+  if (state.readOnly) {
+    return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+  }
+
+  const authorId = context.defaultAuthorId ?? "unknown";
+  const selection = state.selection;
+  const from = Math.min(selection.anchor, selection.head);
+  const to = Math.max(selection.anchor, selection.head);
+  const isCollapsed = from === to;
+
+  if (!isCollapsed && !isSingleParagraphSuggestingRange(state.document, from, to)) {
+    return createSuggestingUnsupportedTransaction(
+      state,
+      "Suggesting mode does not yet support multi-paragraph deletion ranges.",
+    );
+  }
+
+  let deleteFrom: number;
+  let deleteTo: number;
+
+  if (isCollapsed) {
+    if (direction === "backward") {
+      deleteFrom = Math.max(0, from - 1);
+      deleteTo = from;
+    } else {
+      deleteFrom = from;
+      deleteTo = from + 1;
+    }
+  } else {
+    deleteFrom = from;
+    deleteTo = to;
+  }
+
+  // Validate the deletion range doesn't cross protected content
+  if (deleteFrom === deleteTo) {
+    return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+  }
+
+  // Check if the range overlaps an existing deletion revision from this suggesting session
+  // If so, extend the existing revision rather than creating a new one
+  const existingDeletion = findOverlappingAuthoredDeletion(
+    state.document.review.revisions,
+    deleteFrom,
+    deleteTo,
+  );
+
+  if (existingDeletion) {
+    // Extend the existing deletion revision to cover the new range
+    const extendedFrom = Math.min(
+      existingDeletion.anchor.kind === "range" ? existingDeletion.anchor.range.from : deleteFrom,
+      deleteFrom,
+    );
+    const extendedTo = Math.max(
+      existingDeletion.anchor.kind === "range" ? existingDeletion.anchor.range.to : deleteTo,
+      deleteTo,
+    );
+
+    const updatedRevision: CanonicalRevisionRecord = {
+      ...existingDeletion,
+      anchor: {
+        kind: "range",
+        range: { from: extendedFrom, to: extendedTo },
+        assoc: { start: 1, end: -1 },
+      },
+    };
+
+    const nextDocument: CanonicalDocumentEnvelope = {
+      ...state.document,
+      updatedAt: context.timestamp,
+      review: {
+        ...state.document.review,
+        revisions: {
+          ...state.document.review.revisions,
+          [updatedRevision.changeId]: updatedRevision,
+        },
+      },
+    };
+
+    const caretPos = direction === "backward" ? deleteFrom : deleteTo;
+
+    return createTransaction(
+      {
+        ...state,
+        document: nextDocument,
+        selection: createSelectionSnapshot(caretPos, caretPos),
+      },
+      {
+        historyBoundary: "push",
+        markDirty: true,
+        effects: {
+          revisionAuthored: { changeId: updatedRevision.changeId, kind: "deletion" },
+        },
+      },
+    );
+  }
+
+  // Create a new deletion revision — text stays in the document
+  const revision = createAuthoredRevision(
+    state.document.review.revisions,
+    "deletion",
+    deleteFrom,
+    deleteTo,
+    authorId,
+    context.timestamp,
+  );
+
+  const nextDocument: CanonicalDocumentEnvelope = {
+    ...state.document,
+    updatedAt: context.timestamp,
+    review: {
+      ...state.document.review,
+      revisions: {
+        ...state.document.review.revisions,
+        [revision.changeId]: revision,
+      },
+    },
+  };
+
+  const caretPos = direction === "backward" ? deleteFrom : deleteTo;
+
+  return createTransaction(
+    {
+      ...state,
+      document: nextDocument,
+      selection: createSelectionSnapshot(caretPos, caretPos),
+    },
+    {
+      historyBoundary: "push",
+      markDirty: true,
+      effects: {
+        revisionAuthored: { changeId: revision.changeId, kind: "deletion" },
+      },
+    },
+  );
+}
+
+function applySuggestingInsertUnit(
+  state: EditorState,
+  unitType: "tab" | "hard_break",
+  context: CommandExecutionContext,
+): EditorTransaction | undefined {
+  if (state.readOnly) {
+    return createTransaction(state, { historyBoundary: "skip", markDirty: false });
+  }
+
+  const authorId = context.defaultAuthorId ?? "unknown";
+  const selection = state.selection;
+  const from = Math.min(selection.anchor, selection.head);
+  const to = Math.max(selection.anchor, selection.head);
+
+  if (from !== to && !isSingleParagraphSuggestingRange(state.document, from, to)) {
+    return createSuggestingUnsupportedTransaction(
+      state,
+      "Suggesting mode does not yet support multi-paragraph replacement ranges.",
+    );
+  }
+
+  // Insert the unit at the end of the selection (or at cursor if collapsed)
+  const insertPos = to;
+  const insertSelection = createSelectionSnapshot(insertPos, insertPos);
+  const applyFn = unitType === "tab" ? insertTab : insertHardBreak;
+  const result = applyFn(state.document, insertSelection, { timestamp: context.timestamp });
+
+  // Remap existing review state first, before adding new revisions
+  const reviewState = remapReviewStateAfterContentChange(
+    state,
+    result.document,
+    result.mapping,
+  );
+
+  // If non-collapsed, mark selected range as deletion (positions are pre-mapping, content preserved)
+  const deletionRevision = from !== to
+    ? createAuthoredRevision(
+        reviewState.document.review.revisions,
+        "deletion",
+        from,
+        to,
+        authorId,
+        context.timestamp,
+      )
+    : undefined;
+
+  // Create insertion revision for the single inserted unit (positions already correct)
+  const insertionRevision = createAuthoredRevision(
+    {
+      ...reviewState.document.review.revisions,
+      ...(deletionRevision ? { [deletionRevision.changeId]: deletionRevision } : {}),
+    },
+    "insertion",
+    insertPos,
+    insertPos + 1,
+    authorId,
+    context.timestamp,
+  );
+
+  const finalDocument: CanonicalDocumentEnvelope = {
+    ...reviewState.document,
+    review: {
+      ...reviewState.document.review,
+      revisions: {
+        ...reviewState.document.review.revisions,
+        ...(deletionRevision ? { [deletionRevision.changeId]: deletionRevision } : {}),
+        [insertionRevision.changeId]: insertionRevision,
+      },
+    },
+  };
+
+  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: insertionRevision.changeId, kind: "insertion" },
+      },
+    },
+  );
+}
+
+function findOverlappingAuthoredDeletion(
+  revisions: Record<string, CanonicalRevisionRecord>,
+  from: number,
+  to: number,
+): CanonicalRevisionRecord | undefined {
+  for (const revision of Object.values(revisions)) {
+    if (
+      revision.kind === "deletion" &&
+      revision.status === "open" &&
+      revision.metadata?.source === "runtime" &&
+      revision.anchor.kind === "range"
+    ) {
+      const revFrom = revision.anchor.range.from;
+      const revTo = revision.anchor.range.to;
+      // Adjacent or overlapping: the deletion is directly next to or overlapping the range
+      if (
+        (from >= revFrom && from <= revTo) ||
+        (to >= revFrom && to <= revTo) ||
+        (from === revTo) ||
+        (to === revFrom)
+      ) {
+        return revision;
+      }
+    }
+  }
+  return undefined;
+}

package/src/index.ts

@@ -11,6 +11,7 @@ export type {
   EditorSessionState,
   EditorHostAdapter,
   WordReviewEditorProps,
+  WordReviewEditorChromeVisibility,
   WordReviewEditorRef,
   EditorUser,
   EditorDatastoreAdapter,
@@ -93,4 +94,8 @@ export type {
   WorkflowMarkupItem,
   WorkflowMarkupSnapshot,
   WorkflowCandidateRangeOptions,
+  HostAnnotationKind,
+  HostAnnotationItem,
+  HostAnnotationOverlay,
+  HostAnnotationSnapshot,
 } from "./api/public-types.ts";