@stll/folio-core 0.49.0 → 0.51.0

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

@@ -0,0 +1,44 @@
+import { ParagraphAttrs, ParagraphSpacing, TextRun } from "../types.js";
+import { FontMetrics, FontStyle } from "./measureTypes.js";
+import { LineTypography } from "./paragraphMeasureShared.js";
+//#region src/layout-engine/measure/lineTypography.d.ts
+/**
+ * Line-HEIGHT style for a text run. Word derives a CJK line's height from an
+ * East-Asian face, not the run's ascii font: real documents routinely put CJK
+ * glyphs in runs whose ascii/eastAsia fonts are Latin (e.g. `w:eastAsia`
+ * "Century"), and Word font-links those glyphs to the default East-Asian face
+ * and uses its taller single-line height (≈1.303 vs the ≈1.15 Latin default).
+ *
+ * When the run holds CJK text, swap `fontFamily` to the face whose
+ * `singleLineRatio` Word would actually use: the run's `w:eastAsia` font when
+ * it is a real CJK face, the run's own ascii font when THAT is a CJK face, or
+ * `CJK_FALLBACK_FONT_FAMILY` otherwise. Non-CJK runs return `baseStyle`
+ * unchanged, so Latin-only documents are unaffected by construction.
+ *
+ * The result feeds `updateMaxFont` (line height) ONLY — width measurement
+ * keeps the base style so wrapping is untouched.
+ */
+declare function cjkLineHeightStyle(run: TextRun, baseStyle: FontStyle): FontStyle;
+/** Pick the dominant typography metrics for a run containing complex script. */
+declare function complexScriptLineHeightStyle(run: TextRun, baseStyle: FontStyle): FontStyle;
+/**
+ * Calculate typography metrics from font size and spacing settings
+ *
+ * @param fontSize - Font size in points
+ * @param spacing - Paragraph spacing settings
+ * @param metrics - Pre-calculated font metrics (in pixels)
+ */
+declare function calculateTypographyMetrics(fontSize: number, spacing?: ParagraphSpacing, metrics?: FontMetrics | null): LineTypography;
+/**
+ * Calculate metrics for an empty paragraph.
+ *
+ * Word renders an empty paragraph as a single readable line — its line
+ * height never collapses below 1.15 × font size, even when the doc
+ * explicitly writes `<w:line w:val="240"/>` (1.0×). The floor is scoped to
+ * `auto`/`atLeast` line rules; `exact` means exact (per OOXML §17.3.1.33)
+ * and stays untouched.
+ */
+declare function calculateEmptyParagraphMetrics(fontSize: number, spacing?: ParagraphSpacing, fontFamily?: string, attrs?: ParagraphAttrs): LineTypography;
+declare function applyDocumentGrid(typography: LineTypography, attrs: ParagraphAttrs | undefined, spacing: ParagraphSpacing | undefined): LineTypography;
+//#endregion
+export { applyDocumentGrid, calculateEmptyParagraphMetrics, calculateTypographyMetrics, cjkLineHeightStyle, complexScriptLineHeightStyle };

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

@@ -0,0 +1,124 @@
+import { CJK_FALLBACK_FONT_FAMILY, isCjkFont } from "../../utils/fontResolver.js";
+import { hasCjk, hasComplexScript, hasEastAsiaSlotText } from "../../utils/scriptSegments.js";
+import { applyComplexScriptFormatting, hasComplexScriptFormatting } from "./complexScriptFormatting.js";
+import { ptToPx } from "./measureHelpers.js";
+import { getFontMetrics } from "./measureProvider.js";
+import "./paragraphMeasureShared.js";
+//#region src/layout-engine/measure/lineTypography.ts
+/**
+* Line height and typography metrics: font-driven line heights, East Asian
+* and complex-script line height styles, empty-paragraph metrics, and
+* document-grid line pitch.
+*/
+/**
+* Line-HEIGHT style for a text run. Word derives a CJK line's height from an
+* East-Asian face, not the run's ascii font: real documents routinely put CJK
+* glyphs in runs whose ascii/eastAsia fonts are Latin (e.g. `w:eastAsia`
+* "Century"), and Word font-links those glyphs to the default East-Asian face
+* and uses its taller single-line height (≈1.303 vs the ≈1.15 Latin default).
+*
+* When the run holds CJK text, swap `fontFamily` to the face whose
+* `singleLineRatio` Word would actually use: the run's `w:eastAsia` font when
+* it is a real CJK face, the run's own ascii font when THAT is a CJK face, or
+* `CJK_FALLBACK_FONT_FAMILY` otherwise. Non-CJK runs return `baseStyle`
+* unchanged, so Latin-only documents are unaffected by construction.
+*
+* The result feeds `updateMaxFont` (line height) ONLY — width measurement
+* keeps the base style so wrapping is untouched.
+*/
+function cjkLineHeightStyle(run, baseStyle) {
+	if (!run.text) return baseStyle;
+	const eastAsia = baseStyle.eastAsiaFontFamily;
+	const eastAsiaFace = eastAsia !== void 0 && isCjkFont(eastAsia);
+	if (!hasCjk(run.text) && !(eastAsiaFace && hasEastAsiaSlotText(run.text, baseStyle.eastAsiaHint))) return baseStyle;
+	if (eastAsia !== void 0 && eastAsiaFace) {
+		const result = {
+			...baseStyle,
+			fontFamily: eastAsia
+		};
+		delete result.alternateFontFamily;
+		if (baseStyle.eastAsiaAlternateFontFamily !== void 0) result.alternateFontFamily = baseStyle.eastAsiaAlternateFontFamily;
+		return result;
+	}
+	if (isCjkFont(baseStyle.fontFamily ?? "Times New Roman")) return baseStyle;
+	return {
+		...baseStyle,
+		fontFamily: CJK_FALLBACK_FONT_FAMILY
+	};
+}
+/** Pick the dominant typography metrics for a run containing complex script. */
+function complexScriptLineHeightStyle(run, baseStyle) {
+	if (!hasComplexScriptFormatting(run) || !run.forceComplexScript && !hasComplexScript(run.text)) return baseStyle;
+	const complexStyle = applyComplexScriptFormatting(baseStyle, run);
+	return (complexStyle.fontSize ?? 11) >= (baseStyle.fontSize ?? 11) ? complexStyle : baseStyle;
+}
+/**
+* Calculate typography metrics from font size and spacing settings
+*
+* @param fontSize - Font size in points
+* @param spacing - Paragraph spacing settings
+* @param metrics - Pre-calculated font metrics (in pixels)
+*/
+function calculateTypographyMetrics(fontSize, spacing, metrics) {
+	const fontSizePx = ptToPx(fontSize);
+	const ascent = metrics?.ascent ?? fontSizePx * .8;
+	const descent = metrics?.descent ?? fontSizePx * .2;
+	const singleLineBase = fontSizePx * (metrics?.singleLineRatio ?? 1.15);
+	let lineHeight;
+	if (spacing?.lineRule === "exact" && spacing.line !== void 0) lineHeight = spacing.line;
+	else if (spacing?.lineRule === "atLeast" && spacing.line !== void 0) {
+		const defaultHeight = singleLineBase * 1;
+		lineHeight = Math.max(spacing.line, defaultHeight);
+	} else if (spacing?.line !== void 0 && spacing.lineUnit === "multiplier") lineHeight = singleLineBase * spacing.line;
+	else if (spacing?.line !== void 0 && spacing.lineUnit === "px") lineHeight = spacing.line;
+	else lineHeight = singleLineBase * 1;
+	return {
+		ascent,
+		descent,
+		lineHeight
+	};
+}
+/**
+* Word's "single line spacing" floor (≈ 1.15×) applied to empty paragraphs
+* with `auto`/`atLeast` line rules. Without this, narrow-metric fonts
+* (Arial Narrow, OS/2 ratio ≈ 1.117) collapse empty rows visibly tighter
+* than Word renders them. See eigenpal #391/#394.
+*/
+const WORD_SINGLE_LINE_FLOOR = 1.15;
+/**
+* Calculate metrics for an empty paragraph.
+*
+* Word renders an empty paragraph as a single readable line — its line
+* height never collapses below 1.15 × font size, even when the doc
+* explicitly writes `<w:line w:val="240"/>` (1.0×). The floor is scoped to
+* `auto`/`atLeast` line rules; `exact` means exact (per OOXML §17.3.1.33)
+* and stays untouched.
+*/
+function calculateEmptyParagraphMetrics(fontSize, spacing, fontFamily, attrs) {
+	const result = calculateTypographyMetrics(fontSize, spacing, getFontMetrics({
+		fontSize,
+		fontFamily: fontFamily ?? "Times New Roman",
+		...attrs?.defaultAlternateFontFamily !== void 0 ? { alternateFontFamily: attrs.defaultAlternateFontFamily } : {}
+	}));
+	const lineRule = spacing?.lineRule ?? "auto";
+	if (lineRule === "auto" || lineRule === "atLeast") {
+		const floor = ptToPx(fontSize) * WORD_SINGLE_LINE_FLOOR;
+		if (result.lineHeight < floor) return applyDocumentGrid({
+			...result,
+			lineHeight: floor
+		}, attrs, spacing);
+	}
+	return applyDocumentGrid(result, attrs, spacing);
+}
+function applyDocumentGrid(typography, attrs, spacing) {
+	const pitch = attrs?.documentGridLinePitch;
+	if (pitch === void 0 || pitch <= 0 || attrs?.snapToGrid === false) return typography;
+	if (spacing?.lineRule === "exact") return typography;
+	const lineHeight = Math.ceil(typography.lineHeight / pitch - 1e-9) * pitch;
+	return lineHeight === typography.lineHeight ? typography : {
+		...typography,
+		lineHeight
+	};
+}
+//#endregion
+export { applyDocumentGrid, calculateEmptyParagraphMetrics, calculateTypographyMetrics, cjkLineHeightStyle, complexScriptLineHeightStyle };

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

@@ -7,9 +7,10 @@ import { bandFragmentX, bandTopContentY, isPageFrameRelativeAnchor } from "../te
 import { getTextBoxGroupId } from "../textBoxGroup.js";
 import { DEFAULT_TEXTBOX_MARGINS, floatingTextBoxReservesBand, floatingTextBoxWrapsText, resolveTableCellPadding, resolveTableWidthPx, tableColumnsArePinned } from "../types.js";
 import { getCachedParagraphMeasure, setCachedParagraphMeasure } from "./cache.js";
+import { findClearLineY } from "./floatingLineClearance.js";
 import { resolveFloatingTablePageX } from "./floatingTablePosition.js";
 import { getHyphenationDictionaryMisses } from "./hyphenationDictionaries.js";
-import { findClearLineY, measureParagraph } from "./measureParagraph.js";
+import { measureParagraph } from "./measureParagraph.js";
 import { buildTableCellFloatingZones, getTableCellFloatingImages } from "./tableCellFloating.js";
 import { createTableCellFlowState, finishTableCellFlow, placeTableCellBlock } from "./tableCellFlow.js";
 import { buildTableCellGrid, getFirstAvailableColumn, getTableCellSpacingInsetsX, getTableCellSpacingInsetsY, getTableCellVerticalBorderHeight } from "./tableCellGrid.js";

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

@@ -1,6 +1,7 @@
 import { ParagraphBlock, ParagraphMeasure, TextRun } from "../types.js";
 import { FloatingImageZone } from "./floatingZones.js";
 import { clampFloatingWrapMargins } from "./clampFloatingWrapMargins.js";
+import { MIN_WRAP_SEGMENT_WIDTH, findClearLineY } from "./floatingLineClearance.js";
 //#region src/layout-engine/measure/measureParagraph.d.ts
 /**
  * Options for paragraph measurement
@@ -16,26 +17,6 @@ type MeasureParagraphOptions = {
   /** Header/footer tabs may be authored in the page margin, beyond body width. */
   allowEndTabOverflow?: boolean;
 };
-/**
- * Minimum horizontal room a line must offer before we treat it as usable for
- * body text. Below this threshold the line is bumped past obstructing floats
- * via `findClearLineY` instead of being rendered into the unusable sliver.
- * Without this guard, a near-full-width float (e.g. floating table) produces
- * a ~2px segment that collapses every wrap line to one glyph per row.
- */
-declare const MIN_WRAP_SEGMENT_WIDTH = 24;
-/**
- * Find the next vertical position at or below `startY` where the available
- * text width is at least `minWidth`. Used to skip lines past stacked floats
- * when there is no horizontal room for meaningful text at the current Y.
- *
- * Returns `startY` if the current position already has enough room, otherwise
- * the lowest `bottomY` of any zone currently obstructing the line. The caller
- * is expected to re-query margins at the returned Y.
- *
- * Coordinates are absolute (i.e., already include any paragraphYOffset).
- */
-declare function findClearLineY(startY: number, lineHeight: number, zones: FloatingImageZone[] | undefined, contentWidth: number, minWidth: number): number;
 /**
  * Measure a paragraph block and compute line breaks
  *