@beyondwork/docx-react-component 1.0.36 → 1.0.38

package/src/runtime/layout/project-block-fragments.ts

@@ -0,0 +1,91 @@
+/**
+ * Project surface blocks → per-page RuntimeBlockFragments (P4).
+ *
+ * The pagination engine produces `DocumentPageSnapshot[]` keyed by offset
+ * ranges, but for render-kernel consumers to get per-block geometry (and
+ * for the chrome to anchor tables, images, etc.) we need one block
+ * fragment per top-level surface block, assigned to the page that contains
+ * its offset range.
+ *
+ * Today the engine does not split tables across pages, so this emission
+ * pass treats each top-level SurfaceBlockSnapshot as an atomic fragment
+ * with `pageIndex` resolved from `pages[i].startOffset..endOffset`. Row-
+ * level splitting (for header-row repeat + per-row cantSplit) will refine
+ * this to multiple fragments per block.
+ */
+
+import type {
+  DocumentPageSnapshot,
+  EditorSurfaceSnapshot,
+  SurfaceBlockSnapshot,
+} from "../../api/public-types";
+import type { RuntimeBlockFragment } from "./page-graph.ts";
+
+type FragmentWithoutPageId = Omit<RuntimeBlockFragment, "pageId">;
+
+export function projectSurfaceBlocksToPageFragments(
+  surface: EditorSurfaceSnapshot,
+  pages: readonly DocumentPageSnapshot[],
+): Map<number, FragmentWithoutPageId[]> {
+  const byPage = new Map<number, FragmentWithoutPageId[]>();
+  const perPageCounter = new Map<number, number>();
+
+  for (const block of surface.blocks) {
+    const pageIndex = findPageIndexForOffset(pages, block.from);
+    if (pageIndex === null) continue;
+    const orderInRegion = perPageCounter.get(pageIndex) ?? 0;
+    perPageCounter.set(pageIndex, orderInRegion + 1);
+
+    const fragment: FragmentWithoutPageId = {
+      fragmentId: `fragment-${block.blockId}`,
+      blockId: block.blockId,
+      orderInRegion,
+      regionKind: "body",
+      from: block.from,
+      to: block.to,
+      // Height is not recomputed here — the pagination engine already
+      // measured the block to assign it to this page. Chrome surfaces
+      // that need precise heights can consult layout facet measurements.
+      heightTwips: estimateBlockHeightFromSpan(block),
+    };
+
+    const existing = byPage.get(pageIndex);
+    if (existing) {
+      existing.push(fragment);
+    } else {
+      byPage.set(pageIndex, [fragment]);
+    }
+  }
+
+  return byPage;
+}
+
+function findPageIndexForOffset(
+  pages: readonly DocumentPageSnapshot[],
+  offset: number,
+): number | null {
+  for (let i = 0; i < pages.length; i += 1) {
+    const page = pages[i]!;
+    if (offset >= page.startOffset && offset < page.endOffset) {
+      return page.pageIndex;
+    }
+  }
+  // Fall back to the last page for offsets that equal storySize.
+  const last = pages[pages.length - 1];
+  if (last && offset >= last.startOffset && offset <= last.endOffset) {
+    return last.pageIndex;
+  }
+  return null;
+}
+
+/**
+ * Rough height estimate from the block's offset span. Only used as a
+ * fallback when the caller did not pre-measure. Chrome consumers that
+ * need accurate heights should read `facet.getMeasurement(blockId)`.
+ */
+function estimateBlockHeightFromSpan(block: SurfaceBlockSnapshot): number {
+  // 240 twips per line; approximate 80 chars per line for paragraphs.
+  const span = Math.max(0, block.to - block.from);
+  const lines = Math.max(1, Math.ceil(span / 80));
+  return lines * 240;
+}