@beyondwork/docx-react-component 1.0.18 → 1.0.19

package/src/core/commands/style-commands.ts

@@ -0,0 +1,262 @@
+import type {
+  PersistedEditorSnapshot,
+  RuntimeRenderSnapshot,
+  SurfaceBlockSnapshot,
+} from "../../api/public-types";
+import type {
+  BlockNode,
+  DocumentRootNode,
+  ParagraphNode,
+  TableNode,
+} from "../../model/canonical-document.ts";
+
+type CanonicalDocumentEnvelope = PersistedEditorSnapshot["canonicalDocument"];
+
+export interface StyleMutationResult {
+  document: CanonicalDocumentEnvelope;
+  selection: RuntimeRenderSnapshot["selection"];
+  changed: boolean;
+}
+
+export function applyParagraphStyleToDocument(
+  document: CanonicalDocumentEnvelope,
+  snapshot: RuntimeRenderSnapshot,
+  styleId: string | null,
+): StyleMutationResult {
+  const surface = snapshot.surface;
+  if (!surface) {
+    return {
+      document,
+      selection: snapshot.selection,
+      changed: false,
+    };
+  }
+
+  const nextDocument = structuredClone(document);
+  const root = nextDocument.content as DocumentRootNode;
+  const normalizedStyleId = normalizeStyleId(styleId);
+  if (!isValidParagraphStyleId(document, normalizedStyleId)) {
+    return {
+      document,
+      selection: snapshot.selection,
+      changed: false,
+    };
+  }
+  let changed = false;
+
+  visitParagraphBindings(root.children, surface.blocks, (paragraph, paragraphSurface) => {
+    if (
+      !selectionTouchesRange(
+        snapshot.selection.anchor,
+        snapshot.selection.head,
+        paragraphSurface.from,
+        paragraphSurface.to,
+      )
+    ) {
+      return;
+    }
+
+    if (paragraph.styleId === normalizedStyleId) {
+      return;
+    }
+
+    if (normalizedStyleId) {
+      paragraph.styleId = normalizedStyleId;
+    } else {
+      delete paragraph.styleId;
+    }
+    changed = true;
+  });
+
+  return {
+    document: changed ? nextDocument : document,
+    selection: snapshot.selection,
+    changed,
+  };
+}
+
+export function applyTableStyleToDocument(
+  document: CanonicalDocumentEnvelope,
+  snapshot: RuntimeRenderSnapshot,
+  styleId: string | null,
+): StyleMutationResult {
+  const surface = snapshot.surface;
+  if (!surface) {
+    return {
+      document,
+      selection: snapshot.selection,
+      changed: false,
+    };
+  }
+
+  const nextDocument = structuredClone(document);
+  const root = nextDocument.content as DocumentRootNode;
+  const normalizedStyleId = normalizeStyleId(styleId);
+  if (!isValidTableStyleId(document, normalizedStyleId)) {
+    return {
+      document,
+      selection: snapshot.selection,
+      changed: false,
+    };
+  }
+  let changed = false;
+  let applied = false;
+
+  visitTableBindings(root.children, surface.blocks, (table, tableSurface) => {
+    if (
+      applied ||
+      !selectionTouchesRange(
+        snapshot.selection.anchor,
+        snapshot.selection.head,
+        tableSurface.from,
+        tableSurface.to,
+      )
+    ) {
+      return;
+    }
+
+    if (table.styleId === normalizedStyleId) {
+      applied = true;
+      return;
+    }
+
+    if (normalizedStyleId) {
+      table.styleId = normalizedStyleId;
+    } else {
+      delete table.styleId;
+    }
+    changed = true;
+    applied = true;
+  });
+
+  return {
+    document: changed ? nextDocument : document,
+    selection: snapshot.selection,
+    changed,
+  };
+}
+
+function normalizeStyleId(styleId: string | null): string | undefined {
+  if (styleId === null) {
+    return undefined;
+  }
+  const normalized = styleId.trim();
+  return normalized.length > 0 ? normalized : undefined;
+}
+
+function isValidParagraphStyleId(
+  document: CanonicalDocumentEnvelope,
+  styleId: string | undefined,
+): boolean {
+  return styleId === undefined || Boolean(document.styles.paragraphs[styleId]);
+}
+
+function isValidTableStyleId(
+  document: CanonicalDocumentEnvelope,
+  styleId: string | undefined,
+): boolean {
+  return styleId === undefined || Boolean(document.styles.tables[styleId]);
+}
+
+function visitParagraphBindings(
+  blocks: BlockNode[],
+  surfaceBlocks: SurfaceBlockSnapshot[],
+  visitor: (paragraph: ParagraphNode, surface: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>) => void,
+): void {
+  for (let index = 0; index < Math.min(blocks.length, surfaceBlocks.length); index += 1) {
+    const block = blocks[index];
+    const surface = surfaceBlocks[index];
+    if (!block || !surface) {
+      continue;
+    }
+
+    if (block.type === "paragraph" && surface.kind === "paragraph") {
+      visitor(block, surface);
+      continue;
+    }
+
+    if (block.type === "table" && surface.kind === "table") {
+      for (let rowIndex = 0; rowIndex < Math.min(block.rows.length, surface.rows.length); rowIndex += 1) {
+        const row = block.rows[rowIndex];
+        const surfaceRow = surface.rows[rowIndex];
+        if (!row || !surfaceRow) {
+          continue;
+        }
+        for (let cellIndex = 0; cellIndex < Math.min(row.cells.length, surfaceRow.cells.length); cellIndex += 1) {
+          const cell = row.cells[cellIndex];
+          const surfaceCell = surfaceRow.cells[cellIndex];
+          if (!cell || !surfaceCell) {
+            continue;
+          }
+          visitParagraphBindings(cell.children, surfaceCell.content, visitor);
+        }
+      }
+      continue;
+    }
+
+    if (block.type === "sdt" && surface.kind === "sdt_block") {
+      visitParagraphBindings(block.children, surface.children, visitor);
+    }
+  }
+}
+
+function visitTableBindings(
+  blocks: BlockNode[],
+  surfaceBlocks: SurfaceBlockSnapshot[],
+  visitor: (table: TableNode, surface: Extract<SurfaceBlockSnapshot, { kind: "table" }>) => void,
+): void {
+  for (let index = 0; index < Math.min(blocks.length, surfaceBlocks.length); index += 1) {
+    const block = blocks[index];
+    const surface = surfaceBlocks[index];
+    if (!block || !surface) {
+      continue;
+    }
+
+    if (block.type === "table" && surface.kind === "table") {
+      visitor(block, surface);
+      for (let rowIndex = 0; rowIndex < Math.min(block.rows.length, surface.rows.length); rowIndex += 1) {
+        const row = block.rows[rowIndex];
+        const surfaceRow = surface.rows[rowIndex];
+        if (!row || !surfaceRow) {
+          continue;
+        }
+        for (let cellIndex = 0; cellIndex < Math.min(row.cells.length, surfaceRow.cells.length); cellIndex += 1) {
+          const cell = row.cells[cellIndex];
+          const surfaceCell = surfaceRow.cells[cellIndex];
+          if (!cell || !surfaceCell) {
+            continue;
+          }
+          visitTableBindings(cell.children, surfaceCell.content, visitor);
+        }
+      }
+      continue;
+    }
+
+    if (block.type === "sdt" && surface.kind === "sdt_block") {
+      visitTableBindings(block.children, surface.children, visitor);
+    }
+  }
+}
+
+function selectionTouchesRange(
+  anchor: number,
+  head: number,
+  rangeFrom: number,
+  rangeTo: number,
+): boolean {
+  const selectionFrom = Math.min(anchor, head);
+  const selectionTo = Math.max(anchor, head);
+  if (selectionFrom === selectionTo) {
+    return selectionFrom >= rangeFrom && selectionFrom <= rangeTo;
+  }
+  return rangesOverlap(selectionFrom, selectionTo, rangeFrom, rangeTo);
+}
+
+function rangesOverlap(
+  leftFrom: number,
+  leftTo: number,
+  rightFrom: number,
+  rightTo: number,
+): boolean {
+  return leftFrom < rightTo && leftTo > rightFrom;
+}

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

@@ -0,0 +1,329 @@
+import type {
+  EditorStoryTarget,
+  SearchOptions as PublicSearchOptions,
+  SecondaryStorySurface,
+  SurfaceBlockSnapshot,
+} from "../../api/public-types";
+
+export interface SearchTextOptions extends PublicSearchOptions {
+  caseSensitive?: boolean;
+  regex?: boolean;
+}
+
+export interface SearchResult {
+  from: number;
+  to: number;
+  text: string;
+  index: number;
+}
+
+export interface SurfaceSearchResult extends SearchResult {
+  excerpt: string;
+}
+
+export interface SecondaryStorySearchResult extends SurfaceSearchResult {
+  storyTarget: EditorStoryTarget;
+}
+
+interface ProjectedSurfaceText {
+  text: string;
+  offsetMap: Array<number | null>;
+}
+
+interface SurfaceProjectionBuilder {
+  text: string[];
+  offsetMap: Array<number | null>;
+  nextRuntimeOffset: number;
+}
+
+export function buildSearchPattern(
+  query: string,
+  options: SearchTextOptions = {},
+): RegExp | null {
+  if (!query) {
+    return null;
+  }
+
+  const caseSensitive = options.matchCase ?? options.caseSensitive ?? false;
+  const regex = options.regex ?? false;
+  const wholeWord = options.wholeWord ?? false;
+
+  try {
+    const source = regex
+      ? query
+      : query.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const wrapped = wholeWord ? `\\b${source}\\b` : source;
+    return new RegExp(wrapped, caseSensitive ? "g" : "gi");
+  } catch {
+    return null;
+  }
+}
+
+export function findSearchMatches(
+  text: string,
+  query: string,
+  options: SearchTextOptions = {},
+): SearchResult[] {
+  const pattern = buildSearchPattern(query, options);
+  if (!pattern) return [];
+
+  const results: SearchResult[] = [];
+  let match: RegExpExecArray | null;
+  pattern.lastIndex = 0;
+  while ((match = pattern.exec(text)) !== null) {
+    results.push({
+      from: match.index,
+      to: match.index + match[0].length,
+      text: match[0],
+      index: results.length,
+    });
+
+    if (match[0].length === 0) {
+      pattern.lastIndex += 1;
+    }
+  }
+
+  return results;
+}
+
+export function createSearchExcerpt(
+  text: string,
+  from: number,
+  to: number,
+  radius = 24,
+): string {
+  const safeFrom = Math.max(0, Math.min(from, text.length));
+  const safeTo = Math.max(safeFrom, Math.min(to, text.length));
+  const start = Math.max(0, safeFrom - radius);
+  const end = Math.min(text.length, safeTo + radius);
+  const prefix = start > 0 ? "…" : "";
+  const suffix = end < text.length ? "…" : "";
+  const excerpt = text
+    .slice(start, end)
+    .replace(/[\uFFF9\uFFFA]/gu, "")
+    .replace(/\s{2,}/gu, " ")
+    .trim();
+  return `${prefix}${excerpt}${suffix}`;
+}
+
+export function searchSurfaceBlocks(
+  blocks: readonly SurfaceBlockSnapshot[],
+  query: string,
+  options: SearchTextOptions = {},
+): SurfaceSearchResult[] {
+  const projection = projectSurfaceText(blocks);
+  return findSearchMatches(projection.text, query, options)
+    .map((match) => {
+      const range = resolveProjectedRuntimeRange(
+        projection.offsetMap,
+        match.from,
+        match.to,
+      );
+      if (!range) {
+        return null;
+      }
+
+      return {
+        ...match,
+        from: range.from,
+        to: range.to,
+        excerpt: createSearchExcerpt(projection.text, match.from, match.to),
+      };
+    })
+    .filter((match): match is SurfaceSearchResult => Boolean(match));
+}
+
+export function searchSecondaryStories(
+  stories: readonly SecondaryStorySurface[],
+  query: string,
+  options: SearchTextOptions = {},
+): SecondaryStorySearchResult[] {
+  const results: SecondaryStorySearchResult[] = [];
+
+  for (const story of stories) {
+    for (const match of searchSurfaceBlocks(story.blocks, query, options)) {
+      results.push({
+        storyTarget: story.target,
+        from: match.from,
+        to: match.to,
+        text: match.text,
+        index: results.length,
+        excerpt: match.excerpt,
+      });
+    }
+  }
+
+  return results;
+}
+
+export function projectSurfaceText(
+  blocks: readonly SurfaceBlockSnapshot[],
+): ProjectedSurfaceText {
+  const builder: SurfaceProjectionBuilder = {
+    text: [],
+    offsetMap: [],
+    nextRuntimeOffset: 0,
+  };
+
+  appendSurfaceBlocks(builder, blocks);
+
+  return {
+    text: builder.text.join(""),
+    offsetMap: builder.offsetMap,
+  };
+}
+
+function appendSurfaceBlocks(
+  builder: SurfaceProjectionBuilder,
+  blocks: readonly SurfaceBlockSnapshot[],
+): void {
+  for (const block of blocks) {
+    if (block.kind === "opaque_block") {
+      if (block.fragmentId.startsWith("preview:")) {
+        continue;
+      }
+      appendAtomicSpan(builder, block.from, block.to, "\uFFFA");
+      continue;
+    }
+
+    if (block.kind === "table") {
+      appendRuntimeGap(builder, block.from);
+      for (const [rowIndex, row] of block.rows.entries()) {
+        if (rowIndex > 0) {
+          appendSyntheticSeparator(builder, "\n");
+        }
+        for (const [cellIndex, cell] of row.cells.entries()) {
+          if (cellIndex > 0) {
+            appendSyntheticSeparator(builder, "\t");
+          }
+          appendSurfaceBlocks(builder, cell.content);
+        }
+      }
+      appendRuntimeGap(builder, block.to);
+      continue;
+    }
+
+    if (block.kind === "sdt_block") {
+      appendRuntimeGap(builder, block.from);
+      appendSurfaceBlocks(builder, block.children);
+      appendRuntimeGap(builder, block.to);
+      continue;
+    }
+
+    for (const segment of block.segments) {
+      switch (segment.kind) {
+        case "text":
+          appendTextSpan(builder, segment.text, segment.from);
+          break;
+        case "tab":
+          appendAtomicSpan(builder, segment.from, segment.to, "\t");
+          break;
+        case "hard_break":
+          appendAtomicSpan(builder, segment.from, segment.to, "\n");
+          break;
+        case "image":
+          appendAtomicSpan(builder, segment.from, segment.to, "\uFFFC");
+          break;
+        case "opaque_inline":
+          appendAtomicSpan(builder, segment.from, segment.to, "\uFFF9");
+          break;
+        case "note_ref":
+          appendAtomicSpan(builder, segment.from, segment.to, "\uFFFA");
+          break;
+      }
+    }
+
+    appendRuntimeGap(builder, block.to);
+  }
+}
+
+function appendTextSpan(
+  builder: SurfaceProjectionBuilder,
+  text: string,
+  startOffset: number,
+): void {
+  appendRuntimeGap(builder, startOffset);
+
+  for (let index = 0; index < text.length; index += 1) {
+    builder.text.push(text[index]!);
+    builder.offsetMap.push(startOffset + index);
+  }
+
+  builder.nextRuntimeOffset = Math.max(
+    builder.nextRuntimeOffset,
+    startOffset + text.length,
+  );
+}
+
+function appendAtomicSpan(
+  builder: SurfaceProjectionBuilder,
+  from: number,
+  to: number,
+  char: string,
+): void {
+  appendRuntimeGap(builder, from);
+  const width = Math.max(1, to - from);
+
+  for (let index = 0; index < width; index += 1) {
+    builder.text.push(char);
+    builder.offsetMap.push(from + index);
+  }
+
+  builder.nextRuntimeOffset = Math.max(builder.nextRuntimeOffset, to);
+}
+
+function appendRuntimeGap(
+  builder: SurfaceProjectionBuilder,
+  nextFrom: number,
+): void {
+  for (
+    let offset = builder.nextRuntimeOffset;
+    offset < nextFrom;
+    offset += 1
+  ) {
+    builder.text.push("\n");
+    builder.offsetMap.push(offset);
+  }
+
+  builder.nextRuntimeOffset = Math.max(builder.nextRuntimeOffset, nextFrom);
+}
+
+function appendSyntheticSeparator(
+  builder: SurfaceProjectionBuilder,
+  value: string,
+): void {
+  for (const char of value) {
+    builder.text.push(char);
+    builder.offsetMap.push(null);
+  }
+}
+
+function resolveProjectedRuntimeRange(
+  offsetMap: ReadonlyArray<number | null>,
+  from: number,
+  to: number,
+): { from: number; to: number } | null {
+  let runtimeFrom: number | undefined;
+  for (let index = from; index < to; index += 1) {
+    const offset = offsetMap[index];
+    if (offset !== null && offset !== undefined) {
+      runtimeFrom = offset;
+      break;
+    }
+  }
+
+  let runtimeTo: number | undefined;
+  for (let index = to - 1; index >= from; index -= 1) {
+    const offset = offsetMap[index];
+    if (offset !== null && offset !== undefined) {
+      runtimeTo = offset + 1;
+      break;
+    }
+  }
+
+  if (runtimeFrom === undefined || runtimeTo === undefined) {
+    return null;
+  }
+
+  return { from: runtimeFrom, to: runtimeTo };
+}

package/src/core/selection/mapping.ts

@@ -1,3 +1,5 @@
+import type { EditorStoryTarget } from "../../api/public-types";
+
 export type Position = number;
 export type Assoc = -1 | 1;
 
@@ -211,6 +213,45 @@ export function areAnchorsEqual(
   return false;
 }
 
+export function storyTargetsEqual(
+  left: EditorStoryTarget | undefined,
+  right: EditorStoryTarget | undefined,
+): boolean {
+  if (left === right) return true;
+  if (!left || !right) return left === right;
+  if (left.kind !== right.kind) return false;
+  if (left.kind === "main") return true;
+  if (left.kind === "header" && right.kind === "header") {
+    return (
+      left.relationshipId === right.relationshipId &&
+      left.variant === right.variant &&
+      (left.sectionIndex === undefined ||
+      right.sectionIndex === undefined
+        ? true
+        : left.sectionIndex === right.sectionIndex)
+    );
+  }
+  if (left.kind === "footer" && right.kind === "footer") {
+    return (
+      left.relationshipId === right.relationshipId &&
+      left.variant === right.variant &&
+      (left.sectionIndex === undefined ||
+      right.sectionIndex === undefined
+        ? true
+        : left.sectionIndex === right.sectionIndex)
+    );
+  }
+  if (left.kind === "footnote" && right.kind === "footnote") {
+    return left.noteId === right.noteId;
+  }
+  if (left.kind === "endnote" && right.kind === "endnote") {
+    return left.noteId === right.noteId;
+  }
+  return false;
+}
+
+export const MAIN_STORY_TARGET: EditorStoryTarget = { kind: "main" };
+
 function mapPositionThroughStep(
   position: Position,
   assoc: Assoc,

package/src/core/state/editor-state.ts

@@ -62,7 +62,7 @@ export interface EditorError {
     | "internal_invariant";
   message: string;
   isFatal: boolean;
-  source: "import" | "runtime" | "validation" | "datastore" | "export";
+  source: "import" | "runtime" | "validation" | "datastore" | "host" | "export";
   details?: Record<string, unknown>;
 }
 

package/src/index.ts

@@ -1,5 +1,13 @@
 export { WordReviewEditor } from "./ui/WordReviewEditor.tsx";
+export {
+  createEditorSessionState,
+  editorSessionStateFromPersistedSnapshot,
+  persistedSnapshotFromEditorSessionState,
+  EDITOR_SESSION_STATE_VERSION,
+} from "./api/session-state.ts";
 export type {
+  EditorSessionState,
+  EditorHostAdapter,
   WordReviewEditorProps,
   WordReviewEditorRef,
   EditorUser,
@@ -18,12 +26,32 @@ export type {
   RuntimeRenderSnapshot,
   SelectionSnapshot,
   EditorAnchorProjection,
+  EditorStoryTarget,
+  PageLayoutSnapshot,
+  WorkspaceMode,
+  ZoomLevel,
+  SectionBreakType,
+  SectionLayoutPatch,
+  SectionPageNumberingPatch,
+  HeaderFooterLinkPatch,
+  EditorViewStateSnapshot,
+  ViewMode,
+  CaretAffinity,
+  ActiveListContext,
+  ActiveNoteContext,
+  PageRegionHitTest,
+  LayoutMeasurement,
   DocumentStats,
   CommentSidebarSnapshot,
   CommentSidebarThreadSnapshot,
   CommentSidebarThreadEntrySnapshot,
   TrackedChangesSnapshot,
   TrackedChangeEntrySnapshot,
+  StyleCatalogSnapshot,
+  StyleCatalogEntrySnapshot,
+  DocumentNavigationSnapshot,
+  DocumentPageSnapshot,
+  DocumentHeadingSnapshot,
   AddCommentParams,
   ExportDocxOptions,
   ExportResult,
@@ -31,6 +59,8 @@ export type {
   AutosaveState,
   EditorTelemetryEvent,
   LoadResult,
+  SaveSessionParams,
+  SaveSessionResult,
   SaveSnapshotParams,
   SaveSnapshotResult,
   SaveExportParams,