@beyondwork/docx-react-component 1.0.17 → 1.0.19

package/src/runtime/document-runtime.ts

@@ -1,8 +1,8 @@
 import {
   createEditorState,
-  createSelectionSnapshot,
   createPersistedEditorSnapshot,
   deriveDocumentStats,
+  createSelectionSnapshot,
   type CanonicalDocumentEnvelope,
   type CommentEntryRecord,
   type CommentThreadRecord,
@@ -17,18 +17,32 @@ import type {
   CommentSidebarSnapshot,
   CommentSidebarThreadSnapshot,
   CompatibilityReport,
+  DocumentNavigationSnapshot,
+  EditorSessionState,
   EditorAnchorProjection,
   EditorError,
+  EditorStoryTarget,
+  EditorViewStateSnapshot,
   EditorWarning,
+  HeaderFooterLinkPatch,
   ExportDocxOptions,
   ExportResult,
+  PageLayoutSnapshot,
   PersistedEditorSnapshot,
   RuntimeRenderSnapshot,
   SelectionSnapshot,
+  StyleCatalogSnapshot,
   TrackedChangeEntrySnapshot,
   TrackedChangesSnapshot,
+  ViewMode,
+  WorkspaceMode,
   WordReviewEditorEvent,
+  ZoomLevel,
 } from "../api/public-types";
+import {
+  editorSessionStateFromPersistedSnapshot,
+  persistedSnapshotFromEditorSessionState,
+} from "../api/session-state.ts";
 import {
   executeEditorCommand,
   selectionChanged,
@@ -41,6 +55,8 @@ import {
   createDetachedAnchor,
   createNodeAnchor,
   createRangeAnchor,
+  MAIN_STORY_TARGET,
+  storyTargetsEqual,
   type EditorAnchorProjection as InternalEditorAnchorProjection,
 } from "../core/selection/mapping.ts";
 import { canCreateDocxCommentAnchor } from "../core/selection/review-anchors.ts";
@@ -53,21 +69,48 @@ import {
 import { buildCompatibilityReport } from "../validation/compatibility-engine.ts";
 import { mergeCompatibilityReports } from "../validation/compatibility-report.ts";
 import { createEditorSurfaceSnapshot } from "./surface-projection.ts";
-import { getFormattingStateFromRenderSnapshot } from "../core/commands/formatting-commands.ts";
+import { createDocumentNavigationSnapshot } from "./document-navigation.ts";
+import {
+  buildPageLayoutSnapshot,
+  buildResolvedSections,
+  resolveActiveSection,
+} from "./document-layout.ts";
+import { normalizeHeaderFooterTarget } from "./story-context.ts";
+import { storyTargetKey } from "./story-targeting.ts";
+import {
+  createViewState,
+  setViewMode as applyViewMode,
+  setWorkspaceMode as applyWorkspaceMode,
+  setZoomLevel as applyZoomLevel,
+  setFocused as applyFocused,
+  setCaretAffinity as applyCaretAffinity,
+  setActivePageRegion as applyActivePageRegion,
+  setActiveObjectFrame as applyActiveObjectFrame,
+  createEditorViewStateSnapshot,
+  type ViewState,
+} from "./view-state.ts";
+import type { PageMargins } from "../model/canonical-document.ts";
 
 export type Unsubscribe = () => void;
 
+type RuntimeReadySource = "docx" | "session" | "snapshot" | "datastore" | "canonical";
+
+export type DocumentRuntimeEvent =
+  | (Omit<Extract<WordReviewEditorEvent, { type: "ready" }>, "source"> & {
+      source: RuntimeReadySource;
+    })
+  | Exclude<WordReviewEditorEvent, { type: "ready" }>;
+
 export interface DocumentRuntime {
   subscribe(listener: () => void): Unsubscribe;
-  subscribeToEvents(listener: (event: WordReviewEditorEvent) => void): Unsubscribe;
+  subscribeToEvents(listener: (event: DocumentRuntimeEvent) => void): Unsubscribe;
   getRenderSnapshot(): RuntimeRenderSnapshot;
-  getFormattingState(): import("../api/public-types").FormattingStateSnapshot;
+  replaceText(text: string, target?: EditorAnchorProjection): void;
   dispatch(command: EditorCommand): void;
   undo(): void;
   redo(): void;
   focus(): void;
   blur(): void;
-  replaceText(text: string, target?: EditorAnchorProjection): void;
   addComment(params: AddCommentParams): string;
   openComment(commentId: string): void;
   resolveComment(commentId: string): void;
@@ -78,6 +121,16 @@ export interface DocumentRuntime {
   rejectChange(changeId: string): void;
   acceptAllChanges(): void;
   rejectAllChanges(): void;
+  openStory(target: EditorStoryTarget): boolean;
+  closeStory(): void;
+  getActiveStory(): EditorStoryTarget;
+  getViewState(): EditorViewStateSnapshot;
+  setViewMode(mode: ViewMode): void;
+  setWorkspaceMode(mode: WorkspaceMode): void;
+  setZoom(level: ZoomLevel): void;
+  getPageLayoutSnapshot(): PageLayoutSnapshot | null;
+  getDocumentNavigationSnapshot(): DocumentNavigationSnapshot;
+  getSessionState(): EditorSessionState;
   getPersistedSnapshot(): PersistedEditorSnapshot;
   getCompatibilityReport(): CompatibilityReport;
   getWarnings(): EditorWarning[];
@@ -86,22 +139,24 @@ export interface DocumentRuntime {
 
 export interface CreateDocumentRuntimeOptions {
   documentId: string;
+  initialSessionState?: EditorSessionState;
   initialSnapshot?: PersistedEditorSnapshot;
   initialCanonicalDocument?: CanonicalDocumentEnvelope;
   sourceLabel?: string;
-  sourceKind?: "docx" | "snapshot" | "datastore" | "canonical";
+  sourceKind?: RuntimeReadySource;
   readOnly?: boolean;
   editorBuild?: string;
   defaultAuthorId?: string;
   fatalError?: EditorError;
   clock?: () => string;
   exportDocx?: (
-    snapshot: PersistedEditorSnapshot,
+    sessionState: EditorSessionState,
     options?: ExportDocxOptions,
   ) => Promise<ExportResult>;
-  onEvent?: (event: WordReviewEditorEvent) => void;
+  onEvent?: (event: DocumentRuntimeEvent) => void;
   onWarning?: (warning: EditorWarning) => void;
   onError?: (error: EditorError) => void;
+  initialViewState?: Partial<ViewState>;
 }
 
 interface HistoryState {
@@ -116,28 +171,44 @@ export function createDocumentRuntime(
   const editorBuild = options.editorBuild ?? "dev";
   const sessionId = createSessionId(options.documentId, clock());
   const listeners = new Set<() => void>();
-  const eventListeners = new Set<(event: WordReviewEditorEvent) => void>();
+  const eventListeners = new Set<(event: DocumentRuntimeEvent) => void>();
   const history: HistoryState = {
     past: [],
     future: [],
   };
 
+  let activeStory: EditorStoryTarget = MAIN_STORY_TARGET;
+  const storySelections = new Map<string, EditorState["selection"]>();
+  let viewState: ViewState = createViewState(options.initialViewState);
+  const initialPersistedSnapshot = options.initialSessionState
+    ? persistedSnapshotFromEditorSessionState(options.initialSessionState, {
+        savedAt: options.initialSessionState.updatedAt,
+      })
+    : options.initialSnapshot;
+
   let state = createEditorState({
     documentId: options.documentId,
     sessionId,
     sourceLabel: options.sourceLabel,
     readOnly: options.readOnly,
-    persistedSnapshot: options.initialSnapshot as never,
+    persistedSnapshot: initialPersistedSnapshot as never,
     canonicalDocument: options.initialCanonicalDocument,
     fatalError: options.fatalError as never,
   });
-  let cachedRenderSnapshot = createPublicRenderSnapshot(state, history);
+  storySelections.set(storyTargetKey(MAIN_STORY_TARGET), state.selection);
+  let cachedRenderSnapshot = createPublicRenderSnapshot(state, history, activeStory);
 
   emit({
     type: "ready",
     documentId: state.documentId,
     sessionId: state.sessionId,
-    source: options.sourceKind ?? (options.initialSnapshot ? "snapshot" : "canonical"),
+    source:
+      options.sourceKind ??
+      (options.initialSessionState
+        ? "session"
+        : options.initialSnapshot
+          ? "snapshot"
+          : "canonical"),
     stats: toPublicDocumentStats(state),
     compatibility: toPublicCompatibilityReport(createDerivedCompatibility(state)),
     comments: cachedRenderSnapshot.comments,
@@ -167,9 +238,6 @@ export function createDocumentRuntime(
     getRenderSnapshot() {
       return cachedRenderSnapshot;
     },
-    getFormattingState() {
-      return getFormattingStateFromRenderSnapshot(cachedRenderSnapshot);
-    },
     dispatch(command) {
       if (command.type === "history.undo") {
         applyHistory("undo");
@@ -203,6 +271,7 @@ export function createDocumentRuntime(
       });
     },
     focus() {
+      viewState = applyFocused(viewState, true);
       this.dispatch({
         type: "runtime.focus",
         focused: true,
@@ -210,6 +279,7 @@ export function createDocumentRuntime(
       });
     },
     blur() {
+      viewState = applyFocused(viewState, false);
       this.dispatch({
         type: "runtime.focus",
         focused: false,
@@ -351,13 +421,94 @@ export function createDocumentRuntime(
         origin: createOrigin("api", clock()),
       });
     },
-    getPersistedSnapshot() {
+    openStory(target) {
+      const normalizedTarget =
+        target.kind === "header" || target.kind === "footer"
+          ? normalizeHeaderFooterTarget(
+              state.document,
+              target,
+              cachedRenderSnapshot.pageLayout?.sectionIndex,
+            ) ?? target
+          : target;
+      if (storyTargetsEqual(activeStory, normalizedTarget)) {
+        return true;
+      }
+      if (!isValidStoryTarget(state, normalizedTarget)) {
+        return false;
+      }
+      switchActiveStory(normalizedTarget);
+      return true;
+    },
+    closeStory() {
+      if (activeStory.kind === "main") {
+        return;
+      }
+      switchActiveStory(MAIN_STORY_TARGET);
+    },
+    getActiveStory() {
+      return activeStory;
+    },
+    getViewState() {
+      const surface = cachedRenderSnapshot.surface;
+      const mainSurface =
+        activeStory.kind === "main"
+          ? surface
+          : createEditorSurfaceSnapshot(state.document, state.selection, MAIN_STORY_TARGET);
+      return createEditorViewStateSnapshot(
+        viewState,
+        activeStory,
+        toPublicSelectionSnapshot(state.selection, activeStory),
+        surface,
+        mainSurface,
+        cachedRenderSnapshot.pageLayout,
+        state.document.numbering,
+      );
+    },
+    setViewMode(mode) {
+      viewState = applyViewMode(viewState, mode);
+      cachedRenderSnapshot = createPublicRenderSnapshot(state, history, activeStory);
+      for (const listener of listeners) {
+        listener();
+      }
+    },
+    setWorkspaceMode(mode) {
+      viewState = applyWorkspaceMode(viewState, mode);
+      cachedRenderSnapshot = createPublicRenderSnapshot(state, history, activeStory);
+      for (const listener of listeners) {
+        listener();
+      }
+    },
+    setZoom(level) {
+      viewState = applyZoomLevel(viewState, level);
+      cachedRenderSnapshot = createPublicRenderSnapshot(state, history, activeStory);
+      for (const listener of listeners) {
+        listener();
+      }
+    },
+    getPageLayoutSnapshot() {
+      return derivePageLayoutSnapshot(state, activeStory, storySelections);
+    },
+    getDocumentNavigationSnapshot() {
+      return createDocumentNavigationSnapshot(
+        state.document,
+        state.selection.head,
+        activeStory,
+      );
+    },
+    getSessionState() {
       const compatibility = createDerivedCompatibility(state);
-      return createPersistedEditorSnapshot(state, {
-        editorBuild,
+      return editorSessionStateFromPersistedSnapshot(
+        createPersistedEditorSnapshot(state, {
+          editorBuild,
+          savedAt: clock(),
+          compatibility,
+        }) as unknown as PersistedEditorSnapshot,
+      );
+    },
+    getPersistedSnapshot() {
+      return persistedSnapshotFromEditorSessionState(this.getSessionState(), {
         savedAt: clock(),
-        compatibility,
-      }) as unknown as PersistedEditorSnapshot;
+      });
     },
     getCompatibilityReport() {
       return toPublicCompatibilityReport(createDerivedCompatibility(state));
@@ -381,14 +532,7 @@ export function createDocumentRuntime(
         throw new Error(error.message);
       }
 
-      const result = await options.exportDocx(
-        createPersistedEditorSnapshot(state, {
-          editorBuild,
-          savedAt: clock(),
-          compatibility: createDerivedCompatibility(state),
-        }) as unknown as PersistedEditorSnapshot,
-        exportOptions,
-      );
+      const result = await options.exportDocx(this.getSessionState(), exportOptions);
 
       emit({
         type: "export_completed",
@@ -415,7 +559,8 @@ export function createDocumentRuntime(
     // Undo/redo changes the document — must mint a new revisionToken so
     // autosave/export checkpoint dedup treats it as fresh content.
     state = finalizeState(target, true, clock());
-    cachedRenderSnapshot = createPublicRenderSnapshot(state, history);
+    storySelections.set(storyTargetKey(activeStory), state.selection);
+    cachedRenderSnapshot = createPublicRenderSnapshot(state, history, activeStory);
     notify(previous, state, {
       nextState: state,
       mapping: { steps: [] },
@@ -437,7 +582,8 @@ export function createDocumentRuntime(
     }
 
     state = finalizeState(transaction.nextState, transaction.markDirty, clock());
-    cachedRenderSnapshot = createPublicRenderSnapshot(state, history);
+    storySelections.set(storyTargetKey(activeStory), state.selection);
+    cachedRenderSnapshot = createPublicRenderSnapshot(state, history, activeStory);
     notify(previous, state, transaction);
   }
 
@@ -458,7 +604,7 @@ export function createDocumentRuntime(
       emit({
         type: "selection_changed",
         documentId: next.documentId,
-        selection: toPublicSelectionSnapshot(next.selection),
+        selection: toPublicSelectionSnapshot(next.selection, activeStory),
       });
     }
 
@@ -519,7 +665,7 @@ export function createDocumentRuntime(
     }
   }
 
-  function emit(event: WordReviewEditorEvent): void {
+  function emit(event: DocumentRuntimeEvent): void {
     options.onEvent?.(event);
     for (const listener of eventListeners) {
       listener(event);
@@ -533,7 +679,8 @@ export function createDocumentRuntime(
       fatalError: error.isFatal ? error : state.fatalError,
     };
     state = nextState;
-    cachedRenderSnapshot = createPublicRenderSnapshot(state, history);
+    storySelections.set(storyTargetKey(activeStory), state.selection);
+    cachedRenderSnapshot = createPublicRenderSnapshot(state, history, activeStory);
     const publicError = toPublicError(error);
     options.onError?.(publicError);
     emit({
@@ -545,6 +692,39 @@ export function createDocumentRuntime(
       listener();
     }
   }
+
+  function switchActiveStory(target: EditorStoryTarget): void {
+    const previousStory = activeStory;
+    const previousSelection = state.selection;
+    storySelections.set(storyTargetKey(previousStory), previousSelection);
+
+    const restoredSelection =
+      storySelections.get(storyTargetKey(target)) ?? createSelectionSnapshot(0, 0);
+    activeStory = target;
+    state = {
+      ...state,
+      selection: restoredSelection,
+    };
+    storySelections.set(storyTargetKey(target), restoredSelection);
+    cachedRenderSnapshot = createPublicRenderSnapshot(state, history, activeStory);
+
+    if (selectionChanged(previousSelection, restoredSelection)) {
+      emit({
+        type: "selection_changed",
+        documentId: state.documentId,
+        selection: toPublicSelectionSnapshot(restoredSelection, activeStory),
+      });
+    }
+
+    emit({
+      type: "story_changed",
+      documentId: state.documentId,
+      activeStory,
+    });
+    for (const listener of listeners) {
+      listener();
+    }
+  }
 }
 
 function createSessionId(documentId: string, timestamp: string): string {
@@ -623,11 +803,13 @@ function toRuntimeError(error: unknown): InternalEditorError {
 function createPublicRenderSnapshot(
   state: EditorState,
   history: HistoryState,
+  activeStory: EditorStoryTarget,
 ): RuntimeRenderSnapshot {
   const compatibility = createDerivedCompatibility(state);
-  const surface = createEditorSurfaceSnapshot(state.document, state.selection);
+  const surface = createEditorSurfaceSnapshot(state.document, state.selection, activeStory);
   const comments = toPublicCommentSidebarSnapshot(state);
   const trackedChanges = toPublicTrackedChangesSnapshot(state, surface.plainText);
+  const pageLayout = derivePageLayoutSnapshot(state, activeStory);
 
   return {
     documentId: state.documentId,
@@ -637,7 +819,9 @@ function createPublicRenderSnapshot(
     isReady: state.phase === "ready",
     isDirty: state.isDirty,
     readOnly: state.readOnly,
-    selection: toPublicSelectionSnapshot(state.selection),
+    selection: toPublicSelectionSnapshot(state.selection, activeStory),
+    activeStory,
+    pageLayout: pageLayout ?? undefined,
     documentStats: toPublicDocumentStats(state),
     comments,
     trackedChanges,
@@ -673,12 +857,14 @@ function toPublicDocumentStats(state: Pick<EditorState, "document">) {
 
 function toPublicSelectionSnapshot(
   selection: EditorState["selection"],
+  storyTarget?: EditorStoryTarget,
 ): SelectionSnapshot {
   return {
     anchor: selection.anchor,
     head: selection.head,
     isCollapsed: selection.isCollapsed,
     activeRange: toPublicAnchorProjection(selection.activeRange),
+    ...(storyTarget && storyTarget.kind !== "main" ? { storyTarget } : {}),
   };
 }
 
@@ -1026,6 +1212,50 @@ function summarizeRevisionExcerpt(
   return collapsed.length > 96 ? `${collapsed.slice(0, 93)}...` : collapsed;
 }
 
+function isValidStoryTarget(
+  state: EditorState,
+  target: EditorStoryTarget,
+): boolean {
+  if (target.kind === "main") return true;
+  const subParts = state.document.subParts;
+  if (!subParts) return false;
+
+  switch (target.kind) {
+    case "header":
+      return Boolean(normalizeHeaderFooterTarget(state.document, target));
+    case "footer":
+      return Boolean(normalizeHeaderFooterTarget(state.document, target));
+    case "footnote":
+      return Boolean(subParts.footnoteCollection?.footnotes?.[target.noteId]);
+    case "endnote":
+      return Boolean(subParts.footnoteCollection?.endnotes?.[target.noteId]);
+  }
+}
+
+function derivePageLayoutSnapshot(
+  state: EditorState,
+  activeStory: EditorStoryTarget,
+  storySelections?: ReadonlyMap<string, EditorState["selection"]>,
+): PageLayoutSnapshot | null {
+  const subParts = state.document.subParts;
+  const sections = buildResolvedSections(state.document);
+  if (!subParts && sections.length === 0) {
+    return null;
+  }
+
+  const activeSection = resolveActiveSection(
+    state,
+    activeStory,
+    sections,
+    storySelections,
+  );
+  return buildPageLayoutSnapshot(
+    activeSection?.index ?? 0,
+    activeSection?.properties ?? subParts?.finalSectionProperties,
+    subParts,
+  );
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }

package/src/runtime/document-search.ts

@@ -0,0 +1,145 @@
+import type {
+  DocumentNavigationSnapshot,
+  EditorStoryTarget,
+  SearchOptions,
+  SearchResultSnapshot,
+  SelectionSnapshot,
+} from "../api/public-types";
+import {
+  MAIN_STORY_TARGET,
+  storyTargetsEqual,
+} from "../core/selection/mapping.ts";
+import {
+  createSelectionSnapshot,
+  type CanonicalDocumentEnvelope,
+} from "../core/state/editor-state.ts";
+import {
+  searchSecondaryStories,
+  searchSurfaceBlocks,
+} from "../core/search/search-text.ts";
+import { findPageForOffset } from "./document-navigation.ts";
+import {
+  buildResolvedSections,
+  resolveSectionForStoryTarget,
+} from "./document-layout.ts";
+import { createEditorSurfaceSnapshot } from "./surface-projection.ts";
+
+export function searchDocument(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+  activeStory: EditorStoryTarget,
+  navigation: DocumentNavigationSnapshot,
+  query: string,
+  options: SearchOptions = {},
+): SearchResultSnapshot[] {
+  const normalizedQuery = query.trim();
+  if (!normalizedQuery) {
+    return [];
+  }
+
+  const mainSurface = createEditorSurfaceSnapshot(
+    document,
+    createSelectionSnapshot(selection.anchor, selection.head),
+    MAIN_STORY_TARGET,
+  );
+  const sections = buildResolvedSections(document);
+  const combined: SearchResultSnapshot[] = [];
+
+  for (const match of searchSurfaceBlocks(mainSurface.blocks, normalizedQuery, options)) {
+    const pageIndex = findPageForOffset(navigation.pages, match.from);
+    combined.push({
+      resultId: `search-main-${combined.length}`,
+      anchor: {
+        kind: "range",
+        from: match.from,
+        to: match.to,
+        assoc: {
+          start: -1,
+          end: 1,
+        },
+      },
+      excerpt: match.excerpt,
+      isActive: false,
+      storyTarget: MAIN_STORY_TARGET,
+      sectionIndex: navigation.pages[pageIndex]?.sectionIndex ?? 0,
+      pageIndex,
+    });
+  }
+
+  for (const match of searchSecondaryStories(
+    mainSurface.secondaryStories,
+    normalizedQuery,
+    options,
+  )) {
+    const section = resolveSectionForStoryTarget(
+      document,
+      sections,
+      match.storyTarget,
+    );
+    const pageIndex =
+      section === undefined
+        ? undefined
+        : navigation.pages.find((page) => page.sectionIndex === section.index)
+          ?.pageIndex ?? 0;
+
+    combined.push({
+      resultId: `search-secondary-${combined.length}`,
+      anchor: {
+        kind: "range",
+        from: match.from,
+        to: match.to,
+        assoc: {
+          start: -1,
+          end: 1,
+        },
+      },
+      excerpt: match.excerpt,
+      isActive: false,
+      storyTarget: match.storyTarget,
+      ...(section ? { sectionIndex: section.index } : {}),
+      ...(pageIndex !== undefined ? { pageIndex } : {}),
+    });
+  }
+
+  const limited = combined.slice(0, options.limit ?? Number.POSITIVE_INFINITY);
+  const activeIndex = getActiveSearchResultIndex(limited, selection, activeStory);
+
+  return limited.map((result, index) => ({
+    ...result,
+    isActive: index === activeIndex,
+  }));
+}
+
+function getActiveSearchResultIndex(
+  results: readonly SearchResultSnapshot[],
+  selection: SelectionSnapshot,
+  activeStory: EditorStoryTarget,
+): number {
+  if (results.length === 0) {
+    return -1;
+  }
+
+  const selectionFrom = Math.min(selection.anchor, selection.head);
+  const selectionTo = Math.max(selection.anchor, selection.head);
+  const activeIndex = results.findIndex((result) => {
+    if (!result.storyTarget || !storyTargetsEqual(result.storyTarget, activeStory)) {
+      return false;
+    }
+
+    if (result.anchor.kind !== "range") {
+      return false;
+    }
+
+    if (selectionFrom === selectionTo) {
+      return (
+        selectionFrom >= result.anchor.from && selectionFrom <= result.anchor.to
+      );
+    }
+
+    return (
+      selectionFrom < result.anchor.to && selectionTo > result.anchor.from
+    );
+  });
+
+  return activeIndex >= 0 ? activeIndex : 0;
+}