@beyondwork/docx-react-component 1.0.29 → 1.0.30

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;
+}

package/src/runtime/event-refresh-hints.ts

@@ -0,0 +1,137 @@
+import type { SnapshotRefreshHints, WordReviewEditorEvent } from "../api/public-types";
+
+export function describeEventImpact(
+  event: WordReviewEditorEvent,
+): SnapshotRefreshHints {
+  switch (event.type) {
+    case "selection_changed":
+      return {
+        invalidate: ["selection", "locations", "contextAnalytics"],
+        staleTargets: ["selection_only"],
+        changeKinds: ["selection"],
+      };
+    case "story_changed":
+      return {
+        invalidate: ["selection", "render", "locations", "outline", "sections", "contextAnalytics"],
+        staleTargets: ["anchors"],
+        changeKinds: ["selection", "structure"],
+      };
+    case "workflow_overlay_changed":
+    case "workflow_active_work_item_changed":
+      return {
+        invalidate: [
+          "workflowScope",
+          "workflowMarkup",
+          "locations",
+          "reviewWork",
+          "chunks",
+          "contextAnalytics",
+        ],
+        staleTargets: ["anchors"],
+        changeKinds: ["workflow"],
+      };
+    case "workflow_metadata_changed":
+      return {
+        invalidate: ["workflowMarkup", "render", "locations", "reviewWork", "chunks"],
+        staleTargets: ["anchors"],
+        changeKinds: ["workflow"],
+      };
+    case "change_authored":
+    case "change_accepted":
+    case "change_rejected":
+    case "suggestion_authored":
+    case "suggestion_updated":
+    case "comment_added":
+    case "comment_resolved":
+      return {
+        invalidate: [
+          "render",
+          "comments",
+          "trackedChanges",
+          "navigation",
+          "outline",
+          "toc",
+          "sections",
+          "locations",
+          "reviewWork",
+          "chunks",
+          "textStream",
+          "contextAnalytics",
+        ],
+        staleTargets: ["search_results", "anchors"],
+        changeKinds: ["content", "review", "structure"],
+      };
+    case "warning_added":
+    case "warning_cleared":
+    case "error":
+      return {
+        invalidate: ["render", "contextAnalytics"],
+        staleTargets: ["none"],
+        changeKinds: ["content"],
+      };
+    case "snapshot_saved":
+      return {
+        invalidate: [],
+        staleTargets: ["none"],
+        changeKinds: ["checkpoint"],
+        checkpointType: "snapshot",
+      };
+    case "session_saved":
+      return {
+        invalidate: [],
+        staleTargets: ["none"],
+        changeKinds: ["checkpoint"],
+        checkpointType: "session",
+      };
+    case "export_completed":
+      return {
+        invalidate: [],
+        staleTargets: ["none"],
+        changeKinds: ["checkpoint"],
+        checkpointType: "export",
+      };
+    case "command_blocked":
+      return {
+        invalidate: ["workflowScope", "locations", "contextAnalytics"],
+        staleTargets: ["anchors"],
+        changeKinds: ["workflow"],
+      };
+    case "ready":
+      return {
+        invalidate: [
+          "render",
+          "navigation",
+          "outline",
+          "toc",
+          "sections",
+          "locations",
+          "reviewWork",
+          "chunks",
+          "textStream",
+          "contextAnalytics",
+        ],
+        staleTargets: ["none"],
+        changeKinds: ["structure"],
+      };
+    case "context_analytics_changed":
+      return {
+        invalidate: ["contextAnalytics"],
+        staleTargets: ["none"],
+        changeKinds: ["selection", "content", "review", "workflow"],
+      };
+    case "dirty_changed":
+    case "autosave_state":
+    case "host_annotation_overlay_changed":
+      return {
+        invalidate: ["render"],
+        staleTargets: ["none"],
+        changeKinds: ["checkpoint"],
+      };
+  }
+
+  return {
+    invalidate: ["render"],
+    staleTargets: ["none"],
+    changeKinds: ["content"],
+  };
+}

package/src/runtime/numbering-prefix.ts

@@ -0,0 +1,244 @@
+import type {
+  NumberingCatalog,
+  NumberingLevelDefinition,
+  ParagraphNode,
+} from "../model/canonical-document.ts";
+import {
+  DEFAULT_NUMBERING_START_AT,
+  resolveNumberingDefinitionSet,
+  type ResolvedNumberingGeometry,
+} from "./resolved-numbering-geometry.ts";
+
+interface NumberingSequenceState {
+  counters: Array<number | undefined>;
+  lastLevel: number | null;
+}
+
+export interface NumberingPrefixResult {
+  text: string | null;
+  level: number;
+  format: string;
+  startAt: number;
+  suffix?: "tab" | "space" | "nothing";
+  paragraphStyleId?: string;
+  isLegalNumbering?: boolean;
+  geometry: ResolvedNumberingGeometry;
+}
+
+export interface NumberingPrefixResolver {
+  resolve(numbering: ParagraphNode["numbering"] | undefined): string | null;
+  resolveDetailed(
+    numbering: ParagraphNode["numbering"] | undefined,
+    paragraph?: ParagraphNode,
+  ): NumberingPrefixResult | null;
+  resolveParagraph(paragraph: ParagraphNode): NumberingPrefixResult | null;
+}
+
+export function createNumberingPrefixResolver(
+  catalog: NumberingCatalog,
+): NumberingPrefixResolver {
+  const sequenceStates = new Map<string, NumberingSequenceState>();
+
+  function resolveInternal(
+    numbering: ParagraphNode["numbering"] | undefined,
+    paragraph?: ParagraphNode,
+  ): NumberingPrefixResult | null {
+    const resolved = resolveNumberingDefinitionSet(
+      catalog,
+      paragraph?.numbering ?? numbering,
+      paragraph,
+    );
+    if (!resolved) {
+      return null;
+    }
+
+    const resolvedNumbering = paragraph?.numbering ?? numbering;
+    if (!resolvedNumbering) {
+      return null;
+    }
+
+    const sequenceState = getSequenceState(sequenceStates, resolvedNumbering.numberingInstanceId);
+    advanceSequence(sequenceState, resolved.effectiveLevel.level, resolved.effectiveLevels);
+
+    // When isLegalNumbering is true, use decimal format for all referenced levels
+    const effectiveLevelDefs = resolved.effectiveLevel.isLegalNumbering
+      ? new Map(
+          Array.from(resolved.effectiveLevels.entries()).map(([level, definition]) => [
+            level,
+            { ...definition, format: "decimal" },
+          ]),
+        )
+      : resolved.effectiveLevels;
+
+    const text = renderLevelText(
+      resolved.effectiveLevel.text,
+      sequenceState.counters,
+      effectiveLevelDefs,
+    );
+    if (resolved.effectiveLevel.format !== "none" && text === null) {
+      return null;
+    }
+    const visibleText = resolved.effectiveLevel.format === "none" ? null : text;
+
+    return {
+      text: visibleText,
+      level: resolved.effectiveLevel.level,
+      format: resolved.effectiveLevel.format,
+      startAt: resolved.effectiveLevel.startAt ?? DEFAULT_NUMBERING_START_AT,
+      ...(resolved.effectiveLevel.suffix ? { suffix: resolved.effectiveLevel.suffix } : {}),
+      ...(resolved.effectiveLevel.paragraphStyleId
+        ? { paragraphStyleId: resolved.effectiveLevel.paragraphStyleId }
+        : {}),
+      ...(resolved.effectiveLevel.isLegalNumbering ? { isLegalNumbering: true } : {}),
+      geometry: resolved.geometry,
+    };
+  }
+
+  return {
+    resolve(numbering) {
+      const result = resolveInternal(numbering);
+      return result?.text ?? null;
+    },
+    resolveDetailed(numbering, paragraph) {
+      return resolveInternal(numbering, paragraph);
+    },
+    resolveParagraph(paragraph) {
+      return resolveInternal(paragraph.numbering, paragraph);
+    },
+  };
+}
+
+function getSequenceState(
+  states: Map<string, NumberingSequenceState>,
+  numberingInstanceId: string,
+): NumberingSequenceState {
+  const existing = states.get(numberingInstanceId);
+  if (existing) {
+    return existing;
+  }
+
+  const created: NumberingSequenceState = {
+    counters: [],
+    lastLevel: null,
+  };
+  states.set(numberingInstanceId, created);
+  return created;
+}
+
+function advanceSequence(
+  state: NumberingSequenceState,
+  currentLevel: number,
+  levelDefinitions: Map<number, NumberingLevelDefinition>,
+): void {
+  if (state.lastLevel !== null && currentLevel <= state.lastLevel) {
+    state.counters.length = currentLevel + 1;
+  }
+
+  const startAt = getLevelStartAt(currentLevel, levelDefinitions);
+  const currentValue = state.counters[currentLevel];
+  state.counters[currentLevel] =
+    currentValue === undefined ? startAt : currentValue + 1;
+  state.lastLevel = currentLevel;
+}
+
+function getLevelStartAt(
+  level: number,
+  levelDefinitions: Map<number, NumberingLevelDefinition>,
+): number {
+  return levelDefinitions.get(level)?.startAt ?? DEFAULT_NUMBERING_START_AT;
+}
+
+function renderLevelText(
+  text: string,
+  counters: Array<number | undefined>,
+  levelDefinitions: Map<number, NumberingLevelDefinition>,
+): string | null {
+  if (!text) {
+    return null;
+  }
+
+  if (!text.includes("%")) {
+    return text;
+  }
+
+  const rendered = text.replace(/%([1-9])/g, (_match, token) => {
+    const level = Number.parseInt(token, 10) - 1;
+    const counter = counters[level];
+    if (counter === undefined) {
+      return "";
+    }
+
+    const format = levelDefinitions.get(level)?.format ?? "decimal";
+    return formatCounter(counter, format);
+  });
+
+  return rendered.trim().length > 0 ? rendered : null;
+}
+
+function formatCounter(value: number, format: string): string {
+  switch (format) {
+    case "decimal":
+      return String(value);
+    case "decimalZero":
+      return String(value).padStart(2, "0");
+    case "upperLetter":
+      return toAlphabetic(value).toUpperCase();
+    case "lowerLetter":
+      return toAlphabetic(value).toLowerCase();
+    case "upperRoman":
+      return toRoman(value).toUpperCase();
+    case "lowerRoman":
+      return toRoman(value).toLowerCase();
+    case "none":
+      return "";
+    default:
+      return String(value);
+  }
+}
+
+function toAlphabetic(value: number): string {
+  if (value <= 0) {
+    return String(value);
+  }
+
+  let remainder = value;
+  let result = "";
+  while (remainder > 0) {
+    remainder -= 1;
+    result = String.fromCharCode(65 + (remainder % 26)) + result;
+    remainder = Math.floor(remainder / 26);
+  }
+  return result;
+}
+
+function toRoman(value: number): string {
+  if (value <= 0 || value >= 4000) {
+    return String(value);
+  }
+
+  const numerals: Array<[number, string]> = [
+    [1000, "M"],
+    [900, "CM"],
+    [500, "D"],
+    [400, "CD"],
+    [100, "C"],
+    [90, "XC"],
+    [50, "L"],
+    [40, "XL"],
+    [10, "X"],
+    [9, "IX"],
+    [5, "V"],
+    [4, "IV"],
+    [1, "I"],
+  ];
+
+  let remaining = value;
+  let result = "";
+  for (const [amount, numeral] of numerals) {
+    while (remaining >= amount) {
+      remaining -= amount;
+      result += numeral;
+    }
+  }
+  return result;
+}