@beyondwork/docx-react-component 1.0.28 → 1.0.30

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

@@ -3,6 +3,11 @@ import type {
   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>;
@@ -10,56 +15,83 @@ interface NumberingSequenceState {
 }
 
 export interface NumberingPrefixResult {
-  text: string;
+  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): NumberingPrefixResult | null;
+  resolveDetailed(
+    numbering: ParagraphNode["numbering"] | undefined,
+    paragraph?: ParagraphNode,
+  ): NumberingPrefixResult | null;
+  resolveParagraph(paragraph: ParagraphNode): NumberingPrefixResult | null;
 }
 
-const DEFAULT_START_AT = 1;
-
 export function createNumberingPrefixResolver(
   catalog: NumberingCatalog,
 ): NumberingPrefixResolver {
   const sequenceStates = new Map<string, NumberingSequenceState>();
 
-  function resolveInternal(numbering: ParagraphNode["numbering"] | undefined): NumberingPrefixResult | null {
-    if (!numbering) {
+  function resolveInternal(
+    numbering: ParagraphNode["numbering"] | undefined,
+    paragraph?: ParagraphNode,
+  ): NumberingPrefixResult | null {
+    const resolved = resolveNumberingDefinitionSet(
+      catalog,
+      paragraph?.numbering ?? numbering,
+      paragraph,
+    );
+    if (!resolved) {
       return null;
     }
 
-    const instance = catalog.instances[numbering.numberingInstanceId];
-    if (!instance) {
+    const resolvedNumbering = paragraph?.numbering ?? numbering;
+    if (!resolvedNumbering) {
       return null;
     }
 
-    const definition = catalog.abstractDefinitions[instance.abstractNumberingId];
-    if (!definition) {
-      return null;
-    }
+    const sequenceState = getSequenceState(sequenceStates, resolvedNumbering.numberingInstanceId);
+    advanceSequence(sequenceState, resolved.effectiveLevel.level, resolved.effectiveLevels);
 
-    const levelDefinitions = new Map(
-      definition.levels.map((level) => [level.level, level] as const),
+    // 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,
     );
-    const levelDefinition = levelDefinitions.get(numbering.level);
-    if (!levelDefinition || levelDefinition.format === "none") {
+    if (resolved.effectiveLevel.format !== "none" && text === null) {
       return null;
     }
-
-    const sequenceState = getSequenceState(sequenceStates, numbering.numberingInstanceId);
-    advanceSequence(sequenceState, numbering.level, levelDefinitions, instance.overrides);
-
-    // When isLegalNumbering is true, use decimal format for all referenced levels
-    const effectiveLevelDefs = levelDefinition.isLegalNumbering
-      ? new Map(Array.from(levelDefinitions.entries()).map(([k, v]) => [k, { ...v, format: "decimal" }]))
-      : levelDefinitions;
-
-    const text = renderLevelText(levelDefinition.text, sequenceState.counters, effectiveLevelDefs);
-    if (text === null) return null;
-    return { text, suffix: levelDefinition.suffix };
+    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 {
@@ -67,8 +99,11 @@ export function createNumberingPrefixResolver(
       const result = resolveInternal(numbering);
       return result?.text ?? null;
     },
-    resolveDetailed(numbering) {
-      return resolveInternal(numbering);
+    resolveDetailed(numbering, paragraph) {
+      return resolveInternal(numbering, paragraph);
+    },
+    resolveParagraph(paragraph) {
+      return resolveInternal(paragraph.numbering, paragraph);
     },
   };
 }
@@ -94,13 +129,12 @@ function advanceSequence(
   state: NumberingSequenceState,
   currentLevel: number,
   levelDefinitions: Map<number, NumberingLevelDefinition>,
-  overrides: NumberingCatalog["instances"][string]["overrides"],
 ): void {
   if (state.lastLevel !== null && currentLevel <= state.lastLevel) {
     state.counters.length = currentLevel + 1;
   }
 
-  const startAt = getLevelStartAt(currentLevel, levelDefinitions, overrides);
+  const startAt = getLevelStartAt(currentLevel, levelDefinitions);
   const currentValue = state.counters[currentLevel];
   state.counters[currentLevel] =
     currentValue === undefined ? startAt : currentValue + 1;
@@ -110,14 +144,8 @@ function advanceSequence(
 function getLevelStartAt(
   level: number,
   levelDefinitions: Map<number, NumberingLevelDefinition>,
-  overrides: NumberingCatalog["instances"][string]["overrides"],
 ): number {
-  const override = overrides.find((entry) => entry.level === level);
-  if (override?.startAt !== undefined) {
-    return override.startAt;
-  }
-
-  return levelDefinitions.get(level)?.startAt ?? DEFAULT_START_AT;
+  return levelDefinitions.get(level)?.startAt ?? DEFAULT_NUMBERING_START_AT;
 }
 
 function renderLevelText(

package/src/runtime/page-layout-estimation.ts

@@ -38,10 +38,11 @@ export function estimateParagraphHeight(
   block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
   columnWidth: number,
 ): number {
+  const spacing = resolveParagraphSpacing(block);
   const lineHeight = estimateParagraphLineHeight(block);
   const lineCount = estimateParagraphLineCount(block, columnWidth);
-  const spacingBefore = block.spacing?.before ?? 0;
-  const spacingAfter = block.spacing?.after ?? 0;
+  const spacingBefore = spacing?.before ?? 0;
+  const spacingAfter = spacing?.after ?? 0;
   return Math.max(
     MIN_BLOCK_HEIGHT_TWIPS,
     lineHeight * lineCount + spacingBefore + spacingAfter,
@@ -51,7 +52,7 @@ export function estimateParagraphHeight(
 export function estimateParagraphLineHeight(
   block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
 ): number {
-  const explicitLine = block.spacing?.line;
+  const explicitLine = resolveParagraphSpacing(block)?.line;
   if (typeof explicitLine === "number" && explicitLine > 0) {
     return explicitLine;
   }
@@ -75,36 +76,55 @@ export function estimateParagraphLineCount(
   columnWidth: number,
 ): number {
   const averageCharWidth = estimateAverageCharWidth(block);
-  const charsPerLine = Math.max(12, Math.floor(columnWidth / averageCharWidth));
+  const lineMetrics = resolveParagraphLineMetrics(block, columnWidth, averageCharWidth);
   let lineCount = 1;
-  let currentLineChars = estimatedPrefixLength(block);
+  let currentLineChars = lineMetrics.initialLineChars;
+  let currentLineCapacity = lineMetrics.firstLineCapacity;
 
   for (const segment of block.segments) {
     switch (segment.kind) {
       case "text":
         currentLineChars += Array.from(segment.text).length;
-        while (currentLineChars > charsPerLine) {
+        while (currentLineChars > currentLineCapacity) {
           lineCount += 1;
-          currentLineChars -= charsPerLine;
+          currentLineChars -= currentLineCapacity;
+          currentLineCapacity = lineMetrics.subsequentLineCapacity;
         }
         break;
       case "tab":
         currentLineChars += 4;
+        while (currentLineChars > currentLineCapacity) {
+          lineCount += 1;
+          currentLineChars -= currentLineCapacity;
+          currentLineCapacity = lineMetrics.subsequentLineCapacity;
+        }
         break;
       case "hard_break":
         lineCount += 1;
         currentLineChars = 0;
+        currentLineCapacity = lineMetrics.subsequentLineCapacity;
         break;
       case "image":
         lineCount += Math.max(1, Math.round(segment.display === "floating" ? 2 : 1));
         currentLineChars = 0;
+        currentLineCapacity = lineMetrics.subsequentLineCapacity;
         break;
       case "note_ref":
         currentLineChars += 1;
+        while (currentLineChars > currentLineCapacity) {
+          lineCount += 1;
+          currentLineChars -= currentLineCapacity;
+          currentLineCapacity = lineMetrics.subsequentLineCapacity;
+        }
         break;
       case "opaque_inline":
         if (segment.presentation !== "quiet-marker") {
           currentLineChars += segment.label.length > 0 ? 1 : 0;
+          while (currentLineChars > currentLineCapacity) {
+            lineCount += 1;
+            currentLineChars -= currentLineCapacity;
+            currentLineCapacity = lineMetrics.subsequentLineCapacity;
+          }
         }
         break;
     }
@@ -198,6 +218,79 @@ function estimateAverageCharWidth(
   return Math.max(96, Math.round(fontSizePoints * 12));
 }
 
+function resolveParagraphSpacing(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+): Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>["spacing"] | undefined {
+  return block.resolvedNumbering?.geometry.spacing ?? block.spacing;
+}
+
+function resolveParagraphLineMetrics(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+  columnWidth: number,
+  averageCharWidth: number,
+): {
+  initialLineChars: number;
+  firstLineCapacity: number;
+  subsequentLineCapacity: number;
+} {
+  const textColumn =
+    block.resolvedNumbering?.geometry.textColumn ??
+    deriveParagraphTextColumn(block.indentation);
+  const hasResolvedTextColumn = Boolean(textColumn);
+  const baseLineWidth = resolveTextColumnWidth(columnWidth, textColumn);
+  const firstLineWidth =
+    textColumn?.firstLine && textColumn.firstLine > 0
+      ? Math.max(averageCharWidth, baseLineWidth - textColumn.firstLine)
+      : baseLineWidth;
+
+  return {
+    initialLineChars: hasResolvedTextColumn ? 0 : estimatedPrefixLength(block),
+    firstLineCapacity: resolveCharsPerLine(firstLineWidth, averageCharWidth),
+    subsequentLineCapacity: resolveCharsPerLine(baseLineWidth, averageCharWidth),
+  };
+}
+
+function deriveParagraphTextColumn(
+  indentation: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>["indentation"],
+): { start: number; right?: number; firstLine?: number; hanging?: number } | undefined {
+  if (!indentation) {
+    return undefined;
+  }
+  const hanging =
+    indentation.hanging ??
+    (typeof indentation.firstLine === "number" && indentation.firstLine < 0
+      ? Math.abs(indentation.firstLine)
+      : undefined);
+  const hasGeometry =
+    indentation.left !== undefined ||
+    indentation.right !== undefined ||
+    indentation.firstLine !== undefined ||
+    hanging !== undefined;
+  if (!hasGeometry) {
+    return undefined;
+  }
+  return {
+    start: indentation.left ?? 0,
+    ...(indentation.right !== undefined ? { right: indentation.right } : {}),
+    ...(indentation.firstLine !== undefined ? { firstLine: indentation.firstLine } : {}),
+    ...(hanging !== undefined ? { hanging } : {}),
+  };
+}
+
+function resolveTextColumnWidth(
+  columnWidth: number,
+  textColumn: { start: number; right?: number; firstLine?: number; hanging?: number } | undefined,
+): number {
+  if (!textColumn) {
+    return columnWidth;
+  }
+  return Math.max(1, columnWidth - textColumn.start - (textColumn.right ?? 0));
+}
+
+function resolveCharsPerLine(width: number, averageCharWidth: number): number {
+  return Math.max(1, Math.floor(width / averageCharWidth));
+}
+
 function estimatedPrefixLength(
   block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
 ): number {