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

package/dist/paged-layout/headerFooterMargins.d.ts

@@ -0,0 +1,73 @@
+import { HeaderFooterContent, PageMargins, SectionBreakBlock } from "../layout-engine/types.js";
+//#region src/paged-layout/headerFooterMargins.d.ts
+type EffectiveHeaderFooterMarginsInput = {
+  margins: PageMargins;
+  headerContent?: HeaderFooterContent | undefined;
+  footerContent?: HeaderFooterContent | undefined;
+  firstPageHeaderContent?: HeaderFooterContent | undefined;
+  firstPageFooterContent?: HeaderFooterContent | undefined;
+  pageSize?: {
+    w: number;
+    h: number;
+  } | undefined;
+  warn?: ((message: string) => void) | undefined;
+};
+/**
+ * A function that extends a `PageMargins` to clear the HF overflow computed
+ * from a given set of header/footer content. Returned by
+ * `computeHeaderFooterMarginExtender` and applied at every margins site:
+ * the body fallback, `finalMargins`, and per-section `sectionBreak.margins`.
+ *
+ * Eigenpal #400 — pre-PR the extension only applied to the body fallback,
+ * so a section break carrying its own `sb.margins` from `<w:sectPr>`
+ * silently overrode the extension and the footer rendered on top of body
+ * text.
+ */
+type PageMarginsExtender = (margins: PageMargins) => PageMargins;
+declare function computeHeaderFooterMarginExtender(input: Omit<EffectiveHeaderFooterMarginsInput, "margins">): PageMarginsExtender;
+/**
+ * Like `computeHeaderFooterMarginExtender` but also accounts for the
+ * first-page header/footer content. Apply this only to the margins used
+ * for page 1 of a `<w:titlePg/>`-enabled section.
+ */
+declare function computeFirstPageHeaderFooterMarginExtender(input: Omit<EffectiveHeaderFooterMarginsInput, "margins">): PageMarginsExtender;
+declare function computeEffectiveHeaderFooterMargins({
+  margins,
+  headerContent,
+  footerContent,
+  firstPageHeaderContent,
+  firstPageFooterContent,
+  pageSize,
+  warn
+}: EffectiveHeaderFooterMarginsInput): PageMargins;
+/** Rendered header/footer content shared by every extender on a page. */
+type HeaderFooterExtenderContent = Omit<EffectiveHeaderFooterMarginsInput, "margins" | "pageSize" | "warn">;
+type ExtendSectionBreakMarginsInput = {
+  content: HeaderFooterExtenderContent; /** Body page size and effective margins — the inheritance seed. */
+  bodyPageSize: {
+    w: number;
+    h: number;
+  };
+  bodyMargins: PageMargins;
+  warn?: ((message: string) => void) | undefined;
+};
+/**
+ * Extend every section break's margins to clear the same header/footer
+ * overflow the body margins do (eigenpal #400), so an overflowing footer
+ * never re-overlaps body text on a later section.
+ *
+ * The walk mirrors `collectSectionConfigs`: a break that omits its own
+ * `pageSize` or `margins` inherits the previous section's. Each break's
+ * authored-or-inherited margins are extended against the section's *own*
+ * resolved page height, so a taller page never keeps a smaller page's
+ * clamped reservation (and vice versa). Materializes `margins` on every
+ * non-inheriting break in place.
+ */
+declare function extendSectionBreakMargins(sectionBreaks: SectionBreakBlock[], {
+  content,
+  bodyPageSize,
+  bodyMargins,
+  warn
+}: ExtendSectionBreakMarginsInput): void;
+//#endregion
+export { HeaderFooterExtenderContent, PageMarginsExtender, computeEffectiveHeaderFooterMargins, computeFirstPageHeaderFooterMarginExtender, computeHeaderFooterMarginExtender, extendSectionBreakMargins };

package/dist/paged-layout/headerFooterMargins.js

@@ -0,0 +1,120 @@
+//#region src/paged-layout/headerFooterMargins.ts
+/**
+* Floor on the body content area, in pixels. Header/footer overflow can
+* never shrink the content band below this, so a degenerate document
+* (a header taller than the page) still renders some body text.
+*/
+const MIN_CONTENT_HEIGHT_PX = 24;
+function headerHeight(content) {
+	if (!content) return 0;
+	return content.marginPushBottom ?? content.visualBottom ?? content.height;
+}
+function footerHeight(content) {
+	if (!content) return 0;
+	const bottom = content.marginPushBottom ?? content.visualBottom ?? content.height;
+	const top = content.marginPushTop ?? content.visualTop ?? 0;
+	return Math.max(bottom - top, content.height);
+}
+/**
+* Build a function that, applied to any `PageMargins`, extends `top`/`bottom`
+* to clear the same header/footer content the body's effective margins do.
+* Returns the identity function when no extension is needed.
+*
+* Header/footer distances are taken from the *given* margins (the source
+* paragraph's section margins), not the body's, so each section's authored
+* `w:header`/`w:footer` distances are honored.
+*/
+/**
+* Build an extender that pushes body margins clear of HF content.
+*
+* `mode === "default"` ignores `firstPageHeaderContent` /
+* `firstPageFooterContent`. The first-page H/F only renders on page 1 of
+* a `<w:titlePg/>`-enabled section, so margins for pages 2+ within the
+* same section must NOT be extended for first-page overflow — extending
+* them would push body content down on every page even though only page
+* 1 actually carries the overflowing header. This produced visible
+* regressions on NVCA-style first-page-header docs, where pages 2+
+* inherited page 1's title-page header reservation.
+*
+* `mode === "firstPage"` uses the larger of the default and first-page
+* H/F heights — applied only to the first-page margins of a titlePg
+* section.
+*/
+function buildExtender({ headerContent, footerContent, firstPageHeaderContent, firstPageFooterContent, pageSize, warn, mode }) {
+	const headerContentHeight = mode === "firstPage" ? Math.max(headerHeight(headerContent), headerHeight(firstPageHeaderContent)) : headerHeight(headerContent);
+	const footerContentHeight = mode === "firstPage" ? Math.max(footerHeight(footerContent), footerHeight(firstPageFooterContent)) : footerHeight(footerContent);
+	return (margins) => {
+		const headerDistance = margins.header ?? 48;
+		const footerDistance = margins.footer ?? 48;
+		const availableHeaderSpace = margins.top - headerDistance;
+		const availableFooterSpace = margins.bottom - footerDistance;
+		const maxMargins = pageSize ? Math.max(0, pageSize.h - MIN_CONTENT_HEIGHT_PX) : void 0;
+		const fitsContent = headerContentHeight <= availableHeaderSpace && footerContentHeight <= availableFooterSpace;
+		const fitsPage = maxMargins === void 0 || margins.top + margins.bottom <= maxMargins;
+		if (fitsContent && fitsPage) return margins;
+		const out = { ...margins };
+		if (headerContentHeight > availableHeaderSpace) out.top = Math.max(margins.top, headerDistance + headerContentHeight);
+		if (footerContentHeight > availableFooterSpace) out.bottom = Math.max(margins.bottom, footerDistance + footerContentHeight);
+		if (pageSize && maxMargins !== void 0 && out.top + out.bottom > maxMargins) {
+			if (warn) warn(`header/footer content exceeds page height; clamping margins to preserve a content area. pageHeight=${Math.round(pageSize.h)} top=${Math.round(out.top)} bottom=${Math.round(out.bottom)}`);
+			out.bottom = Math.max(0, Math.min(out.bottom, maxMargins - out.top));
+			if (out.top + out.bottom > maxMargins) out.top = Math.max(0, maxMargins - out.bottom);
+		}
+		return out;
+	};
+}
+function computeHeaderFooterMarginExtender(input) {
+	return buildExtender({
+		...input,
+		mode: "default"
+	});
+}
+/**
+* Like `computeHeaderFooterMarginExtender` but also accounts for the
+* first-page header/footer content. Apply this only to the margins used
+* for page 1 of a `<w:titlePg/>`-enabled section.
+*/
+function computeFirstPageHeaderFooterMarginExtender(input) {
+	return buildExtender({
+		...input,
+		mode: "firstPage"
+	});
+}
+function computeEffectiveHeaderFooterMargins({ margins, headerContent, footerContent, firstPageHeaderContent, firstPageFooterContent, pageSize, warn }) {
+	return computeHeaderFooterMarginExtender({
+		headerContent,
+		footerContent,
+		firstPageHeaderContent,
+		firstPageFooterContent,
+		pageSize,
+		warn
+	})(margins);
+}
+/**
+* Extend every section break's margins to clear the same header/footer
+* overflow the body margins do (eigenpal #400), so an overflowing footer
+* never re-overlaps body text on a later section.
+*
+* The walk mirrors `collectSectionConfigs`: a break that omits its own
+* `pageSize` or `margins` inherits the previous section's. Each break's
+* authored-or-inherited margins are extended against the section's *own*
+* resolved page height, so a taller page never keeps a smaller page's
+* clamped reservation (and vice versa). Materializes `margins` on every
+* non-inheriting break in place.
+*/
+function extendSectionBreakMargins(sectionBreaks, { content, bodyPageSize, bodyMargins, warn }) {
+	let pageSize = bodyPageSize;
+	let margins = bodyMargins;
+	for (const sb of sectionBreaks) {
+		if (!sb.pageSize && !sb.margins) continue;
+		pageSize = sb.pageSize ?? pageSize;
+		margins = computeHeaderFooterMarginExtender({
+			...content,
+			pageSize,
+			warn
+		})(sb.margins ?? margins);
+		sb.margins = margins;
+	}
+}
+//#endregion
+export { computeEffectiveHeaderFooterMargins, computeFirstPageHeaderFooterMarginExtender, computeHeaderFooterMarginExtender, extendSectionBreakMargins };

package/dist/paged-layout/hiddenEditorScroll.d.ts

@@ -0,0 +1,4 @@
+//#region src/paged-layout/hiddenEditorScroll.d.ts
+declare const suppressHiddenEditorScrollToSelection: () => true;
+//#endregion
+export { suppressHiddenEditorScrollToSelection };

package/dist/paged-layout/hiddenEditorScroll.js

@@ -0,0 +1,4 @@
+//#region src/paged-layout/hiddenEditorScroll.ts
+const suppressHiddenEditorScrollToSelection = () => true;
+//#endregion
+export { suppressHiddenEditorScrollToSelection };

package/dist/paged-layout/incrementalMeasure.d.ts

@@ -0,0 +1,33 @@
+import { FlowBlock, Measure } from "../layout-engine/types.js";
+
+//#region src/paged-layout/incrementalMeasure.d.ts
+type DirtyRange = {
+  from: number;
+  to: number;
+};
+type IncrementalMeasureInput = {
+  previousBlocks: FlowBlock[];
+  previousMeasures: Measure[];
+  previousBlockWidths: number[];
+  nextBlocks: FlowBlock[];
+  nextBlockWidths: number[];
+  dirtyRange: DirtyRange;
+  measureBlock: (block: FlowBlock, blockWidth: number, blockIndex: number) => Measure;
+};
+type IncrementalMeasureResult = {
+  measures: Measure[];
+  measuredBlockIndexes: number[];
+};
+declare function mergeDirtyRanges(first: DirtyRange | null, second: DirtyRange | null): DirtyRange | null;
+declare function findDirtyBlockIndexes(blocks: FlowBlock[], dirtyRange: DirtyRange): number[];
+declare function tryBuildIncrementalMeasures({
+  previousBlocks,
+  previousMeasures,
+  previousBlockWidths,
+  nextBlocks,
+  nextBlockWidths,
+  dirtyRange,
+  measureBlock
+}: IncrementalMeasureInput): IncrementalMeasureResult | null;
+//#endregion
+export { DirtyRange, IncrementalMeasureInput, IncrementalMeasureResult, findDirtyBlockIndexes, mergeDirtyRanges, tryBuildIncrementalMeasures };

package/dist/paged-layout/incrementalMeasure.js

@@ -0,0 +1,56 @@
+//#region src/paged-layout/incrementalMeasure.ts
+function mergeDirtyRanges(first, second) {
+	if (!first) return second;
+	if (!second) return first;
+	return {
+		from: Math.min(first.from, second.from),
+		to: Math.max(first.to, second.to)
+	};
+}
+function findDirtyBlockIndexes(blocks, dirtyRange) {
+	const indexes = [];
+	const dirtyFrom = Math.min(dirtyRange.from, dirtyRange.to);
+	const dirtyTo = Math.max(dirtyRange.from, dirtyRange.to);
+	for (let i = 0; i < blocks.length; i += 1) {
+		const block = blocks[i];
+		if (!block) continue;
+		const blockStart = "pmStart" in block ? block.pmStart : void 0;
+		const blockEnd = "pmEnd" in block ? block.pmEnd : void 0;
+		if (blockStart === void 0 || blockEnd === void 0) return [];
+		if (rangesTouch(blockStart, blockEnd, dirtyFrom, dirtyTo)) indexes.push(i);
+	}
+	return indexes;
+}
+function tryBuildIncrementalMeasures({ previousBlocks, previousMeasures, previousBlockWidths, nextBlocks, nextBlockWidths, dirtyRange, measureBlock }) {
+	if (previousBlocks.length !== nextBlocks.length || previousMeasures.length !== nextBlocks.length || previousBlockWidths.length !== nextBlockWidths.length) return null;
+	for (let i = 0; i < nextBlockWidths.length; i += 1) if (previousBlockWidths[i] !== nextBlockWidths[i]) return null;
+	if (!nextBlocks.every(isIncrementalMeasureEligibleBlock)) return null;
+	const dirtyBlockIndexes = findDirtyBlockIndexes(nextBlocks, dirtyRange);
+	if (dirtyBlockIndexes.length === 0) return null;
+	const measures = previousMeasures.slice();
+	for (const blockIndex of dirtyBlockIndexes) {
+		const block = nextBlocks[blockIndex];
+		const blockWidth = nextBlockWidths[blockIndex];
+		if (!block || blockWidth === void 0) return null;
+		measures[blockIndex] = measureBlock(block, blockWidth, blockIndex);
+	}
+	return {
+		measures,
+		measuredBlockIndexes: dirtyBlockIndexes
+	};
+}
+function rangesTouch(blockStart, blockEnd, dirtyFrom, dirtyTo) {
+	if (dirtyFrom === dirtyTo) return dirtyFrom >= blockStart && dirtyFrom <= blockEnd;
+	return dirtyFrom <= blockEnd && dirtyTo >= blockStart;
+}
+function isIncrementalMeasureEligibleBlock(block) {
+	if (block.kind !== "paragraph") return false;
+	const paragraph = block;
+	if (paragraph.attrs?.listMarker || paragraph.attrs?.contextualSpacing || paragraph.attrs?.borders) return false;
+	return paragraph.runs.every((run) => {
+		if (run.kind === "field" || run.kind === "image") return false;
+		return !("footnoteRefId" in run || "endnoteRefId" in run || "isInsertion" in run || "isDeletion" in run || "changeRevisionId" in run);
+	});
+}
+//#endregion
+export { findDirtyBlockIndexes, mergeDirtyRanges, tryBuildIncrementalMeasures };

package/dist/paged-layout/rangeProjection.d.ts

@@ -0,0 +1,51 @@
+import { FlowBlock, Layout, Measure } from "../layout-engine/types.js";
+import { SelectionRect } from "../layout-bridge/engine/selectionRects.js";
+
+//#region src/paged-layout/rangeProjection.d.ts
+type ProjectableRange = {
+  from: number;
+  to: number;
+};
+type ProjectedRange<T extends ProjectableRange> = {
+  range: T;
+  rects: SelectionRect[];
+};
+type RangeProjectionContext = {
+  pagesContainer: HTMLElement;
+  zoom: number;
+  layout: Layout | null;
+  blocks: FlowBlock[];
+  measures: Measure[];
+};
+/**
+ * Stable text-column left edge in container space: the minimum painted run-span
+ * left on the first page. Gutter widgets (e.g. the block-directive rail) anchor
+ * to this instead of a single re-projected range's `rects[0].x`, which can flip
+ * horizontally between paint passes while content above reflows. The page's
+ * left margin is fixed, so this value holds steady as text is edited.
+ */
+declare const measureContentLeft: (pagesContainer: HTMLElement, zoom: number) => number | null;
+/**
+ * Computed text style of the painted run at a PM position. Overlays
+ * that paint substituted text over the pages (template fill preview,
+ * AI suggestion replacement) copy these so the injected text matches
+ * the surrounding run instead of the overlay container's base font.
+ */
+type ProjectedRunFont = {
+  fontFamily: string;
+  fontSize: string;
+  fontWeight: string;
+  fontStyle: string;
+  letterSpacing: string;
+  color: string;
+};
+/**
+ * Sample the painted-run text style at each position in a single walk
+ * over the rendered run spans. Positions outside the rendered buffer
+ * (virtualized pages) simply stay absent from the result; callers fall
+ * back to the overlay's inherited font.
+ */
+declare const collectRunFontsAtPmPositions: (pagesContainer: HTMLElement, positions: readonly number[]) => Map<number, ProjectedRunFont>;
+declare const projectRangesToRects: <T extends ProjectableRange>(ranges: readonly T[], ctx: RangeProjectionContext) => Promise<ProjectedRange<T>[]>;
+//#endregion
+export { ProjectableRange, ProjectedRange, ProjectedRunFont, RangeProjectionContext, collectRunFontsAtPmPositions, measureContentLeft, projectRangesToRects };

package/dist/paged-layout/rangeProjection.js

@@ -0,0 +1,153 @@
+import { findBodyPmSpans } from "../layout-bridge/dom/findBodyPmSpans.js";
+//#region src/paged-layout/rangeProjection.ts
+/**
+* Shared range → paged-canvas rectangle projection.
+*
+* Folio's editor lives off-screen, so features that paint over the
+* document (anonymization highlights, template-directive widgets)
+* must project their `{ from, to }` PM ranges onto container-space
+* rectangles. This mirrors the SelectionOverlay flow: prefer real
+* painted-DOM rects (correct for indents, tabs, justified text, line
+* wraps) and fall back to the layout-coordinate `selectionToRects`
+* projection only for ranges whose DOM spans aren't mounted yet
+* (initial paint, off-screen pages).
+*/
+const isTextNode = (node) => node?.nodeType === Node.TEXT_NODE;
+const pageIndexOf = (el) => {
+	const page = el.closest(".layout-page");
+	const raw = page instanceof HTMLElement ? page.dataset["pageNumber"] : void 0;
+	return raw ? Number(raw) - 1 : 0;
+};
+/** Real painted-DOM rects for a PM range via `Range.getClientRects`. */
+const domRectsForRange = (pmSpans, overlayRect, zoom, from, to) => {
+	const rects = [];
+	for (const spanEl of pmSpans) {
+		const pmStart = Number(spanEl.dataset["pmStart"]);
+		if (!(Number(spanEl.dataset["pmEnd"]) > from && pmStart < to)) continue;
+		if (spanEl.classList.contains("layout-run-tab")) {
+			const spanRect = spanEl.getBoundingClientRect();
+			rects.push({
+				x: (spanRect.left - overlayRect.left) / zoom,
+				y: (spanRect.top - overlayRect.top) / zoom,
+				width: spanRect.width / zoom,
+				height: spanRect.height / zoom,
+				pageIndex: pageIndexOf(spanEl)
+			});
+			continue;
+		}
+		let textNode = null;
+		if (isTextNode(spanEl.firstChild)) textNode = spanEl.firstChild;
+		else if (spanEl.firstChild instanceof HTMLElement && spanEl.firstChild.tagName === "A" && isTextNode(spanEl.firstChild.firstChild)) textNode = spanEl.firstChild.firstChild;
+		if (!textNode) continue;
+		const startChar = Math.max(0, from - pmStart);
+		const endChar = Math.min(textNode.length, to - pmStart);
+		if (startChar >= endChar) continue;
+		const range = spanEl.ownerDocument.createRange();
+		range.setStart(textNode, startChar);
+		range.setEnd(textNode, endChar);
+		const pageIndex = pageIndexOf(spanEl);
+		for (const rect of Array.from(range.getClientRects())) rects.push({
+			x: (rect.left - overlayRect.left) / zoom,
+			y: (rect.top - overlayRect.top) / zoom,
+			width: rect.width / zoom,
+			height: rect.height / zoom,
+			pageIndex
+		});
+	}
+	return rects;
+};
+/**
+* Stable text-column left edge in container space: the minimum painted run-span
+* left on the first page. Gutter widgets (e.g. the block-directive rail) anchor
+* to this instead of a single re-projected range's `rects[0].x`, which can flip
+* horizontally between paint passes while content above reflows. The page's
+* left margin is fixed, so this value holds steady as text is edited.
+*/
+const measureContentLeft = (pagesContainer, zoom) => {
+	const overlay = pagesContainer.parentElement?.querySelector("[data-testid=\"selection-overlay\"]");
+	const firstPage = pagesContainer.querySelector(".layout-page");
+	if (!overlay || !firstPage) return null;
+	const spans = findBodyPmSpans(firstPage);
+	if (spans.length === 0) return null;
+	const overlayLeft = overlay.getBoundingClientRect().left;
+	let min = Number.POSITIVE_INFINITY;
+	for (const span of spans) {
+		const left = span.getBoundingClientRect().left;
+		if (left < min) min = left;
+	}
+	return Number.isFinite(min) ? (min - overlayLeft) / zoom : null;
+};
+/**
+* Sample the painted-run text style at each position in a single walk
+* over the rendered run spans. Positions outside the rendered buffer
+* (virtualized pages) simply stay absent from the result; callers fall
+* back to the overlay's inherited font.
+*/
+const collectRunFontsAtPmPositions = (pagesContainer, positions) => {
+	const fonts = /* @__PURE__ */ new Map();
+	if (positions.length === 0) return fonts;
+	const remaining = new Set(positions);
+	for (const spanEl of findBodyPmSpans(pagesContainer)) {
+		if (remaining.size === 0) break;
+		const pmStart = Number(spanEl.dataset["pmStart"]);
+		const pmEnd = Number(spanEl.dataset["pmEnd"]);
+		if (Number.isNaN(pmStart) || Number.isNaN(pmEnd)) continue;
+		for (const pos of remaining) {
+			if (!(pmStart <= pos && pos < pmEnd)) continue;
+			const win = spanEl.ownerDocument.defaultView;
+			if (!win) continue;
+			const style = win.getComputedStyle(spanEl);
+			fonts.set(pos, {
+				fontFamily: style.fontFamily,
+				fontSize: style.fontSize,
+				fontWeight: style.fontWeight,
+				fontStyle: style.fontStyle,
+				letterSpacing: style.letterSpacing,
+				color: style.color
+			});
+			remaining.delete(pos);
+		}
+	}
+	return fonts;
+};
+const projectRangesToRects = async (ranges, ctx) => {
+	const { pagesContainer, zoom, layout, blocks, measures } = ctx;
+	if (ranges.length === 0) return [];
+	const overlay = pagesContainer.parentElement?.querySelector("[data-testid=\"selection-overlay\"]");
+	const firstPage = pagesContainer.querySelector(".layout-page");
+	if (!overlay || !firstPage) return [];
+	const overlayRect = overlay.getBoundingClientRect();
+	const pageRect = firstPage.getBoundingClientRect();
+	const pageOffsetX = (pageRect.left - overlayRect.left) / zoom;
+	const pageOffsetY = (pageRect.top - overlayRect.top) / zoom;
+	const pmSpans = findBodyPmSpans(pagesContainer);
+	const result = [];
+	const fallback = [];
+	for (const range of ranges) {
+		const rects = domRectsForRange(pmSpans, overlayRect, zoom, range.from, range.to);
+		if (rects.length > 0) result.push({
+			range,
+			rects
+		});
+		else fallback.push(range);
+	}
+	if (fallback.length > 0 && layout && blocks.length > 0) {
+		const { selectionToRects } = await import("../layout-bridge/engine/selectionRects.js");
+		for (const range of fallback) {
+			const rects = selectionToRects(layout, blocks, measures, range.from, range.to).map((rect) => ({
+				height: rect.height,
+				pageIndex: rect.pageIndex,
+				width: rect.width,
+				x: rect.x + pageOffsetX,
+				y: rect.y + pageOffsetY
+			}));
+			if (rects.length > 0) result.push({
+				range,
+				rects
+			});
+		}
+	}
+	return result;
+};
+//#endregion
+export { collectRunFontsAtPmPositions, measureContentLeft, projectRangesToRects };

package/dist/paged-layout/readOnlyEditAttempt.d.ts

@@ -0,0 +1,5 @@
+//#region src/paged-layout/readOnlyEditAttempt.d.ts
+type ReadOnlyEditKeyEvent = Pick<KeyboardEvent, "altKey" | "ctrlKey" | "key" | "metaKey">;
+declare const isReadOnlyEditKey: (event: ReadOnlyEditKeyEvent) => boolean;
+//#endregion
+export { isReadOnlyEditKey };

package/dist/paged-layout/readOnlyEditAttempt.js

@@ -0,0 +1,22 @@
+//#region src/paged-layout/readOnlyEditAttempt.ts
+const MODIFIED_EDIT_KEYS = /* @__PURE__ */ new Set([
+	"b",
+	"i",
+	"u",
+	"v",
+	"x",
+	"y",
+	"z"
+]);
+const PLAIN_EDIT_KEYS = /* @__PURE__ */ new Set([
+	"Backspace",
+	"Delete",
+	"Enter"
+]);
+const isReadOnlyEditKey = (event) => {
+	if (event.metaKey || event.ctrlKey) return MODIFIED_EDIT_KEYS.has(event.key.toLowerCase());
+	if (event.altKey) return false;
+	return event.key.length === 1 || PLAIN_EDIT_KEYS.has(event.key);
+};
+//#endregion
+export { isReadOnlyEditKey };

package/dist/paged-layout/scrollNavigation.d.ts

@@ -0,0 +1,23 @@
+import { Layout } from "../layout-engine/types.js";
+
+//#region src/paged-layout/scrollNavigation.d.ts
+type PageScrollTarget = {
+  type: "position";
+  pmPos: number;
+} | {
+  type: "pageShell";
+  pageIndex: number;
+};
+declare const isValidPmScrollPosition: (pmPos: number) => boolean;
+/**
+ * Pick a `scrollIntoView` / `scrollTo` `behavior` that respects the
+ * user's `prefers-reduced-motion` setting. Chrome silently no-ops
+ * `behavior: "smooth"` when reduced motion is on (instead of falling
+ * back to instant), so a stale "smooth" call from scroll-to-block
+ * leaves the user wondering why the chip "doesn't work". Use the
+ * helper everywhere we'd otherwise hard-code `"smooth"`.
+ */
+declare const prefersReducedMotionBehavior: () => ScrollBehavior;
+declare const getPageScrollTarget: (layout: Layout | null, pageNumber: number) => PageScrollTarget | null;
+//#endregion
+export { PageScrollTarget, getPageScrollTarget, isValidPmScrollPosition, prefersReducedMotionBehavior };

package/dist/paged-layout/scrollNavigation.js

@@ -0,0 +1,31 @@
+//#region src/paged-layout/scrollNavigation.ts
+const isValidPmScrollPosition = (pmPos) => Number.isInteger(pmPos) && pmPos >= 0;
+/**
+* Pick a `scrollIntoView` / `scrollTo` `behavior` that respects the
+* user's `prefers-reduced-motion` setting. Chrome silently no-ops
+* `behavior: "smooth"` when reduced motion is on (instead of falling
+* back to instant), so a stale "smooth" call from scroll-to-block
+* leaves the user wondering why the chip "doesn't work". Use the
+* helper everywhere we'd otherwise hard-code `"smooth"`.
+*/
+const prefersReducedMotionBehavior = () => {
+	if (typeof window === "undefined" || typeof window.matchMedia !== "function") return "smooth";
+	return window.matchMedia("(prefers-reduced-motion: reduce)").matches ? "auto" : "smooth";
+};
+const getPageScrollTarget = (layout, pageNumber) => {
+	if (!layout || !Number.isInteger(pageNumber) || pageNumber < 1) return null;
+	const pageIndex = pageNumber - 1;
+	const page = layout.pages[pageIndex];
+	if (!page) return null;
+	const pmStart = page.fragments.at(0)?.pmStart;
+	if (typeof pmStart === "number" && Number.isInteger(pmStart) && pmStart >= 0) return {
+		type: "position",
+		pmPos: pmStart
+	};
+	return {
+		type: "pageShell",
+		pageIndex
+	};
+};
+//#endregion
+export { getPageScrollTarget, isValidPmScrollPosition, prefersReducedMotionBehavior };

package/dist/paged-layout/scrollPageInfo.d.ts

@@ -0,0 +1,41 @@
+//#region src/paged-layout/scrollPageInfo.d.ts
+/**
+ * scrollPageInfo
+ *
+ * Framework-agnostic page-indicator state for the scrollable editor: the
+ * current/total page derivation and the total-count clamp. The React
+ * `useZoomAndPageInfo` hook owns the React state and the scroll/layout DOM
+ * reads; this module owns the pure geometry.
+ */
+type ScrollPageInfo = {
+  currentPage: number;
+  totalPages: number;
+  visible: boolean;
+};
+declare const updateScrollPageTotal: (previous: ScrollPageInfo, totalPages: number) => ScrollPageInfo;
+type ScrollPageMetrics = {
+  /** Laid-out page heights (unscaled), top to bottom. */pageHeights: readonly number[]; /** Current scroll offset of the container (scaled by zoom). */
+  scrollTop: number; /** Visible height of the scroll container. */
+  clientHeight: number; /** Current zoom factor. */
+  zoom: number; /** Padding above the first page in the scroll container. */
+  viewportPaddingTop: number; /** Gap rendered between consecutive pages. */
+  pageGap: number;
+};
+/**
+ * Derive the current page (the one under the viewport center) and total page
+ * count from the laid-out page heights and the live scroll position. Returns
+ * null when there are no pages to measure.
+ */
+declare const computeScrollPageInfo: ({
+  pageHeights,
+  scrollTop,
+  clientHeight,
+  zoom,
+  viewportPaddingTop,
+  pageGap
+}: ScrollPageMetrics) => {
+  currentPage: number;
+  totalPages: number;
+} | null;
+//#endregion
+export { ScrollPageInfo, ScrollPageMetrics, computeScrollPageInfo, updateScrollPageTotal };

package/dist/paged-layout/scrollPageInfo.js

@@ -0,0 +1,34 @@
+//#region src/paged-layout/scrollPageInfo.ts
+const updateScrollPageTotal = (previous, totalPages) => ({
+	...previous,
+	currentPage: Math.min(previous.currentPage, totalPages),
+	totalPages
+});
+/**
+* Derive the current page (the one under the viewport center) and total page
+* count from the laid-out page heights and the live scroll position. Returns
+* null when there are no pages to measure.
+*/
+const computeScrollPageInfo = ({ pageHeights, scrollTop, clientHeight, zoom, viewportPaddingTop, pageGap }) => {
+	const totalPages = pageHeights.length;
+	if (totalPages === 0) return null;
+	const viewportCenter = (scrollTop + clientHeight / 2) / Math.max(zoom, Number.EPSILON);
+	let accumulatedY = viewportPaddingTop;
+	let currentPage = 1;
+	for (let i = 0; i < totalPages; i++) {
+		const pageHeight = pageHeights[i];
+		const pageEnd = accumulatedY + pageHeight;
+		if (viewportCenter < pageEnd) {
+			currentPage = i + 1;
+			break;
+		}
+		accumulatedY = pageEnd + pageGap;
+		currentPage = i + 2;
+	}
+	return {
+		currentPage: Math.min(currentPage, totalPages),
+		totalPages
+	};
+};
+//#endregion
+export { computeScrollPageInfo, updateScrollPageTotal };