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

package/dist/layout-engine/keep-together.d.ts

@@ -0,0 +1,43 @@
+import { FlowBlock, Measure } from "./types.js";
+
+//#region src/layout-engine/keep-together.d.ts
+/**
+ * A chain of consecutive keepNext paragraphs.
+ */
+type KeepNextChain = {
+  /** Index of the first paragraph in the chain. */startIndex: number; /** Index of the last paragraph in the chain. */
+  endIndex: number; /** All paragraph indices in the chain. */
+  memberIndices: number[]; /** Index of the anchor paragraph (first non-keepNext after chain), or -1 if none. */
+  anchorIndex: number;
+};
+/**
+ * Pre-scan blocks to find all keepNext chains.
+ *
+ * A keepNext chain is a sequence of consecutive paragraphs with keepNext=true,
+ * followed by an anchor paragraph (the first non-keepNext paragraph).
+ * The entire chain must stay on the same page as the anchor's first line.
+ *
+ * Returns a map from chain start index to chain info.
+ */
+declare function computeKeepNextChains(blocks: FlowBlock[]): Map<number, KeepNextChain>;
+/**
+ * Calculate the total height needed to keep a chain together.
+ *
+ * Includes all chain members plus the first line of the anchor paragraph.
+ */
+declare function calculateChainHeight(chain: KeepNextChain, blocks: FlowBlock[], measures: Measure[]): number;
+/**
+ * Get the set of indices that are mid-chain (not chain starters).
+ * These should skip the keepNext check since their chain starter already decided.
+ */
+declare function getMidChainIndices(chains: Map<number, KeepNextChain>): Set<number>;
+/**
+ * Check if a paragraph has keepLines property (all lines must stay together).
+ */
+declare function hasKeepLines(block: FlowBlock): boolean;
+/**
+ * Check if a paragraph should start on a new page (pageBreakBefore).
+ */
+declare function hasPageBreakBefore(block: FlowBlock): boolean;
+//#endregion
+export { KeepNextChain, calculateChainHeight, computeKeepNextChains, getMidChainIndices, hasKeepLines, hasPageBreakBefore };

package/dist/layout-engine/keep-together.js

@@ -0,0 +1,98 @@
+//#region src/layout-engine/keep-together.ts
+/**
+* Pre-scan blocks to find all keepNext chains.
+*
+* A keepNext chain is a sequence of consecutive paragraphs with keepNext=true,
+* followed by an anchor paragraph (the first non-keepNext paragraph).
+* The entire chain must stay on the same page as the anchor's first line.
+*
+* Returns a map from chain start index to chain info.
+*/
+function computeKeepNextChains(blocks) {
+	const chains = /* @__PURE__ */ new Map();
+	const processed = /* @__PURE__ */ new Set();
+	for (let i = 0; i < blocks.length; i++) {
+		if (processed.has(i)) continue;
+		const block = blocks[i];
+		if (block.kind !== "paragraph") continue;
+		if (!block.attrs?.keepNext) continue;
+		const memberIndices = [i];
+		let endIndex = i;
+		for (let j = i + 1; j < blocks.length; j++) {
+			const nextBlock = blocks[j];
+			if (nextBlock.kind === "sectionBreak" || nextBlock.kind === "pageBreak" || nextBlock.kind === "columnBreak") break;
+			if (nextBlock.kind !== "paragraph") break;
+			if (nextBlock.attrs?.keepNext) {
+				memberIndices.push(j);
+				endIndex = j;
+				processed.add(j);
+			} else break;
+		}
+		const potentialAnchor = endIndex + 1;
+		let anchorIndex = -1;
+		if (potentialAnchor < blocks.length) {
+			const anchorBlock = blocks[potentialAnchor];
+			if (anchorBlock.kind !== "sectionBreak" && anchorBlock.kind !== "pageBreak" && anchorBlock.kind !== "columnBreak") anchorIndex = potentialAnchor;
+		}
+		chains.set(i, {
+			startIndex: i,
+			endIndex,
+			memberIndices,
+			anchorIndex
+		});
+	}
+	return chains;
+}
+/**
+* Calculate the total height needed to keep a chain together.
+*
+* Includes all chain members plus the first line of the anchor paragraph.
+*/
+function calculateChainHeight(chain, blocks, measures) {
+	let totalHeight = 0;
+	for (const memberIndex of chain.memberIndices) {
+		const block = blocks[memberIndex];
+		const measure = measures[memberIndex];
+		if (!block || !measure || block.kind !== "paragraph" || measure.kind !== "paragraph") continue;
+		const para = block;
+		const paraMeasure = measure;
+		const spacingBefore = para.attrs?.spacing?.before ?? 0;
+		totalHeight += spacingBefore;
+		totalHeight += paraMeasure.totalHeight;
+		const spacingAfter = para.attrs?.spacing?.after ?? 0;
+		totalHeight += spacingAfter;
+	}
+	if (chain.anchorIndex !== -1) {
+		const anchorMeasure = measures[chain.anchorIndex];
+		if (anchorMeasure?.kind === "paragraph") {
+			const anchorPara = anchorMeasure;
+			if (anchorPara.lines.length > 0) totalHeight += anchorPara.lines[0].lineHeight;
+		}
+	}
+	return totalHeight;
+}
+/**
+* Get the set of indices that are mid-chain (not chain starters).
+* These should skip the keepNext check since their chain starter already decided.
+*/
+function getMidChainIndices(chains) {
+	const midChain = /* @__PURE__ */ new Set();
+	for (const chain of chains.values()) for (let i = 1; i < chain.memberIndices.length; i++) midChain.add(chain.memberIndices[i]);
+	return midChain;
+}
+/**
+* Check if a paragraph has keepLines property (all lines must stay together).
+*/
+function hasKeepLines(block) {
+	if (block.kind !== "paragraph") return false;
+	return block.attrs?.keepLines === true;
+}
+/**
+* Check if a paragraph should start on a new page (pageBreakBefore).
+*/
+function hasPageBreakBefore(block) {
+	if (block.kind !== "paragraph") return false;
+	return block.attrs?.pageBreakBefore === true;
+}
+//#endregion
+export { calculateChainHeight, computeKeepNextChains, getMidChainIndices, hasKeepLines, hasPageBreakBefore };

package/dist/layout-engine/layoutInstrumentation.d.ts

@@ -0,0 +1,50 @@
+import { FlowBlock } from "./types.js";
+
+//#region src/layout-engine/layoutInstrumentation.d.ts
+type LayoutRunReason = "font-ready" | "initial" | "layout-input" | "manual" | "transaction";
+type LayoutPhase = "flow-blocks" | "header-footer" | "initial-fonts" | "layout-document" | "measure-blocks" | "render-pages";
+type HiddenEditorStateReason = "external-document" | "mount";
+type HiddenEditorPhase = "editor-state" | "editor-view" | "to-prose-doc" | "update-state";
+type LayoutInstrumentation = {
+  onHiddenEditorPhase?: (event: {
+    durationMs: number;
+    phase: HiddenEditorPhase;
+    reason: HiddenEditorStateReason;
+  }) => void;
+  onHiddenEditorStateCreate?: (event: {
+    reason: HiddenEditorStateReason;
+  }) => void;
+  onLayoutComplete?: (event: {
+    reason: LayoutRunReason;
+  }) => void;
+  onLayoutError?: (event: {
+    message: string;
+    reason: LayoutRunReason;
+  }) => void;
+  onLayoutPhase?: (event: {
+    durationMs: number;
+    phase: LayoutPhase;
+    reason: LayoutRunReason;
+  }) => void;
+  onMeasureBlock?: (event: {
+    blockIndex: number;
+    blockKind: FlowBlock["kind"];
+  }) => void;
+  onMeasureBlockError?: (event: {
+    blockIndex: number;
+    blockKind: FlowBlock["kind"];
+    message: string;
+  }) => void;
+};
+declare global {
+  var __folioLayoutInstrumentation: LayoutInstrumentation | undefined;
+}
+declare function recordMeasureBlock(blockIndex: number, block: FlowBlock): void;
+declare function recordMeasureBlockError(blockIndex: number, block: FlowBlock, error: unknown): void;
+declare function recordLayoutComplete(reason?: LayoutRunReason): void;
+declare function recordLayoutError(reason: LayoutRunReason, error: unknown): void;
+declare function recordLayoutPhase(reason: LayoutRunReason, phase: LayoutPhase, durationMs: number): void;
+declare function recordHiddenEditorStateCreate(reason: HiddenEditorStateReason): void;
+declare function recordHiddenEditorPhase(reason: HiddenEditorStateReason, phase: HiddenEditorPhase, durationMs: number): void;
+//#endregion
+export { HiddenEditorPhase, HiddenEditorStateReason, LayoutInstrumentation, LayoutPhase, LayoutRunReason, recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordMeasureBlock, recordMeasureBlockError };

package/dist/layout-engine/layoutInstrumentation.js

@@ -0,0 +1,43 @@
+//#region src/layout-engine/layoutInstrumentation.ts
+function recordMeasureBlock(blockIndex, block) {
+	globalThis.__folioLayoutInstrumentation?.onMeasureBlock?.({
+		blockIndex,
+		blockKind: block.kind
+	});
+}
+function recordMeasureBlockError(blockIndex, block, error) {
+	globalThis.__folioLayoutInstrumentation?.onMeasureBlockError?.({
+		blockIndex,
+		blockKind: block.kind,
+		message: error instanceof Error ? error.message : String(error)
+	});
+}
+function recordLayoutComplete(reason = "manual") {
+	globalThis.__folioLayoutInstrumentation?.onLayoutComplete?.({ reason });
+}
+function recordLayoutError(reason, error) {
+	const message = error instanceof Error ? error.message : String(error);
+	globalThis.__folioLayoutInstrumentation?.onLayoutError?.({
+		message,
+		reason
+	});
+}
+function recordLayoutPhase(reason, phase, durationMs) {
+	globalThis.__folioLayoutInstrumentation?.onLayoutPhase?.({
+		durationMs,
+		phase,
+		reason
+	});
+}
+function recordHiddenEditorStateCreate(reason) {
+	globalThis.__folioLayoutInstrumentation?.onHiddenEditorStateCreate?.({ reason });
+}
+function recordHiddenEditorPhase(reason, phase, durationMs) {
+	globalThis.__folioLayoutInstrumentation?.onHiddenEditorPhase?.({
+		durationMs,
+		phase,
+		reason
+	});
+}
+//#endregion
+export { recordHiddenEditorPhase, recordHiddenEditorStateCreate, recordLayoutComplete, recordLayoutError, recordLayoutPhase, recordMeasureBlock, recordMeasureBlockError };

package/dist/layout-engine/lineFlow.d.ts

@@ -0,0 +1,8 @@
+import { MeasuredLine } from "./types.js";
+
+//#region src/layout-engine/lineFlow.d.ts
+declare function measuredLineAdvance(line: MeasuredLine): number;
+declare function measuredLineRangeHeight(lines: readonly MeasuredLine[], fromLine: number, toLine: number): number;
+declare function measuredLineContentOffset(lines: readonly MeasuredLine[], fromLine: number, lineIndex: number): number;
+//#endregion
+export { measuredLineAdvance, measuredLineContentOffset, measuredLineRangeHeight };

package/dist/layout-engine/lineFlow.js

@@ -0,0 +1,17 @@
+//#region src/layout-engine/lineFlow.ts
+function measuredLineAdvance(line) {
+	return line.lineHeight + (line.floatSkipBefore ?? 0);
+}
+function measuredLineRangeHeight(lines, fromLine, toLine) {
+	let height = 0;
+	const start = Math.max(0, fromLine);
+	const end = Math.min(toLine, lines.length);
+	for (let index = start; index < end; index++) height += measuredLineAdvance(lines[index]);
+	return height;
+}
+function measuredLineContentOffset(lines, fromLine, lineIndex) {
+	const line = lines.at(lineIndex);
+	return measuredLineRangeHeight(lines, fromLine, lineIndex) + (line?.floatSkipBefore ?? 0);
+}
+//#endregion
+export { measuredLineAdvance, measuredLineContentOffset, measuredLineRangeHeight };

package/dist/layout-engine/measure/cache.d.ts

@@ -0,0 +1,93 @@
+import { ParagraphBlock, ParagraphMeasure } from "../types.js";
+
+//#region src/layout-engine/measure/cache.d.ts
+/**
+ * Get cached text width or return undefined
+ */
+declare function getCachedTextWidth(text: string, font: string, letterSpacing?: number): number | undefined;
+/**
+ * Store text width in cache
+ */
+declare function setCachedTextWidth(text: string, font: string, letterSpacing: number, width: number): void;
+/**
+ * Clear the text width cache
+ */
+declare function clearTextWidthCache(): void;
+/**
+ * Monotonic generation used by async measurement workers to drop
+ * responses that were measured before a cache reset.
+ */
+declare function getTextWidthCacheGeneration(): number;
+/**
+ * Set the maximum size of the text width cache
+ */
+declare function setTextCacheSize(size: number): void;
+/**
+ * Get current text width cache size
+ */
+declare function getTextCacheSize(): number;
+/**
+ * Cached font metrics entry
+ */
+type FontMetricsEntry = {
+  ascent: number;
+  descent: number;
+  lineHeight: number;
+  singleLineRatio: number;
+};
+/**
+ * Get cached font metrics or return undefined
+ */
+declare function getCachedFontMetrics(fontFamily: string, fontSize: number, bold?: boolean, italic?: boolean, fontVariant?: string): FontMetricsEntry | undefined;
+/**
+ * Store font metrics in cache
+ */
+declare function setCachedFontMetrics(fontFamily: string, fontSize: number, bold: boolean, italic: boolean, metrics: FontMetricsEntry, fontVariant?: string): void;
+/**
+ * Clear the font metrics cache
+ */
+declare function clearFontMetricsCache(): void;
+/**
+ * Set the maximum size of the font metrics cache
+ */
+declare function setFontCacheSize(size: number): void;
+/**
+ * Get current font metrics cache size
+ */
+declare function getFontCacheSize(): number;
+/**
+ * Generate a simple hash for a paragraph block
+ * Used as cache key to identify identical content
+ */
+declare function hashParagraphBlock(block: ParagraphBlock): string;
+/**
+ * Get cached paragraph measurement or return undefined
+ */
+declare function getCachedParagraphMeasure(block: ParagraphBlock, maxWidth: number): ParagraphMeasure | undefined;
+/**
+ * Store paragraph measurement in cache
+ */
+declare function setCachedParagraphMeasure(block: ParagraphBlock, maxWidth: number, measure: ParagraphMeasure): void;
+/**
+ * Clear the paragraph measure cache
+ */
+declare function clearParagraphMeasureCache(): void;
+/**
+ * Set the maximum size of the paragraph measure cache
+ */
+declare function setParagraphCacheSize(size: number): void;
+/**
+ * Get current paragraph measure cache size
+ */
+declare function getParagraphCacheSize(): number;
+/**
+ * Clear all measurement caches
+ * Call when fonts change, page width changes, or for testing
+ */
+declare function clearAllCaches(): void;
+/**
+ * Get total size of all caches
+ */
+declare function getTotalCacheSize(): number;
+//#endregion
+export { clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFontCacheSize, getParagraphCacheSize, getTextCacheSize, getTextWidthCacheGeneration, getTotalCacheSize, hashParagraphBlock, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFontCacheSize, setParagraphCacheSize, setTextCacheSize };

package/dist/layout-engine/measure/cache.js

@@ -0,0 +1,245 @@
+//#region src/layout-engine/measure/cache.ts
+/**
+* Current max size for text width cache
+*/
+let textCacheMaxSize = 2e4;
+/**
+* LRU cache for text width measurements
+* Key format: "text|font|letterSpacing"
+*/
+const textWidthCache = /* @__PURE__ */ new Map();
+let textWidthCacheGeneration = 0;
+/**
+* Create a cache key for text width lookup
+*/
+function makeTextKey(text, font, letterSpacing) {
+	return `${text}|${font}|${letterSpacing || 0}`;
+}
+/**
+* Evict oldest entries if cache exceeds max size
+*/
+function evictTextEntries() {
+	while (textWidthCache.size > textCacheMaxSize) {
+		const oldestKey = textWidthCache.keys().next().value;
+		if (oldestKey === void 0) break;
+		textWidthCache.delete(oldestKey);
+	}
+}
+/**
+* Get cached text width or return undefined
+*/
+function getCachedTextWidth(text, font, letterSpacing = 0) {
+	const key = makeTextKey(text, font, letterSpacing);
+	const entry = textWidthCache.get(key);
+	if (entry !== void 0) {
+		textWidthCache.delete(key);
+		textWidthCache.set(key, entry);
+		return entry.width;
+	}
+}
+/**
+* Store text width in cache
+*/
+function setCachedTextWidth(text, font, letterSpacing, width) {
+	const key = makeTextKey(text, font, letterSpacing);
+	textWidthCache.set(key, { width });
+	evictTextEntries();
+}
+/**
+* Clear the text width cache
+*/
+function clearTextWidthCache() {
+	textWidthCache.clear();
+	textWidthCacheGeneration += 1;
+}
+/**
+* Monotonic generation used by async measurement workers to drop
+* responses that were measured before a cache reset.
+*/
+function getTextWidthCacheGeneration() {
+	return textWidthCacheGeneration;
+}
+/**
+* Set the maximum size of the text width cache
+*/
+function setTextCacheSize(size) {
+	if (!Number.isFinite(size) || size <= 0) return;
+	textCacheMaxSize = size;
+	evictTextEntries();
+}
+/**
+* Get current text width cache size
+*/
+function getTextCacheSize() {
+	return textWidthCache.size;
+}
+/**
+* Current max size for font metrics cache
+*/
+let fontCacheMaxSize = 1e3;
+/**
+* LRU cache for font metrics
+* Key format: "fontFamily|fontSize|bold|italic|fontVariant"
+*/
+const fontMetricsCache = /* @__PURE__ */ new Map();
+/**
+* Create a cache key for font metrics lookup
+*/
+function makeFontKey(fontFamily, fontSize, bold = false, italic = false, fontVariant) {
+	return `${fontFamily}|${fontSize}|${bold}|${italic}|${fontVariant ?? ""}`;
+}
+/**
+* Evict oldest entries if font cache exceeds max size
+*/
+function evictFontEntries() {
+	while (fontMetricsCache.size > fontCacheMaxSize) {
+		const oldestKey = fontMetricsCache.keys().next().value;
+		if (oldestKey === void 0) break;
+		fontMetricsCache.delete(oldestKey);
+	}
+}
+/**
+* Get cached font metrics or return undefined
+*/
+function getCachedFontMetrics(fontFamily, fontSize, bold = false, italic = false, fontVariant) {
+	const key = makeFontKey(fontFamily, fontSize, bold, italic, fontVariant);
+	const entry = fontMetricsCache.get(key);
+	if (entry !== void 0) {
+		fontMetricsCache.delete(key);
+		fontMetricsCache.set(key, entry);
+		return entry;
+	}
+}
+/**
+* Store font metrics in cache
+*/
+function setCachedFontMetrics(fontFamily, fontSize, bold, italic, metrics, fontVariant) {
+	const key = makeFontKey(fontFamily, fontSize, bold, italic, fontVariant);
+	fontMetricsCache.set(key, metrics);
+	evictFontEntries();
+}
+/**
+* Clear the font metrics cache
+*/
+function clearFontMetricsCache() {
+	fontMetricsCache.clear();
+}
+/**
+* Set the maximum size of the font metrics cache
+*/
+function setFontCacheSize(size) {
+	if (!Number.isFinite(size) || size <= 0) return;
+	fontCacheMaxSize = size;
+	evictFontEntries();
+}
+/**
+* Get current font metrics cache size
+*/
+function getFontCacheSize() {
+	return fontMetricsCache.size;
+}
+/**
+* Current max size for paragraph measure cache
+*/
+let paragraphCacheMaxSize = 5e3;
+/**
+* LRU cache for paragraph measurements
+* Key format: block content hash
+*/
+const paragraphMeasureCache = /* @__PURE__ */ new Map();
+/**
+* Generate a simple hash for a paragraph block
+* Used as cache key to identify identical content
+*/
+function hashParagraphBlock(block) {
+	const parts = [];
+	for (const run of block.runs) if (run.kind === "text") parts.push(`t:${run.text}|${run.fontFamily}|${run.eastAsiaFontFamily}|${run.fontSize}|${run.bold}|${run.italic}|${run.allCaps}|${run.smallCaps}|${run.horizontalScale}|${run.letterSpacing}`);
+	else if (run.kind === "tab") parts.push(`tab:${run.width}`);
+	else if (run.kind === "image") parts.push(`img:${run.width}x${run.height}`);
+	else if (run.kind === "lineBreak") parts.push("br");
+	const attrs = block.attrs;
+	if (attrs) {
+		if (attrs.alignment) parts.push(`align:${attrs.alignment}`);
+		if (attrs.indent) parts.push(`indent:${attrs.indent.left}|${attrs.indent.right}|${attrs.indent.firstLine}|${attrs.indent.hanging}`);
+		if (attrs.spacing) parts.push(`spacing:${attrs.spacing.before}|${attrs.spacing.after}|${attrs.spacing.line}|${attrs.spacing.lineRule}`);
+		if (attrs.defaultFontSize != null) parts.push(`dfs:${attrs.defaultFontSize}`);
+		if (attrs.defaultFontFamily != null) parts.push(`dff:${attrs.defaultFontFamily}`);
+		if (attrs.suppressEmptyParagraphHeight) parts.push("sup");
+		const borders = attrs.borders;
+		if (borders) {
+			const signature = (border) => border ? `${border.width ?? ""},${border.style ?? ""},${border.color ?? ""}` : "";
+			parts.push(`bdr:${signature(borders.top)}|${signature(borders.bottom)}|${signature(borders.left)}|${signature(borders.right)}`);
+		}
+	}
+	return parts.join("||");
+}
+/**
+* Evict oldest entries if paragraph cache exceeds max size
+*/
+function evictParagraphEntries() {
+	while (paragraphMeasureCache.size > paragraphCacheMaxSize) {
+		const oldestKey = paragraphMeasureCache.keys().next().value;
+		if (oldestKey === void 0) break;
+		paragraphMeasureCache.delete(oldestKey);
+	}
+}
+/**
+* Get cached paragraph measurement or return undefined
+*/
+function getCachedParagraphMeasure(block, maxWidth) {
+	const key = hashParagraphBlock(block);
+	const entry = paragraphMeasureCache.get(key);
+	if (entry !== void 0 && entry.maxWidth === maxWidth) {
+		paragraphMeasureCache.delete(key);
+		paragraphMeasureCache.set(key, entry);
+		return entry.measure;
+	}
+}
+/**
+* Store paragraph measurement in cache
+*/
+function setCachedParagraphMeasure(block, maxWidth, measure) {
+	const key = hashParagraphBlock(block);
+	paragraphMeasureCache.set(key, {
+		measure,
+		maxWidth
+	});
+	evictParagraphEntries();
+}
+/**
+* Clear the paragraph measure cache
+*/
+function clearParagraphMeasureCache() {
+	paragraphMeasureCache.clear();
+}
+/**
+* Set the maximum size of the paragraph measure cache
+*/
+function setParagraphCacheSize(size) {
+	if (!Number.isFinite(size) || size <= 0) return;
+	paragraphCacheMaxSize = size;
+	evictParagraphEntries();
+}
+/**
+* Get current paragraph measure cache size
+*/
+function getParagraphCacheSize() {
+	return paragraphMeasureCache.size;
+}
+/**
+* Clear all measurement caches
+* Call when fonts change, page width changes, or for testing
+*/
+function clearAllCaches() {
+	clearTextWidthCache();
+	clearFontMetricsCache();
+	clearParagraphMeasureCache();
+}
+/**
+* Get total size of all caches
+*/
+function getTotalCacheSize() {
+	return getTextCacheSize() + getFontCacheSize() + getParagraphCacheSize();
+}
+//#endregion
+export { clearAllCaches, clearFontMetricsCache, clearParagraphMeasureCache, clearTextWidthCache, getCachedFontMetrics, getCachedParagraphMeasure, getCachedTextWidth, getFontCacheSize, getParagraphCacheSize, getTextCacheSize, getTextWidthCacheGeneration, getTotalCacheSize, hashParagraphBlock, setCachedFontMetrics, setCachedParagraphMeasure, setCachedTextWidth, setFontCacheSize, setParagraphCacheSize, setTextCacheSize };

package/dist/layout-engine/measure/clampFloatingWrapMargins.d.ts

@@ -0,0 +1,20 @@
+//#region src/layout-engine/measure/clampFloatingWrapMargins.d.ts
+/**
+ * Guard against wrap margins that exceed the available content width.
+ *
+ * When a float's wrap margins consume the entire content width (or more),
+ * there is no horizontal strip beside it for body text. Word renders the
+ * following lines at full content width instead of collapsing them to a
+ * 1-glyph column. Unchecked margins from near-full-width tables/images can
+ * exceed contentWidth and collapse every wrap line to ~1 character.
+ *
+ * Returned margins are zeroed when either side alone is >= contentWidth or
+ * their sum is >= contentWidth. Otherwise the original (non-negative) values
+ * pass through unchanged.
+ */
+declare function clampFloatingWrapMargins(leftMargin: number, rightMargin: number, contentWidth: number): {
+  leftMargin: number;
+  rightMargin: number;
+};
+//#endregion
+export { clampFloatingWrapMargins };

package/dist/layout-engine/measure/clampFloatingWrapMargins.js

@@ -0,0 +1,29 @@
+//#region src/layout-engine/measure/clampFloatingWrapMargins.ts
+/**
+* Guard against wrap margins that exceed the available content width.
+*
+* When a float's wrap margins consume the entire content width (or more),
+* there is no horizontal strip beside it for body text. Word renders the
+* following lines at full content width instead of collapsing them to a
+* 1-glyph column. Unchecked margins from near-full-width tables/images can
+* exceed contentWidth and collapse every wrap line to ~1 character.
+*
+* Returned margins are zeroed when either side alone is >= contentWidth or
+* their sum is >= contentWidth. Otherwise the original (non-negative) values
+* pass through unchanged.
+*/
+function clampFloatingWrapMargins(leftMargin, rightMargin, contentWidth) {
+	const cw = Math.max(1, contentWidth);
+	const lm = Math.max(0, leftMargin);
+	const rm = Math.max(0, rightMargin);
+	if (lm >= cw || rm >= cw || lm + rm >= cw) return {
+		leftMargin: 0,
+		rightMargin: 0
+	};
+	return {
+		leftMargin: lm,
+		rightMargin: rm
+	};
+}
+//#endregion
+export { clampFloatingWrapMargins };