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

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

@@ -0,0 +1,17 @@
+import { EditorView } from "prosemirror-view";
+
+//#region src/paged-layout/scrollToPmPosition.d.ts
+/** Class on the pages container `PagedEditor` paints into. */
+declare const PAGES_CONTAINER_CLASS = "paged-editor__pages";
+/** Scroll visible pages to a ProseMirror position. */
+declare const scrollPagesToPmPosition: (pageContainer: HTMLElement, pmPos: number) => void;
+/**
+ * Scroll the paged layout that mirrors `view` so `pmPos` is centered
+ * in the viewport. The hidden editing view sits inside the editor's
+ * scroll container, so the painted pages are reachable from its DOM.
+ * Returns false when no paged layout is found (non-paged host) so
+ * callers can fall back to coordinate-based scrolling.
+ */
+declare const scrollFolioPositionIntoView: (view: EditorView, pmPos: number) => boolean;
+//#endregion
+export { PAGES_CONTAINER_CLASS, scrollFolioPositionIntoView, scrollPagesToPmPosition };

package/dist/paged-layout/scrollToPmPosition.js

@@ -0,0 +1,95 @@
+import { findBodyPmAnchor, findBodyPmAnchors } from "../layout-bridge/dom/findBodyPmSpans.js";
+import { findPageShellForPmPos } from "../layout-painter/renderPage.js";
+import { isValidPmScrollPosition, prefersReducedMotionBehavior } from "./scrollNavigation.js";
+//#region src/paged-layout/scrollToPmPosition.ts
+/** Class on the pages container `PagedEditor` paints into. */
+const PAGES_CONTAINER_CLASS = "paged-editor__pages";
+/** Scroll visible pages to a ProseMirror position. */
+const scrollPagesToPmPosition = (pageContainer, pmPos) => {
+	if (!isValidPmScrollPosition(pmPos)) return;
+	const exact = findBodyPmAnchor(pageContainer, pmPos);
+	if (exact) {
+		exact.scrollIntoView({
+			behavior: prefersReducedMotionBehavior(),
+			block: "center"
+		});
+		return;
+	}
+	let runMatch = null;
+	for (const el of findBodyPmAnchors(pageContainer)) {
+		const start = Number(el.dataset["pmStart"]);
+		if (Number.isNaN(start)) continue;
+		const endAttr = el.dataset["pmEnd"];
+		const end = endAttr === void 0 ? start : Number(endAttr);
+		if (start <= pmPos && pmPos <= end) {
+			runMatch = el;
+			break;
+		}
+	}
+	if (runMatch) {
+		runMatch.scrollIntoView({
+			behavior: prefersReducedMotionBehavior(),
+			block: "center"
+		});
+		return;
+	}
+	const shellHit = findPageShellForPmPos(pageContainer, pmPos);
+	if (!shellHit) return;
+	const { element: shell } = shellHit;
+	shell.scrollIntoView({
+		behavior: prefersReducedMotionBehavior(),
+		block: "center"
+	});
+	let attempts = 0;
+	const refine = () => {
+		attempts++;
+		const exactInShell = findBodyPmAnchor(shell, pmPos);
+		if (exactInShell) {
+			exactInShell.scrollIntoView({
+				behavior: prefersReducedMotionBehavior(),
+				block: "center"
+			});
+			return;
+		}
+		let bestEl = null;
+		let bestStart = Number.NEGATIVE_INFINITY;
+		for (const el of findBodyPmAnchors(shell)) {
+			const start = Number(el.dataset["pmStart"]);
+			if (Number.isNaN(start)) continue;
+			const endAttr = el.dataset["pmEnd"];
+			const end = endAttr === void 0 ? start : Number(endAttr);
+			if (start <= pmPos && pmPos <= end) {
+				bestEl = el;
+				break;
+			}
+			if (start <= pmPos && start > bestStart) {
+				bestStart = start;
+				bestEl = el;
+			}
+		}
+		if (bestEl) {
+			bestEl.scrollIntoView({
+				behavior: prefersReducedMotionBehavior(),
+				block: "center"
+			});
+			return;
+		}
+		if (attempts < 20) requestAnimationFrame(refine);
+	};
+	requestAnimationFrame(refine);
+};
+/**
+* Scroll the paged layout that mirrors `view` so `pmPos` is centered
+* in the viewport. The hidden editing view sits inside the editor's
+* scroll container, so the painted pages are reachable from its DOM.
+* Returns false when no paged layout is found (non-paged host) so
+* callers can fall back to coordinate-based scrolling.
+*/
+const scrollFolioPositionIntoView = (view, pmPos) => {
+	const pageContainer = view.dom.closest("[data-folio-scroll]")?.querySelector(`.paged-editor__pages`) ?? null;
+	if (!pageContainer) return false;
+	scrollPagesToPmPosition(pageContainer, pmPos);
+	return true;
+};
+//#endregion
+export { PAGES_CONTAINER_CLASS, scrollFolioPositionIntoView, scrollPagesToPmPosition };

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

@@ -0,0 +1,35 @@
+import { FlowBlock } from "../layout-engine/types.js";
+import { SectionLayoutConfig } from "../layout-engine/index.js";
+
+//#region src/paged-layout/sectionBlockWidths.d.ts
+type ComputePerBlockMeasureInput = {
+  blocks: FlowBlock[];
+  bodyConfig: SectionLayoutConfig;
+  finalConfig: SectionLayoutConfig;
+};
+type PerBlockMeasureInputs = {
+  widths: number[];
+  marginTops: number[];
+  pageHeights: number[];
+  marginBottoms: number[];
+};
+/**
+ * Compute per-block measurement widths by scanning for section breaks.
+ * Blocks in multi-column sections must be measured at column width, not full content width.
+ *
+ * OOXML note: Each section break carries the CURRENT section's properties.
+ * Section N's blocks use config from sectionBreak[N].
+ * The final section (after all breaks) uses body-level config.
+ */
+declare function computePerBlockWidths({
+  blocks,
+  bodyConfig,
+  finalConfig
+}: ComputePerBlockMeasureInput): number[];
+declare function computePerBlockMeasureInputs({
+  blocks,
+  bodyConfig,
+  finalConfig
+}: ComputePerBlockMeasureInput): PerBlockMeasureInputs;
+//#endregion
+export { computePerBlockMeasureInputs, computePerBlockWidths };

package/dist/paged-layout/sectionBlockWidths.js

@@ -0,0 +1,52 @@
+import { collectSectionConfigs } from "../layout-engine/index.js";
+//#region src/paged-layout/sectionBlockWidths.ts
+const SINGLE_COLUMN_LAYOUT = {
+	count: 1,
+	gap: 0
+};
+/**
+* Compute per-block measurement widths by scanning for section breaks.
+* Blocks in multi-column sections must be measured at column width, not full content width.
+*
+* OOXML note: Each section break carries the CURRENT section's properties.
+* Section N's blocks use config from sectionBreak[N].
+* The final section (after all breaks) uses body-level config.
+*/
+function computePerBlockWidths({ blocks, bodyConfig, finalConfig }) {
+	return computePerBlockMeasureInputs({
+		blocks,
+		bodyConfig,
+		finalConfig
+	}).widths;
+}
+function computePerBlockMeasureInputs({ blocks, bodyConfig, finalConfig }) {
+	function colWidth(cw, cols) {
+		if (cols.count <= 1) return cw;
+		return Math.floor((cw - (cols.count - 1) * cols.gap) / cols.count);
+	}
+	function contentWidth(config) {
+		return config.pageSize.w - config.margins.left - config.margins.right;
+	}
+	const { configs: sectionConfigs, breakIndices } = collectSectionConfigs(blocks, bodyConfig, finalConfig);
+	let sectionIdx = 0;
+	const widths = [];
+	const marginTops = [];
+	const pageHeights = [];
+	const marginBottoms = [];
+	for (let i = 0; i < blocks.length; i++) {
+		const config = sectionConfigs[sectionIdx] ?? finalConfig;
+		widths.push(colWidth(contentWidth(config), config.columns ?? SINGLE_COLUMN_LAYOUT));
+		marginTops.push(config.margins.top);
+		pageHeights.push(config.pageSize.h);
+		marginBottoms.push(config.margins.bottom);
+		if (sectionIdx < breakIndices.length && i === breakIndices[sectionIdx]) sectionIdx++;
+	}
+	return {
+		widths,
+		marginTops,
+		pageHeights,
+		marginBottoms
+	};
+}
+//#endregion
+export { computePerBlockMeasureInputs, computePerBlockWidths };

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

@@ -0,0 +1,21 @@
+import { document_d_exports } from "../types/document.js";
+import { PageMargins } from "../layout-engine/types.js";
+
+//#region src/paged-layout/sectionGeometry.d.ts
+declare const DEFAULT_PAGE_WIDTH_PX = 816;
+declare const DEFAULT_PAGE_HEIGHT_PX = 1056;
+declare const DEFAULT_BODY_MARGIN_PX = 96;
+declare const DEFAULT_HEADER_FOOTER_DISTANCE_PX = 48;
+declare const twipsToPixels: (twips: number) => number;
+/**
+ * Convert an offset-like twip dimension to px. Explicit 0 is meaningful for
+ * page margins and header/footer distances; only absence should use fallback.
+ */
+declare const twipsToPxOr: (twips: number | null | undefined, fallbackPx: number) => number;
+declare const getPageSize: (sectionProps: document_d_exports.SectionProperties | null | undefined) => {
+  w: number;
+  h: number;
+};
+declare const getMargins: (sectionProps: document_d_exports.SectionProperties | null | undefined) => PageMargins;
+//#endregion
+export { DEFAULT_BODY_MARGIN_PX, DEFAULT_HEADER_FOOTER_DISTANCE_PX, DEFAULT_PAGE_HEIGHT_PX, DEFAULT_PAGE_WIDTH_PX, getMargins, getPageSize, twipsToPixels, twipsToPxOr };

package/dist/paged-layout/sectionGeometry.js

@@ -0,0 +1,36 @@
+//#region src/paged-layout/sectionGeometry.ts
+const DEFAULT_PAGE_WIDTH_PX = 816;
+const DEFAULT_PAGE_HEIGHT_PX = 1056;
+const DEFAULT_BODY_MARGIN_PX = 96;
+const DEFAULT_HEADER_FOOTER_DISTANCE_PX = 48;
+const DEFAULT_MARGINS = {
+	top: 96,
+	right: 96,
+	bottom: 96,
+	left: 96
+};
+const twipsToPixels = (twips) => Math.round(twips / 1440 * 96);
+/**
+* Convert an offset-like twip dimension to px. Explicit 0 is meaningful for
+* page margins and header/footer distances; only absence should use fallback.
+*/
+const twipsToPxOr = (twips, fallbackPx) => twips !== null && twips !== void 0 ? twipsToPixels(twips) : fallbackPx;
+/**
+* Convert a page-dimension twip value to px. Page dimensions must be positive:
+* a literal 0 is malformed and, like an absent value, uses the fallback.
+*/
+const pageDimToPx = (twips, fallbackPx) => twips !== null && twips !== void 0 && twips > 0 ? twipsToPixels(twips) : fallbackPx;
+const getPageSize = (sectionProps) => ({
+	w: pageDimToPx(sectionProps?.pageWidth, 816),
+	h: pageDimToPx(sectionProps?.pageHeight, DEFAULT_PAGE_HEIGHT_PX)
+});
+const getMargins = (sectionProps) => ({
+	top: twipsToPxOr(sectionProps?.marginTop, DEFAULT_MARGINS.top),
+	right: twipsToPxOr(sectionProps?.marginRight, DEFAULT_MARGINS.right),
+	bottom: twipsToPxOr(sectionProps?.marginBottom, DEFAULT_MARGINS.bottom),
+	left: twipsToPxOr(sectionProps?.marginLeft, DEFAULT_MARGINS.left),
+	header: twipsToPxOr(sectionProps?.headerDistance, 48),
+	footer: twipsToPxOr(sectionProps?.footerDistance, 48)
+});
+//#endregion
+export { DEFAULT_BODY_MARGIN_PX, DEFAULT_HEADER_FOOTER_DISTANCE_PX, DEFAULT_PAGE_HEIGHT_PX, DEFAULT_PAGE_WIDTH_PX, getMargins, getPageSize, twipsToPixels, twipsToPxOr };

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

@@ -0,0 +1,29 @@
+import { EditorView } from "prosemirror-view";
+
+//#region src/paged-layout/selectionViewportRect.d.ts
+/** Attribute SelectionOverlay stamps on every painted highlight rect. */
+declare const FOLIO_SELECTION_RECT_ATTRIBUTE = "data-folio-selection-rect";
+/** Attribute SelectionOverlay stamps on the painted collapsed caret. */
+declare const FOLIO_CARET_RECT_ATTRIBUTE = "data-folio-caret-rect";
+/**
+ * Union bounding rect (client coordinates) of the painted selection
+ * highlights mirroring `view`'s selection. Returns null for a collapsed
+ * selection or while the overlay has not painted yet — the selection
+ * geometry is computed asynchronously after each selection change, so
+ * callers should retry on a later frame instead of treating null as
+ * "no selection".
+ */
+declare const getFolioSelectionViewportRect: (view: EditorView) => DOMRect | null;
+/**
+ * Client-coordinate rect of the painted collapsed caret mirroring `view`'s
+ * cursor. The paged editor's editing view is hidden off-screen, so
+ * `view.coordsAtPos` cannot anchor caret-relative floating UI (the slash
+ * menu); this reads the painted caret div instead. Returns null while the
+ * overlay has not painted the caret yet (it is computed asynchronously after
+ * each selection change) or when the selection is a range rather than a caret,
+ * so callers should retry on a later frame instead of treating null as "no
+ * caret".
+ */
+declare const getFolioCaretViewportRect: (view: EditorView) => DOMRect | null;
+//#endregion
+export { FOLIO_CARET_RECT_ATTRIBUTE, FOLIO_SELECTION_RECT_ATTRIBUTE, getFolioCaretViewportRect, getFolioSelectionViewportRect };

package/dist/paged-layout/selectionViewportRect.js

@@ -0,0 +1,55 @@
+//#region src/paged-layout/selectionViewportRect.ts
+/** Attribute SelectionOverlay stamps on every painted highlight rect. */
+const FOLIO_SELECTION_RECT_ATTRIBUTE = "data-folio-selection-rect";
+/** Attribute SelectionOverlay stamps on the painted collapsed caret. */
+const FOLIO_CARET_RECT_ATTRIBUTE = "data-folio-caret-rect";
+/**
+* Union bounding rect (client coordinates) of the painted selection
+* highlights mirroring `view`'s selection. Returns null for a collapsed
+* selection or while the overlay has not painted yet — the selection
+* geometry is computed asynchronously after each selection change, so
+* callers should retry on a later frame instead of treating null as
+* "no selection".
+*/
+const getFolioSelectionViewportRect = (view) => {
+	const scrollContainer = view.dom.closest("[data-folio-scroll]");
+	if (!scrollContainer) return null;
+	let left = Number.POSITIVE_INFINITY;
+	let top = Number.POSITIVE_INFINITY;
+	let right = Number.NEGATIVE_INFINITY;
+	let bottom = Number.NEGATIVE_INFINITY;
+	let found = false;
+	const highlights = scrollContainer.querySelectorAll(`[${FOLIO_SELECTION_RECT_ATTRIBUTE}]`);
+	for (const el of highlights) {
+		const rect = el.getBoundingClientRect();
+		if (rect.width <= 0 || rect.height <= 0) continue;
+		found = true;
+		left = Math.min(left, rect.left);
+		top = Math.min(top, rect.top);
+		right = Math.max(right, rect.right);
+		bottom = Math.max(bottom, rect.bottom);
+	}
+	if (!found) return null;
+	return new DOMRect(left, top, right - left, bottom - top);
+};
+/**
+* Client-coordinate rect of the painted collapsed caret mirroring `view`'s
+* cursor. The paged editor's editing view is hidden off-screen, so
+* `view.coordsAtPos` cannot anchor caret-relative floating UI (the slash
+* menu); this reads the painted caret div instead. Returns null while the
+* overlay has not painted the caret yet (it is computed asynchronously after
+* each selection change) or when the selection is a range rather than a caret,
+* so callers should retry on a later frame instead of treating null as "no
+* caret".
+*/
+const getFolioCaretViewportRect = (view) => {
+	const scrollContainer = view.dom.closest("[data-folio-scroll]");
+	if (!scrollContainer) return null;
+	const caret = scrollContainer.querySelector(`[${FOLIO_CARET_RECT_ATTRIBUTE}]`);
+	if (!caret) return null;
+	const rect = caret.getBoundingClientRect();
+	if (rect.height <= 0) return null;
+	return rect;
+};
+//#endregion
+export { FOLIO_CARET_RECT_ATTRIBUTE, FOLIO_SELECTION_RECT_ATTRIBUTE, getFolioCaretViewportRect, getFolioSelectionViewportRect };

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

@@ -0,0 +1,19 @@
+//#region src/paged-layout/tableColumnResize.d.ts
+/**
+ * Resize a pair of adjacent column widths (in twips) as the boundary handle
+ * between them is dragged by `deltaTwips`.
+ *
+ * For RTL (`w:bidiVisual`) tables the two columns either side of the boundary
+ * are visually mirrored — the `left` column paints on the right — so the drag
+ * delta is inverted: dragging the handle right grows the visual-left (logical
+ * `right`) column and shrinks the visual-right (logical `left`) one, which also
+ * keeps the committed boundary under the cursor. Returns the original widths
+ * unchanged when either side would drop below `minWidth`.
+ * eigenpal/docx-editor#940.
+ */
+declare const resizeColumnPair: (left: number, right: number, deltaTwips: number, bidi: boolean, minWidth: number) => {
+  left: number;
+  right: number;
+};
+//#endregion
+export { resizeColumnPair };

package/dist/paged-layout/tableColumnResize.js

@@ -0,0 +1,28 @@
+//#region src/paged-layout/tableColumnResize.ts
+/**
+* Resize a pair of adjacent column widths (in twips) as the boundary handle
+* between them is dragged by `deltaTwips`.
+*
+* For RTL (`w:bidiVisual`) tables the two columns either side of the boundary
+* are visually mirrored — the `left` column paints on the right — so the drag
+* delta is inverted: dragging the handle right grows the visual-left (logical
+* `right`) column and shrinks the visual-right (logical `left`) one, which also
+* keeps the committed boundary under the cursor. Returns the original widths
+* unchanged when either side would drop below `minWidth`.
+* eigenpal/docx-editor#940.
+*/
+const resizeColumnPair = (left, right, deltaTwips, bidi, minWidth) => {
+	const signedDelta = bidi ? -deltaTwips : deltaTwips;
+	const newLeft = left + signedDelta;
+	const newRight = right - signedDelta;
+	if (newLeft >= minWidth && newRight >= minWidth) return {
+		left: newLeft,
+		right: newRight
+	};
+	return {
+		left,
+		right
+	};
+};
+//#endregion
+export { resizeColumnPair };

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

@@ -0,0 +1,15 @@
+//#region src/paged-layout/tableInsertButtonGeometry.d.ts
+/**
+ * Position the table insert ("+") button inside the zoom-scaled viewport.
+ *
+ * The button is an absolute child of `.paged-editor__viewport`, which carries
+ * `transform: scale(zoom)`. `getBoundingClientRect` returns already-scaled
+ * screen pixels, so the screen-space delta from the viewport origin must be
+ * divided by `zoom` to land in the viewport's own coordinate space. The
+ * constant nudge then stays in that (button-local) space so it tracks the
+ * button, which is scaled too. Without the divisor the button drifts off the
+ * table edge at any zoom other than 100% (eigenpal/docx-editor#934).
+ */
+declare const tableInsertButtonOffset: (edge: number, viewportEdge: number, zoom: number, nudge: number) => number;
+//#endregion
+export { tableInsertButtonOffset };

package/dist/paged-layout/tableInsertButtonGeometry.js

@@ -0,0 +1,15 @@
+//#region src/paged-layout/tableInsertButtonGeometry.ts
+/**
+* Position the table insert ("+") button inside the zoom-scaled viewport.
+*
+* The button is an absolute child of `.paged-editor__viewport`, which carries
+* `transform: scale(zoom)`. `getBoundingClientRect` returns already-scaled
+* screen pixels, so the screen-space delta from the viewport origin must be
+* divided by `zoom` to land in the viewport's own coordinate space. The
+* constant nudge then stays in that (button-local) space so it tracks the
+* button, which is scaled too. Without the divisor the button drifts off the
+* table edge at any zoom other than 100% (eigenpal/docx-editor#934).
+*/
+const tableInsertButtonOffset = (edge, viewportEdge, zoom, nudge) => (edge - viewportEdge) / (zoom || 1) - nudge;
+//#endregion
+export { tableInsertButtonOffset };

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

@@ -0,0 +1,7 @@
+import { DirtyRange } from "./incrementalMeasure.js";
+import { Transaction } from "prosemirror-state";
+
+//#region src/paged-layout/transactionDirtyRange.d.ts
+declare function getTransactionDirtyRange(transaction: Transaction): DirtyRange | null;
+//#endregion
+export { getTransactionDirtyRange };

package/dist/paged-layout/transactionDirtyRange.js

@@ -0,0 +1,27 @@
+import { AddMarkStep, RemoveMarkStep } from "prosemirror-transform";
+//#region src/paged-layout/transactionDirtyRange.ts
+function getTransactionDirtyRange(transaction) {
+	const dirtyRange = {
+		from: Number.POSITIVE_INFINITY,
+		to: Number.NEGATIVE_INFINITY
+	};
+	for (let stepIndex = 0; stepIndex < transaction.mapping.maps.length; stepIndex += 1) includeStepDirtyRange(transaction, stepIndex, dirtyRange);
+	if (!Number.isFinite(dirtyRange.from) || !Number.isFinite(dirtyRange.to)) return null;
+	return dirtyRange;
+}
+function includeStepDirtyRange(transaction, stepIndex, dirtyRange) {
+	const map = transaction.mapping.maps[stepIndex];
+	if (!map) return;
+	const followingMaps = transaction.mapping.slice(stepIndex + 1);
+	const extend = (newStart, newEnd) => {
+		const finalStart = followingMaps.map(newStart, -1);
+		const finalEnd = followingMaps.map(newEnd, 1);
+		dirtyRange.from = Math.min(dirtyRange.from, finalStart, finalEnd);
+		dirtyRange.to = Math.max(dirtyRange.to, finalStart, finalEnd);
+	};
+	map.forEach((_oldStart, _oldEnd, newStart, newEnd) => extend(newStart, newEnd));
+	const step = transaction.steps[stepIndex];
+	if (step instanceof AddMarkStep || step instanceof RemoveMarkStep) extend(step.from, step.to);
+}
+//#endregion
+export { getTransactionDirtyRange };

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

@@ -0,0 +1,40 @@
+//#region src/paged-layout/zoomScrollAnchor.d.ts
+/**
+ * zoomScrollAnchor
+ *
+ * Framework-agnostic viewport-center anchoring math for zoom changes. The React
+ * `useZoomAndPageInfo` hook captures an anchor before a zoom change and restores
+ * the scroll position after the layout reflows so the document does not jump.
+ */
+type ViewportCenterZoomAnchor = {
+  offsetY: number;
+  scaledY: number;
+  zoom: number;
+};
+type CaptureViewportCenterZoomAnchorParams = {
+  clientHeight: number;
+  scrollTop: number;
+  zoom: number;
+};
+type GetViewportCenterZoomAnchorForZoomChangeParams = {
+  clientHeight: number;
+  currentZoom: number;
+  nextZoom: number;
+  pendingAnchor: ViewportCenterZoomAnchor | null;
+  scrollTop: number;
+};
+declare const captureViewportCenterZoomAnchor: ({
+  clientHeight,
+  scrollTop,
+  zoom
+}: CaptureViewportCenterZoomAnchorParams) => ViewportCenterZoomAnchor;
+declare const getViewportCenterZoomAnchorForZoomChange: ({
+  clientHeight,
+  currentZoom,
+  nextZoom,
+  pendingAnchor,
+  scrollTop
+}: GetViewportCenterZoomAnchorForZoomChangeParams) => ViewportCenterZoomAnchor | null;
+declare const getScrollTopForZoomAnchor: (anchor: ViewportCenterZoomAnchor, nextZoom: number) => number;
+//#endregion
+export { ViewportCenterZoomAnchor, captureViewportCenterZoomAnchor, getScrollTopForZoomAnchor, getViewportCenterZoomAnchorForZoomChange };

package/dist/paged-layout/zoomScrollAnchor.js

@@ -0,0 +1,25 @@
+//#region src/paged-layout/zoomScrollAnchor.ts
+const captureViewportCenterZoomAnchor = ({ clientHeight, scrollTop, zoom }) => {
+	const offsetY = clientHeight / 2;
+	return {
+		offsetY,
+		scaledY: scrollTop + offsetY,
+		zoom
+	};
+};
+const getViewportCenterZoomAnchorForZoomChange = ({ clientHeight, currentZoom, nextZoom, pendingAnchor, scrollTop }) => {
+	if (pendingAnchor?.zoom === nextZoom) return null;
+	if (currentZoom === nextZoom) return pendingAnchor;
+	if (pendingAnchor) return pendingAnchor;
+	return captureViewportCenterZoomAnchor({
+		clientHeight,
+		scrollTop,
+		zoom: currentZoom
+	});
+};
+const getScrollTopForZoomAnchor = (anchor, nextZoom) => {
+	if (anchor.zoom <= 0 || nextZoom <= 0) return anchor.scaledY - anchor.offsetY;
+	return anchor.scaledY * (nextZoom / anchor.zoom) - anchor.offsetY;
+};
+//#endregion
+export { captureViewportCenterZoomAnchor, getScrollTopForZoomAnchor, getViewportCenterZoomAnchorForZoomChange };

package/dist/prosemirror/attrs/index.d.ts

@@ -0,0 +1,80 @@
+import { BlockSdtAttrs, FieldAttrs, HardBreakAttrs, ImageAttrs, MathAttrs, ParagraphAttrs, SdtAttrs, ShapeAttrs, TableAttrs, TableCellAttrs, TableRowAttrs, TextBoxAttrs } from "../schema/nodes.js";
+import { CharacterSpacingAttrs, CharacterStyleAttrs, CommentAttrs, EmphasisMarkAttrs, FontFamilyAttrs, FontSizeAttrs, FootnoteRefAttrs, HighlightAttrs, HyperlinkAttrs, RunFormattingOverrideAttrs, RunShadingAttrs, StrikeAttrs, TextColorAttrs, TextEffectAttrs, TrackedChangeMarkAttrs, UnderlineAttrs } from "../schema/marks.js";
+import { Mark, Node } from "prosemirror-model";
+
+//#region src/prosemirror/attrs/index.d.ts
+type ProseMirrorAttrIssue = {
+  path: string;
+  message: string;
+};
+type ReadProseMirrorAttrsResult<T> = {
+  ok: true;
+  value: T;
+} | {
+  ok: false;
+  issues: ProseMirrorAttrIssue[];
+};
+declare const readParagraphAttrs: (node: Node) => ReadProseMirrorAttrsResult<ParagraphAttrs>;
+declare const expectParagraphAttrs: (node: Node) => ParagraphAttrs;
+declare const readHardBreakAttrs: (node: Node) => ReadProseMirrorAttrsResult<HardBreakAttrs>;
+declare const expectHardBreakAttrs: (node: Node) => HardBreakAttrs;
+declare const readTableAttrs: (node: Node) => ReadProseMirrorAttrsResult<TableAttrs>;
+declare const expectTableAttrs: (node: Node) => TableAttrs;
+declare const readTableRowAttrs: (node: Node) => ReadProseMirrorAttrsResult<TableRowAttrs>;
+declare const expectTableRowAttrs: (node: Node) => TableRowAttrs;
+declare const readTableCellAttrs: (node: Node) => ReadProseMirrorAttrsResult<TableCellAttrs>;
+declare const expectTableCellAttrs: (node: Node) => TableCellAttrs;
+declare const readImageAttrs: (node: Node) => ReadProseMirrorAttrsResult<ImageAttrs>;
+declare const expectImageAttrs: (node: Node) => ImageAttrs;
+declare const readFieldAttrs: (node: Node) => ReadProseMirrorAttrsResult<FieldAttrs>;
+declare const expectFieldAttrs: (node: Node) => FieldAttrs;
+declare const readMathAttrs: (node: Node) => ReadProseMirrorAttrsResult<MathAttrs>;
+declare const expectMathAttrs: (node: Node) => MathAttrs;
+declare const readSdtAttrs: (node: Node) => ReadProseMirrorAttrsResult<SdtAttrs>;
+declare const expectSdtAttrs: (node: Node) => SdtAttrs;
+declare const readBlockSdtAttrs: (node: Node) => ReadProseMirrorAttrsResult<BlockSdtAttrs>;
+declare const expectBlockSdtAttrs: (node: Node) => BlockSdtAttrs;
+declare const readShapeAttrs: (node: Node) => ReadProseMirrorAttrsResult<ShapeAttrs>;
+declare const expectShapeAttrs: (node: Node) => ShapeAttrs;
+declare const readTextBoxAttrs: (node: Node) => ReadProseMirrorAttrsResult<TextBoxAttrs>;
+declare const expectTextBoxAttrs: (node: Node) => TextBoxAttrs;
+declare const readUnderlineMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<UnderlineAttrs>;
+declare const expectUnderlineMarkAttrs: (mark: Mark) => UnderlineAttrs;
+declare const readStrikeMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<StrikeAttrs>;
+declare const expectStrikeMarkAttrs: (mark: Mark) => StrikeAttrs;
+declare const readTextColorMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<TextColorAttrs>;
+declare const expectTextColorMarkAttrs: (mark: Mark) => TextColorAttrs;
+declare const readHighlightMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<HighlightAttrs>;
+declare const expectHighlightMarkAttrs: (mark: Mark) => HighlightAttrs;
+declare const readRunShadingMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<RunShadingAttrs>;
+declare const expectRunShadingMarkAttrs: (mark: Mark) => RunShadingAttrs;
+declare const readCharacterStyleMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<CharacterStyleAttrs>;
+declare const expectCharacterStyleMarkAttrs: (mark: Mark) => CharacterStyleAttrs;
+declare const readFontSizeMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<FontSizeAttrs>;
+declare const expectFontSizeMarkAttrs: (mark: Mark) => FontSizeAttrs;
+declare const readFontFamilyMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<FontFamilyAttrs>;
+declare const expectFontFamilyMarkAttrs: (mark: Mark) => FontFamilyAttrs;
+declare const readCharacterSpacingMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<CharacterSpacingAttrs>;
+declare const expectCharacterSpacingMarkAttrs: (mark: Mark) => CharacterSpacingAttrs;
+declare const readEmphasisMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<EmphasisMarkAttrs>;
+declare const expectEmphasisMarkAttrs: (mark: Mark) => EmphasisMarkAttrs;
+declare const readTextEffectMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<TextEffectAttrs>;
+declare const expectTextEffectMarkAttrs: (mark: Mark) => TextEffectAttrs;
+declare const readFootnoteRefMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<FootnoteRefAttrs>;
+declare const expectFootnoteRefMarkAttrs: (mark: Mark) => FootnoteRefAttrs;
+declare const readCommentMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<CommentAttrs>;
+declare const expectCommentMarkAttrs: (mark: Mark) => CommentAttrs;
+declare const readTrackedChangeMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<TrackedChangeMarkAttrs>;
+declare const expectTrackedChangeMarkAttrs: (mark: Mark) => TrackedChangeMarkAttrs;
+declare const readRunFormattingOverrideMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<RunFormattingOverrideAttrs>;
+declare const expectRunFormattingOverrideMarkAttrs: (mark: Mark) => RunFormattingOverrideAttrs;
+declare const readHyperlinkMarkAttrs: (mark: Mark) => ReadProseMirrorAttrsResult<HyperlinkAttrs>;
+declare const expectHyperlinkMarkAttrs: (mark: Mark) => HyperlinkAttrs;
+type NodeAttrPatch<T extends object> = { [K in keyof T]?: T[K] | undefined };
+declare const mergeImageAttrs: (node: Node, patch: NodeAttrPatch<ImageAttrs>) => ImageAttrs;
+declare const mergeParagraphAttrs: (node: Node, patch: NodeAttrPatch<ParagraphAttrs>) => ParagraphAttrs;
+declare const mergeTableAttrs: (node: Node, patch: NodeAttrPatch<TableAttrs>) => TableAttrs;
+declare const mergeTableRowAttrs: (node: Node, patch: NodeAttrPatch<TableRowAttrs>) => TableRowAttrs;
+declare const mergeTableCellAttrs: (node: Node, patch: NodeAttrPatch<TableCellAttrs>) => TableCellAttrs;
+//#endregion
+export { ProseMirrorAttrIssue, ReadProseMirrorAttrsResult, expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectMathAttrs, expectParagraphAttrs, expectRunFormattingOverrideMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readMathAttrs, readParagraphAttrs, readRunFormattingOverrideMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };