@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/layout-bridge/engine/hitTest.d.ts

@@ -0,0 +1,135 @@
+import { FlowBlock, Fragment, Layout, Measure, Page, ParagraphBlock, ParagraphMeasure, TableBlock, TableFragment, TableMeasure } from "../../layout-engine/types.js";
+
+//#region src/layout-bridge/engine/hitTest.d.ts
+/**
+ * A 2D point in page coordinate space.
+ */
+type Point = {
+  x: number;
+  y: number;
+};
+/**
+ * Result of hit-testing to find which page contains a point.
+ */
+type PageHit = {
+  /** Index of the page (0-based). */pageIndex: number; /** The page that was hit. */
+  page: Page; /** Y position relative to the page top. */
+  pageY: number;
+};
+/**
+ * Result of hit-testing to find which fragment contains a point.
+ */
+type FragmentHit = {
+  /** The fragment that was hit. */fragment: Fragment; /** The corresponding flow block. */
+  block: FlowBlock; /** The corresponding measurement. */
+  measure: Measure; /** Page index (0-based). */
+  pageIndex: number; /** Y position relative to the fragment top. */
+  localY: number; /** X position relative to the fragment left. */
+  localX: number;
+};
+/**
+ * Result of hit-testing a table to find the cell.
+ */
+type TableCellHit = {
+  /** The table fragment. */fragment: TableFragment; /** The table block. */
+  block: TableBlock; /** The table measure. */
+  measure: TableMeasure; /** Page index (0-based). */
+  pageIndex: number; /** Row index (0-based). */
+  rowIndex: number; /** Column index (0-based). */
+  colIndex: number; /** Paragraph block within the cell (first one). */
+  cellBlock?: ParagraphBlock; /** Paragraph measure within the cell. */
+  cellMeasure?: ParagraphMeasure; /** X position relative to cell content area. */
+  cellLocalX: number; /** Y position relative to cell content area. */
+  cellLocalY: number;
+};
+/**
+ * Hit-test pages to find which page contains a given Y coordinate.
+ *
+ * Pages are stacked vertically with optional gaps between them.
+ * If the point is in a gap, returns the nearest page.
+ *
+ * @param layout - The layout containing pages.
+ * @param point - The point to test (only Y is used for page lookup).
+ * @returns PageHit if a page was found, null otherwise.
+ */
+declare function hitTestPage(layout: Layout, point: Point): PageHit | null;
+/**
+ * Calculate the Y offset of a page from the top of the document.
+ */
+declare function getPageTop(layout: Layout, pageIndex: number): number;
+/**
+ * Get the page index at a specific Y coordinate.
+ * Returns null if the coordinate is outside all pages.
+ */
+declare function getPageIndexAtY(layout: Layout, y: number): number | null;
+/**
+ * Hit-test fragments on a page to find which fragment contains a point.
+ *
+ * Fragments are checked in visual order (sorted by Y then X).
+ * Only considers paragraph and table fragments (not images for now).
+ *
+ * @param pageHit - The page hit result from hitTestPage.
+ * @param blocks - All flow blocks in the document.
+ * @param measures - All measurements corresponding to blocks.
+ * @param pagePoint - Point in page-relative coordinates.
+ * @returns FragmentHit if a fragment was found, null otherwise.
+ */
+declare function hitTestFragment(pageHit: PageHit, blocks: FlowBlock[], measures: Measure[], pagePoint: Point): FragmentHit | null;
+/**
+ * Hit-test to find image fragments (they may overlap other content).
+ */
+declare function hitTestImageFragment(pageHit: PageHit, blocks: FlowBlock[], measures: Measure[], pagePoint: Point): FragmentHit | null;
+/**
+ * Hit-test within a table fragment to find the specific cell.
+ *
+ * @param pageHit - The page hit result.
+ * @param blocks - All flow blocks.
+ * @param measures - All measurements.
+ * @param pagePoint - Point in page-relative coordinates.
+ * @returns TableCellHit if a table cell was found, null otherwise.
+ */
+declare function hitTestTableCell(pageHit: PageHit, blocks: FlowBlock[], measures: Measure[], pagePoint: Point): TableCellHit | null;
+/**
+ * Combined result of all hit testing.
+ */
+type HitTestResult = {
+  /** Page that was hit. */pageHit: PageHit | null; /** Fragment that was hit (if any). */
+  fragmentHit: FragmentHit | null; /** Table cell that was hit (if fragment is a table). */
+  tableCellHit: TableCellHit | null;
+};
+/**
+ * Perform complete hit testing from document coordinates to the most specific element.
+ *
+ * @param layout - The layout containing pages.
+ * @param blocks - All flow blocks.
+ * @param measures - All measurements.
+ * @param point - Point in document coordinates (Y is cumulative from document top).
+ * @returns Complete hit test result.
+ */
+declare function hitTest(layout: Layout, blocks: FlowBlock[], measures: Measure[], point: Point): HitTestResult;
+/**
+ * Get the total document height (all pages + gaps).
+ */
+declare function getTotalDocumentHeight(layout: Layout): number;
+/**
+ * Get Y coordinate to scroll to for a specific page.
+ */
+declare function getScrollYForPage(layout: Layout, pageIndex: number): number;
+/**
+ * Get page bounds (top and bottom Y coordinates).
+ */
+declare function getPageBounds(layout: Layout, pageIndex: number): {
+  top: number;
+  bottom: number;
+} | null;
+/**
+ * Check if a point is within the content area of a page (inside margins).
+ */
+declare function isPointInContentArea(_layout: Layout, pageHit: PageHit, pagePoint: Point): boolean;
+/**
+ * Find the nearest fragment to a point on a page.
+ * Useful when the click is in whitespace.
+ */
+declare function findNearestFragment(pageHit: PageHit, blocks: FlowBlock[], measures: Measure[], pagePoint: Point): FragmentHit | null;
+//#endregion
+export { FragmentHit, HitTestResult, PageHit, Point, TableCellHit, findNearestFragment, getPageBounds, getPageIndexAtY, getPageTop, getScrollYForPage, getTotalDocumentHeight, hitTest, hitTestFragment, hitTestImageFragment, hitTestPage, hitTestTableCell, isPointInContentArea };

package/dist/layout-bridge/engine/hitTest.js

@@ -0,0 +1,375 @@
+import { measuredLineRangeHeight } from "../../layout-engine/lineFlow.js";
+import { getHeaderRowsHeight } from "../../layout-engine/index.js";
+//#region src/layout-bridge/engine/hitTest.ts
+/**
+* Hit Testing Utilities
+*
+* Maps click coordinates to pages, fragments, and document positions.
+* Used by the paged editor to translate user clicks into PM positions.
+*/
+/**
+* Hit-test pages to find which page contains a given Y coordinate.
+*
+* Pages are stacked vertically with optional gaps between them.
+* If the point is in a gap, returns the nearest page.
+*
+* @param layout - The layout containing pages.
+* @param point - The point to test (only Y is used for page lookup).
+* @returns PageHit if a page was found, null otherwise.
+*/
+function hitTestPage(layout, point) {
+	if (layout.pages.length === 0) return null;
+	const pageGap = layout.pageGap ?? 0;
+	let cursorY = 0;
+	let nearestPageIndex = null;
+	let nearestDistance = Infinity;
+	for (let pageIndex = 0; pageIndex < layout.pages.length; pageIndex++) {
+		const page = layout.pages[pageIndex];
+		const pageHeight = page.size.h;
+		const pageTop = cursorY;
+		const pageBottom = pageTop + pageHeight;
+		if (point.y >= pageTop && point.y < pageBottom) return {
+			pageIndex,
+			page,
+			pageY: point.y - pageTop
+		};
+		const pageCenter = pageTop + pageHeight / 2;
+		const distance = Math.abs(point.y - pageCenter);
+		if (distance < nearestDistance) {
+			nearestDistance = distance;
+			nearestPageIndex = pageIndex;
+		}
+		cursorY = pageBottom + pageGap;
+	}
+	if (nearestPageIndex !== null) {
+		const page = layout.pages[nearestPageIndex];
+		const pageTop = getPageTop(layout, nearestPageIndex);
+		return {
+			pageIndex: nearestPageIndex,
+			page,
+			pageY: Math.max(0, Math.min(point.y - pageTop, page.size.h))
+		};
+	}
+	return null;
+}
+/**
+* Calculate the Y offset of a page from the top of the document.
+*/
+function getPageTop(layout, pageIndex) {
+	const pageGap = layout.pageGap ?? 0;
+	let y = 0;
+	for (let i = 0; i < pageIndex && i < layout.pages.length; i++) {
+		const pageHeight = layout.pages[i].size.h;
+		y += pageHeight + pageGap;
+	}
+	return y;
+}
+/**
+* Get the page index at a specific Y coordinate.
+* Returns null if the coordinate is outside all pages.
+*/
+function getPageIndexAtY(layout, y) {
+	return hitTestPage(layout, {
+		x: 0,
+		y
+	})?.pageIndex ?? null;
+}
+/**
+* Find a block by its ID in the blocks array.
+*/
+function findBlockIndexById(blocks, blockId) {
+	return blocks.findIndex((block) => block.id === blockId);
+}
+/**
+* Calculate the actual height of a paragraph fragment from its lines.
+*/
+function calculateParagraphFragmentHeight(fragment, measure) {
+	return measuredLineRangeHeight(measure.lines, fragment.fromLine, fragment.toLine);
+}
+/**
+* Hit-test fragments on a page to find which fragment contains a point.
+*
+* Fragments are checked in visual order (sorted by Y then X).
+* Only considers paragraph and table fragments (not images for now).
+*
+* @param pageHit - The page hit result from hitTestPage.
+* @param blocks - All flow blocks in the document.
+* @param measures - All measurements corresponding to blocks.
+* @param pagePoint - Point in page-relative coordinates.
+* @returns FragmentHit if a fragment was found, null otherwise.
+*/
+function hitTestFragment(pageHit, blocks, measures, pagePoint) {
+	const sortedFragments = [...pageHit.page.fragments].toSorted((a, b) => {
+		const dy = a.y - b.y;
+		if (Math.abs(dy) > .5) return dy;
+		return a.x - b.x;
+	});
+	for (const fragment of sortedFragments) {
+		const blockIndex = findBlockIndexById(blocks, fragment.blockId);
+		if (blockIndex === -1) continue;
+		const block = blocks[blockIndex];
+		const measure = measures[blockIndex];
+		if (!block || !measure) continue;
+		let fragmentHeight;
+		if (fragment.kind === "paragraph") {
+			if (block.kind !== "paragraph" || measure.kind !== "paragraph") continue;
+			fragmentHeight = calculateParagraphFragmentHeight(fragment, measure);
+		} else if (fragment.kind === "table") fragmentHeight = fragment.height;
+		else if (fragment.kind === "image") fragmentHeight = fragment.height;
+		else continue;
+		const withinX = pagePoint.x >= fragment.x && pagePoint.x <= fragment.x + fragment.width;
+		const withinY = pagePoint.y >= fragment.y && pagePoint.y <= fragment.y + fragmentHeight;
+		if (withinX && withinY) return {
+			fragment,
+			block,
+			measure,
+			pageIndex: pageHit.pageIndex,
+			localX: pagePoint.x - fragment.x,
+			localY: pagePoint.y - fragment.y
+		};
+	}
+	return null;
+}
+/**
+* Hit-test to find image fragments (they may overlap other content).
+*/
+function hitTestImageFragment(pageHit, blocks, measures, pagePoint) {
+	for (const fragment of pageHit.page.fragments) {
+		if (fragment.kind !== "image") continue;
+		const blockIndex = findBlockIndexById(blocks, fragment.blockId);
+		if (blockIndex === -1) continue;
+		const block = blocks[blockIndex];
+		const measure = measures[blockIndex];
+		if (!block || !measure) continue;
+		const withinX = pagePoint.x >= fragment.x && pagePoint.x <= fragment.x + fragment.width;
+		const withinY = pagePoint.y >= fragment.y && pagePoint.y <= fragment.y + fragment.height;
+		if (withinX && withinY) return {
+			fragment,
+			block,
+			measure,
+			pageIndex: pageHit.pageIndex,
+			localX: pagePoint.x - fragment.x,
+			localY: pagePoint.y - fragment.y
+		};
+	}
+	return null;
+}
+/**
+* Hit-test within a table fragment to find the specific cell.
+*
+* @param pageHit - The page hit result.
+* @param blocks - All flow blocks.
+* @param measures - All measurements.
+* @param pagePoint - Point in page-relative coordinates.
+* @returns TableCellHit if a table cell was found, null otherwise.
+*/
+function hitTestTableCell(pageHit, blocks, measures, pagePoint) {
+	for (const fragment of pageHit.page.fragments) {
+		if (fragment.kind !== "table") continue;
+		const tableFragment = fragment;
+		const withinX = pagePoint.x >= tableFragment.x && pagePoint.x <= tableFragment.x + tableFragment.width;
+		const withinY = pagePoint.y >= tableFragment.y && pagePoint.y <= tableFragment.y + tableFragment.height;
+		if (!withinX || !withinY) continue;
+		const blockIndex = findBlockIndexById(blocks, tableFragment.blockId);
+		if (blockIndex === -1) continue;
+		const block = blocks[blockIndex];
+		const measure = measures[blockIndex];
+		if (!block || block.kind !== "table" || !measure || measure.kind !== "table") continue;
+		const tableBlock = block;
+		const tableMeasure = measure;
+		const localX = pagePoint.x - tableFragment.x;
+		const localY = pagePoint.y - tableFragment.y;
+		const headerRowCount = tableFragment.headerRowCount ?? 0;
+		const headerHeight = headerRowCount > 0 && tableFragment.continuesFromPrev ? getHeaderRowsHeight(tableMeasure, headerRowCount) : 0;
+		let rowY = 0;
+		let rowIndex = -1;
+		if (tableMeasure.rows.length === 0 || tableBlock.rows.length === 0) continue;
+		if (headerHeight > 0 && localY < headerHeight) {
+			let hdrY = 0;
+			for (let h = 0; h < headerRowCount && h < tableMeasure.rows.length; h++) {
+				const hdrRowMeasure = tableMeasure.rows[h];
+				if (localY >= hdrY && localY < hdrY + hdrRowMeasure.height) {
+					rowIndex = h;
+					break;
+				}
+				hdrY += hdrRowMeasure.height;
+			}
+			if (rowIndex === -1) rowIndex = 0;
+		} else {
+			const adjustedLocalY = localY - headerHeight + (tableFragment.topClip ?? 0);
+			for (let r = tableFragment.fromRow; r < tableFragment.toRow && r < tableMeasure.rows.length; r++) {
+				const rowMeasure = tableMeasure.rows[r];
+				if (adjustedLocalY >= rowY && adjustedLocalY < rowY + rowMeasure.height) {
+					rowIndex = r;
+					break;
+				}
+				rowY += rowMeasure.height;
+			}
+		}
+		if (rowIndex === -1) {
+			rowIndex = Math.min(tableFragment.toRow - 1, tableMeasure.rows.length - 1);
+			if (rowIndex < tableFragment.fromRow) continue;
+		}
+		const rowMeasure = tableMeasure.rows[rowIndex];
+		const row = tableBlock.rows[rowIndex];
+		if (!rowMeasure || !row) continue;
+		let colX = 0;
+		let colIndex = -1;
+		if (rowMeasure.cells.length === 0 || row.cells.length === 0) continue;
+		for (let c = 0; c < rowMeasure.cells.length; c++) {
+			const cellMeasure = rowMeasure.cells[c];
+			if (localX >= colX && localX < colX + cellMeasure.width) {
+				colIndex = c;
+				break;
+			}
+			colX += cellMeasure.width;
+		}
+		if (colIndex === -1) {
+			colIndex = rowMeasure.cells.length - 1;
+			if (colIndex < 0) continue;
+		}
+		const cellMeasure = rowMeasure.cells[colIndex];
+		const cell = row.cells[colIndex];
+		if (!cellMeasure || !cell) continue;
+		let rowTop = 0;
+		const isClickOnHeader = headerHeight > 0 && rowIndex < headerRowCount;
+		if (isClickOnHeader) for (let r = 0; r < rowIndex; r++) rowTop += tableMeasure.rows[r]?.height ?? 0;
+		else {
+			rowTop = headerHeight;
+			for (let r = tableFragment.fromRow; r < rowIndex; r++) rowTop += tableMeasure.rows[r]?.height ?? 0;
+		}
+		let colLeft = 0;
+		for (let c = 0; c < colIndex; c++) colLeft += rowMeasure.cells[c]?.width ?? 0;
+		let cellBlock;
+		let cellBlockMeasure;
+		if (cell.blocks.length > 0) {
+			const firstBlock = cell.blocks[0];
+			const firstMeasure = cellMeasure.blocks[0];
+			if (firstBlock.kind === "paragraph" && firstMeasure?.kind === "paragraph") {
+				cellBlock = firstBlock;
+				cellBlockMeasure = firstMeasure;
+			}
+		}
+		const cellLocalX = localX - colLeft;
+		const clipOffset = isClickOnHeader ? 0 : tableFragment.topClip ?? 0;
+		const cellLocalY = localY - rowTop + clipOffset;
+		return {
+			fragment: tableFragment,
+			block: tableBlock,
+			measure: tableMeasure,
+			pageIndex: pageHit.pageIndex,
+			rowIndex,
+			colIndex,
+			...cellBlock !== void 0 ? { cellBlock } : {},
+			...cellBlockMeasure !== void 0 ? { cellMeasure: cellBlockMeasure } : {},
+			cellLocalX: Math.max(0, cellLocalX),
+			cellLocalY: Math.max(0, cellLocalY)
+		};
+	}
+	return null;
+}
+/**
+* Perform complete hit testing from document coordinates to the most specific element.
+*
+* @param layout - The layout containing pages.
+* @param blocks - All flow blocks.
+* @param measures - All measurements.
+* @param point - Point in document coordinates (Y is cumulative from document top).
+* @returns Complete hit test result.
+*/
+function hitTest(layout, blocks, measures, point) {
+	const result = {
+		pageHit: null,
+		fragmentHit: null,
+		tableCellHit: null
+	};
+	result.pageHit = hitTestPage(layout, point);
+	if (!result.pageHit) return result;
+	const pageTop = getPageTop(layout, result.pageHit.pageIndex);
+	const pagePoint = {
+		x: point.x,
+		y: point.y - pageTop
+	};
+	result.fragmentHit = hitTestFragment(result.pageHit, blocks, measures, pagePoint);
+	if (result.fragmentHit?.fragment.kind === "table") result.tableCellHit = hitTestTableCell(result.pageHit, blocks, measures, pagePoint);
+	return result;
+}
+/**
+* Get the total document height (all pages + gaps).
+*/
+function getTotalDocumentHeight(layout) {
+	if (layout.pages.length === 0) return 0;
+	const pageGap = layout.pageGap ?? 0;
+	let height = 0;
+	for (let i = 0; i < layout.pages.length; i++) {
+		const page = layout.pages[i];
+		height += page.size.h;
+		if (i < layout.pages.length - 1) height += pageGap;
+	}
+	return height;
+}
+/**
+* Get Y coordinate to scroll to for a specific page.
+*/
+function getScrollYForPage(layout, pageIndex) {
+	return getPageTop(layout, pageIndex);
+}
+/**
+* Get page bounds (top and bottom Y coordinates).
+*/
+function getPageBounds(layout, pageIndex) {
+	if (pageIndex < 0 || pageIndex >= layout.pages.length) return null;
+	const top = getPageTop(layout, pageIndex);
+	return {
+		top,
+		bottom: top + layout.pages[pageIndex].size.h
+	};
+}
+/**
+* Check if a point is within the content area of a page (inside margins).
+*/
+function isPointInContentArea(_layout, pageHit, pagePoint) {
+	const page = pageHit.page;
+	const margins = page.margins;
+	const contentLeft = margins.left;
+	const contentRight = page.size.w - margins.right;
+	const contentTop = margins.top;
+	const contentBottom = page.size.h - margins.bottom;
+	return pagePoint.x >= contentLeft && pagePoint.x <= contentRight && pagePoint.y >= contentTop && pagePoint.y <= contentBottom;
+}
+/**
+* Find the nearest fragment to a point on a page.
+* Useful when the click is in whitespace.
+*/
+function findNearestFragment(pageHit, blocks, measures, pagePoint) {
+	let nearestHit = null;
+	let nearestDistance = Infinity;
+	for (const fragment of pageHit.page.fragments) {
+		const blockIndex = findBlockIndexById(blocks, fragment.blockId);
+		if (blockIndex === -1) continue;
+		const block = blocks[blockIndex];
+		const measure = measures[blockIndex];
+		if (!block || !measure) continue;
+		let height;
+		if (fragment.kind === "paragraph" && measure.kind === "paragraph") height = calculateParagraphFragmentHeight(fragment, measure);
+		else if (fragment.kind === "table" || fragment.kind === "image") height = fragment.height;
+		else continue;
+		const centerX = fragment.x + fragment.width / 2;
+		const centerY = fragment.y + height / 2;
+		const distance = Math.hypot(pagePoint.x - centerX, pagePoint.y - centerY);
+		if (distance < nearestDistance) {
+			nearestDistance = distance;
+			nearestHit = {
+				fragment,
+				block,
+				measure,
+				pageIndex: pageHit.pageIndex,
+				localX: Math.max(0, Math.min(pagePoint.x - fragment.x, fragment.width)),
+				localY: Math.max(0, Math.min(pagePoint.y - fragment.y, height))
+			};
+		}
+	}
+	return nearestHit;
+}
+//#endregion
+export { findNearestFragment, getPageBounds, getPageIndexAtY, getPageTop, getScrollYForPage, getTotalDocumentHeight, hitTest, hitTestFragment, hitTestImageFragment, hitTestPage, hitTestTableCell, isPointInContentArea };

package/dist/layout-bridge/engine/measuring/index.d.ts

@@ -0,0 +1,10 @@
+import { FontMetrics, FontStyle, RunMeasurement, TextMeasurement } from "../../../layout-engine/measure/measureTypes.js";
+import { getFontMetrics, measureRun, measureText, measureTextWidth } from "../../../layout-engine/measure/measureProvider.js";
+import { getCanvasContext, resetCanvasContext } from "../../../layout-engine/measure/measureContainer.js";
+import { buildFontString, findCharacterAtX, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx } from "../../../layout-engine/measure/measureHelpers.js";
+import { FloatingExclusionRect, FloatingImageZone, FloatingLineMargins, FloatingLineSegmentZone, WrapTextDirection, getFloatingAvailableWidth, getFloatingMargins, rectsToFloatingZones } from "../../../layout-engine/measure/floatingZones.js";
+import { clampFloatingWrapMargins } from "../../../layout-engine/measure/clampFloatingWrapMargins.js";
+import { MIN_WRAP_SEGMENT_WIDTH, MeasureParagraphOptions, findClearLineY, getRunCharWidths, measureParagraph, measureParagraphs } from "../../../layout-engine/measure/measureParagraph.js";
+import { clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFontCacheSize, getParagraphCacheSize, getTextCacheSize, getTotalCacheSize, hashParagraphBlock, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFontCacheSize, setParagraphCacheSize, setTextCacheSize } from "../../../layout-engine/measure/cache.js";
+import { FolioMeasurementFeatureFlags, isWorkerFontMetricsEnabled, setFolioMeasurementFlags } from "../../../layout-engine/measure/featureFlags.js";
+export { type FloatingExclusionRect, type FloatingImageZone, type FloatingLineMargins, type FloatingLineSegmentZone, type FolioMeasurementFeatureFlags, type FontMetrics, type FontStyle, MIN_WRAP_SEGMENT_WIDTH, type MeasureParagraphOptions, type RunMeasurement, type TextMeasurement, type WrapTextDirection, buildFontString, clampFloatingWrapMargins, clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, findCharacterAtX, findClearLineY, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getCanvasContext, getFloatingAvailableWidth, getFloatingMargins, getFontCacheSize, getFontMetrics, getParagraphCacheSize, getRunCharWidths, getTextCacheSize, getTotalCacheSize, getXForCharacter, halfPtToPx, hashParagraphBlock, isWorkerFontMetricsEnabled, measureParagraph, measureParagraphs, measureRun, measureText, measureTextWidth, ptToPx, pxToHalfPt, pxToPt, pxToTwips, rectsToFloatingZones, resetCanvasContext, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFolioMeasurementFlags, setFontCacheSize, setParagraphCacheSize, setTextCacheSize, twipsToPx };

package/dist/layout-bridge/engine/measuring/index.js

@@ -0,0 +1,9 @@
+import { getFontMetrics, measureRun, measureText, measureTextWidth } from "../../../layout-engine/measure/measureProvider.js";
+import { buildFontString, findCharacterAtX, getXForCharacter, halfPtToPx, ptToPx, pxToHalfPt, pxToPt, pxToTwips, twipsToPx } from "../../../layout-engine/measure/measureHelpers.js";
+import { clampFloatingWrapMargins } from "../../../layout-engine/measure/clampFloatingWrapMargins.js";
+import { getFloatingAvailableWidth, getFloatingMargins, rectsToFloatingZones } from "../../../layout-engine/measure/floatingZones.js";
+import { MIN_WRAP_SEGMENT_WIDTH, findClearLineY, getRunCharWidths, measureParagraph, measureParagraphs } from "../../../layout-engine/measure/measureParagraph.js";
+import { clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFontCacheSize, getParagraphCacheSize, getTextCacheSize, getTotalCacheSize, hashParagraphBlock, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFontCacheSize, setParagraphCacheSize, setTextCacheSize } from "../../../layout-engine/measure/cache.js";
+import { isWorkerFontMetricsEnabled, setFolioMeasurementFlags } from "../../../layout-engine/measure/featureFlags.js";
+import { getCanvasContext, resetCanvasContext } from "../../../layout-engine/measure/measureContainer.js";
+export { MIN_WRAP_SEGMENT_WIDTH, buildFontString, clampFloatingWrapMargins, clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, findCharacterAtX, findClearLineY, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getCanvasContext, getFloatingAvailableWidth, getFloatingMargins, getFontCacheSize, getFontMetrics, getParagraphCacheSize, getRunCharWidths, getTextCacheSize, getTotalCacheSize, getXForCharacter, halfPtToPx, hashParagraphBlock, isWorkerFontMetricsEnabled, measureParagraph, measureParagraphs, measureRun, measureText, measureTextWidth, ptToPx, pxToHalfPt, pxToPt, pxToTwips, rectsToFloatingZones, resetCanvasContext, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFolioMeasurementFlags, setFontCacheSize, setParagraphCacheSize, setTextCacheSize, twipsToPx };

package/dist/layout-bridge/engine/selectionRects.d.ts

@@ -0,0 +1,59 @@
+import { FlowBlock, Layout, Measure } from "../../layout-engine/types.js";
+
+//#region src/layout-bridge/engine/selectionRects.d.ts
+/**
+ * A rectangle representing part of a selection.
+ */
+type SelectionRect = {
+  /** X coordinate in container space. */x: number; /** Y coordinate in container space. */
+  y: number; /** Width of the rectangle. */
+  width: number; /** Height of the rectangle (typically line height). */
+  height: number; /** Page index (0-based). */
+  pageIndex: number;
+};
+/**
+ * Caret position for collapsed selection.
+ */
+type CaretPosition = {
+  /** X coordinate in container space. */x: number; /** Y coordinate in container space. */
+  y: number; /** Height of the caret (line height). */
+  height: number; /** Page index (0-based). */
+  pageIndex: number;
+};
+/**
+ * Convert a ProseMirror selection range to screen rectangles.
+ *
+ * @param layout - The document layout.
+ * @param blocks - All flow blocks.
+ * @param measures - All measurements.
+ * @param from - Start PM position.
+ * @param to - End PM position.
+ * @returns Array of rectangles covering the selection.
+ */
+declare function selectionToRects(layout: Layout, blocks: FlowBlock[], measures: Measure[], from: number, to: number): SelectionRect[];
+/**
+ * Get caret position for a collapsed selection.
+ *
+ * @param layout - The document layout.
+ * @param blocks - All flow blocks.
+ * @param measures - All measurements.
+ * @param pmPosition - The PM position.
+ * @returns Caret position, or null if not found.
+ */
+declare function getCaretPosition(layout: Layout, blocks: FlowBlock[], measures: Measure[], pmPosition: number): CaretPosition | null;
+/**
+ * Check if a selection spans multiple pages.
+ *
+ * @param rects - Selection rectangles.
+ * @returns True if selection spans multiple pages.
+ */
+declare function isMultiPageSelection(rects: SelectionRect[]): boolean;
+/**
+ * Get selection rectangles grouped by page.
+ *
+ * @param rects - Selection rectangles.
+ * @returns Map of page index to rectangles on that page.
+ */
+declare function groupRectsByPage(rects: SelectionRect[]): Map<number, SelectionRect[]>;
+//#endregion
+export { CaretPosition, SelectionRect, getCaretPosition, groupRectsByPage, isMultiPageSelection, selectionToRects };