@stll/folio-core 0.7.0 → 0.9.0

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

@@ -0,0 +1,252 @@
+import czechHyphenation from "hyphen/cs/index.js";
+import britishEnglishHyphenation from "hyphen/en-gb/index.js";
+import americanEnglishHyphenation from "hyphen/en-us/index.js";
+import slovakHyphenation from "hyphen/sk/index.js";
+//#region src/layout-engine/measure/lineBreakProvider.ts
+/**
+* Replaceable line-break policy for the layout engine.
+*
+* Providers return UTF-16 offsets so their output composes directly with the
+* run and ProseMirror positions used by the rest of the layout pipeline. The
+* default provider uses the platform's Unicode segmenter, then applies the
+* OOXML line-edge restrictions that are available in the flow model.
+*/
+const { hyphenateSync: hyphenateCzech } = czechHyphenation;
+const { hyphenateSync: hyphenateBritishEnglish } = britishEnglishHyphenation;
+const { hyphenateSync: hyphenateAmericanEnglish } = americanEnglishHyphenation;
+const { hyphenateSync: hyphenateSlovak } = slovakHyphenation;
+const SEGMENTER_CACHE_LIMIT = 16;
+const DEFAULT_SEGMENTER_KEY = "";
+const SOFT_HYPHEN = "­";
+const MAX_HYPHENATION_WORD_LENGTH = 256;
+const wordSegmenters = /* @__PURE__ */ new Map();
+const graphemeSegmenters = /* @__PURE__ */ new Map();
+const segmenterLocale = (locale) => {
+	const language = locale?.trim().replaceAll("_", "-").split("-").at(0);
+	return language && /^[a-z]{2,3}$/iu.test(language) ? language.toLowerCase() : void 0;
+};
+const DICTIONARY_BREAK_SCRIPT = /[\p{Script=Thai}\p{Script=Lao}\p{Script=Khmer}\p{Script=Myanmar}]/u;
+const CJK_SCRIPT = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+const BREAK_AFTER_CHARACTER = /* @__PURE__ */ new Set([
+	"-",
+	"֊",
+	"־",
+	"᐀",
+	"᠆",
+	"‐",
+	"⸗",
+	"⹀",
+	"゠",
+	"﹣",
+	"－",
+	"​",
+	"­"
+]);
+const CZECH_ONE_LETTER_PREPOSITIONS = /* @__PURE__ */ new Set([
+	"k",
+	"o",
+	"s",
+	"u",
+	"v",
+	"z"
+]);
+const DEFAULT_PROHIBITED_LINE_START = /* @__PURE__ */ new Set([
+	"!",
+	"%",
+	")",
+	",",
+	".",
+	":",
+	";",
+	"?",
+	"]",
+	"}",
+	"、",
+	"。",
+	"〉",
+	"》",
+	"」",
+	"』",
+	"】",
+	"〕",
+	"）",
+	"］",
+	"｝",
+	"，",
+	"．",
+	"：",
+	"；",
+	"！",
+	"？",
+	"…",
+	"’",
+	"”"
+]);
+const DEFAULT_PROHIBITED_LINE_END = /* @__PURE__ */ new Set([
+	"$",
+	"(",
+	"[",
+	"{",
+	"£",
+	"¥",
+	"〈",
+	"《",
+	"「",
+	"『",
+	"【",
+	"〔",
+	"（",
+	"［",
+	"｛",
+	"‘",
+	"“"
+]);
+const getSegmenter = (cache, granularity, locale) => {
+	const normalizedLocale = segmenterLocale(locale);
+	const key = normalizedLocale ?? DEFAULT_SEGMENTER_KEY;
+	const cached = cache.get(key);
+	if (cached) return cached;
+	const segmenter = new Intl.Segmenter(normalizedLocale, { granularity });
+	if (cache.size >= SEGMENTER_CACHE_LIMIT) {
+		const oldestKey = cache.keys().next().value;
+		if (typeof oldestKey === "string") cache.delete(oldestKey);
+	}
+	cache.set(key, segmenter);
+	return segmenter;
+};
+const firstCodePoint = (text, index) => {
+	if (index >= text.length) return;
+	return String.fromCodePoint(text.codePointAt(index) ?? 0);
+};
+const previousCodePoint = (text, index) => {
+	if (index <= 0) return;
+	const trailing = text.charCodeAt(index - 1);
+	if (trailing >= 56320 && trailing <= 57343 && index >= 2) return text.slice(index - 2, index);
+	return text[index - 1];
+};
+const isProhibitedLineStart = (character, policy) => character !== void 0 && policy?.kinsoku !== false && (policy?.noLineBreaksBefore !== void 0 ? policy.noLineBreaksBefore.includes(character) : DEFAULT_PROHIBITED_LINE_START.has(character));
+const isProhibitedLineEnd = (character, policy) => character !== void 0 && policy?.kinsoku !== false && (policy?.noLineBreaksAfter !== void 0 ? policy.noLineBreaksAfter.includes(character) : DEFAULT_PROHIBITED_LINE_END.has(character));
+const isCjkLineBreakParticipant = (character, policy) => character !== void 0 && (CJK_SCRIPT.test(character) || DEFAULT_PROHIBITED_LINE_START.has(character) || DEFAULT_PROHIBITED_LINE_END.has(character) || policy?.noLineBreaksBefore?.includes(character) === true || policy?.noLineBreaksAfter?.includes(character) === true);
+const isLegacyEthiopicBreakCharacter = (character, policy) => {
+	if (!policy?.useLegacyEthiopicAmharicRules || character === void 0) return false;
+	const codePoint = character.codePointAt(0);
+	return codePoint !== void 0 && codePoint >= 4961 && codePoint <= 4968;
+};
+const czechProtectedBreaks = (text, policy) => {
+	const breaks = /* @__PURE__ */ new Set();
+	if (segmenterLocale(policy?.locale) !== "cs") return breaks;
+	let tokenStart = 0;
+	let index = 0;
+	while (index < text.length) {
+		const character = firstCodePoint(text, index);
+		if (character === void 0) break;
+		if (!/\s/u.test(character)) {
+			index += character.length;
+			continue;
+		}
+		const token = text.slice(tokenStart, index);
+		const protectsNextWord = token.length === 1 && CZECH_ONE_LETTER_PREPOSITIONS.has(token.toLocaleLowerCase("cs"));
+		while (index < text.length) {
+			const whitespace = firstCodePoint(text, index);
+			if (whitespace === void 0 || !/\s/u.test(whitespace)) break;
+			index += whitespace.length;
+			if (protectsNextWord) breaks.add(index);
+		}
+		tokenStart = index;
+	}
+	return breaks;
+};
+const allowsBreak = (text, index, policy) => {
+	const previous = previousCodePoint(text, index);
+	const next = firstCodePoint(text, index);
+	return !isProhibitedLineEnd(previous, policy) && !isProhibitedLineStart(next, policy);
+};
+const pushBreak = (breaks, text, index, policy) => {
+	if (index <= 0 || index > text.length || breaks.at(-1) === index) return;
+	if (allowsBreak(text, index, policy)) breaks.push(index);
+};
+const findUnicodeGraphemeBreaks = (text, policy) => {
+	const breaks = [];
+	for (const segment of getSegmenter(graphemeSegmenters, "grapheme", policy?.locale).segment(text)) {
+		const end = segment.index + segment.segment.length;
+		breaks.push(end);
+	}
+	return breaks;
+};
+const findUnicodeBreaks = (text, policy) => {
+	if (text.length === 0) return [];
+	const breaks = [];
+	const graphemeBreaks = findUnicodeGraphemeBreaks(text, policy);
+	for (const index of graphemeBreaks) {
+		const previous = previousCodePoint(text, index);
+		if (previous !== void 0 && (/\s/u.test(previous) || BREAK_AFTER_CHARACTER.has(previous) || isLegacyEthiopicBreakCharacter(previous, policy))) pushBreak(breaks, text, index, policy);
+	}
+	const wordSegments = [...getSegmenter(wordSegmenters, "word", policy?.locale).segment(text)];
+	for (const [segmentIndex, segment] of wordSegments.entries()) {
+		const end = segment.index + segment.segment.length;
+		const nextSegment = wordSegments[segmentIndex + 1];
+		if (segment.isWordLike && nextSegment?.isWordLike === true && DICTIONARY_BREAK_SCRIPT.test(segment.segment + nextSegment.segment)) pushBreak(breaks, text, end, policy);
+	}
+	if (CJK_SCRIPT.test(text)) for (const index of graphemeBreaks) {
+		const previous = previousCodePoint(text, index);
+		if (isCjkLineBreakParticipant(previous, policy)) pushBreak(breaks, text, index, policy);
+	}
+	const protectedBreaks = czechProtectedBreaks(text, policy);
+	return [...new Set(breaks)].filter((index) => !protectedBreaks.has(index)).sort((left, right) => left - right);
+};
+const hyphenatorFor = (locale) => {
+	const normalized = locale?.trim().replaceAll("_", "-").toLowerCase();
+	if (!normalized) return;
+	if (normalized === "en-gb" || normalized.startsWith("en-gb-")) return hyphenateBritishEnglish;
+	if (normalized === "en-us" || normalized.startsWith("en-us-")) return hyphenateAmericanEnglish;
+	if (normalized === "cs" || normalized.startsWith("cs-")) return hyphenateCzech;
+	if (normalized === "sk" || normalized.startsWith("sk-")) return hyphenateSlovak;
+};
+const isAllCapsWord = (text, locale) => {
+	const letters = [...text].filter((character) => /\p{Letter}/u.test(character)).join("");
+	if (letters.length === 0) return false;
+	const casingLocale = segmenterLocale(locale);
+	return letters === letters.toLocaleUpperCase(casingLocale) && letters !== letters.toLocaleLowerCase(casingLocale);
+};
+const findPatternHyphenationBreaks = (text, policy) => {
+	if (text.length > 256 || text.includes(SOFT_HYPHEN)) return [];
+	const hyphenate = hyphenatorFor(policy?.locale);
+	if (!hyphenate) return [];
+	if (policy?.doNotHyphenateCaps && (policy.renderedAllCaps === true || isAllCapsWord(text, policy.locale))) return [];
+	const hyphenated = hyphenate(text);
+	const breaks = [];
+	let sourceOffset = 0;
+	for (const character of hyphenated) {
+		if (character === SOFT_HYPHEN) {
+			breaks.push(sourceOffset);
+			continue;
+		}
+		sourceOffset += character.length;
+	}
+	return sourceOffset === text.length ? breaks : [];
+};
+const isDefaultHangingPunctuation = (text, policy) => {
+	const characters = [...text];
+	return characters.length > 0 && characters.every((character) => isProhibitedLineStart(character, policy));
+};
+const defaultLineBreakProvider = {
+	findBreaks: findUnicodeBreaks,
+	findGraphemeBreaks: findUnicodeGraphemeBreaks,
+	findHyphenationBreaks: findPatternHyphenationBreaks,
+	isHangingPunctuation: isDefaultHangingPunctuation
+};
+let activeLineBreakProvider = defaultLineBreakProvider;
+let lineBreakProviderGeneration = 0;
+const getLineBreakProvider = () => activeLineBreakProvider;
+/** Changes whenever the active provider changes, so layout caches cannot go stale. */
+const getLineBreakProviderGeneration = () => lineBreakProviderGeneration;
+const setLineBreakProvider = (provider) => {
+	activeLineBreakProvider = provider;
+	lineBreakProviderGeneration += 1;
+};
+const resetLineBreakProvider = () => {
+	activeLineBreakProvider = defaultLineBreakProvider;
+	lineBreakProviderGeneration += 1;
+};
+//#endregion
+export { MAX_HYPHENATION_WORD_LENGTH, defaultLineBreakProvider, getLineBreakProvider, getLineBreakProviderGeneration, resetLineBreakProvider, setLineBreakProvider };

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

@@ -1,10 +1,15 @@
+import { LineBreakPolicy } from "./lineBreakProvider.js";
+
 //#region src/layout-engine/measure/lineBreaks.d.ts
 /**
  * Indices in `text` where a line may end. Latin text breaks after
  * whitespace or hyphen; CJK text can break after every ideograph so a
  * partial line is filled instead of pushing the whole run to the next line.
  */
-declare function findWordBreaks(text: string): number[];
+declare const findWordBreaks: (text: string, policy?: LineBreakPolicy) => number[];
+declare const findGraphemeBreaks: (text: string, policy?: LineBreakPolicy) => number[];
+declare const findHyphenationBreaks: (text: string, policy?: LineBreakPolicy) => number[];
+declare const isHangingPunctuation: (text: string, policy?: LineBreakPolicy) => boolean;
 declare function isBreakChar(char: string | undefined): boolean;
 //#endregion
-export { findWordBreaks, isBreakChar };
+export { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakChar, isHangingPunctuation };

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

@@ -1,3 +1,4 @@
+import { defaultLineBreakProvider, getLineBreakProvider } from "./lineBreakProvider.js";
 import { isCjkCodePoint } from "../../utils/scriptSegments.js";
 //#region src/layout-engine/measure/lineBreaks.ts
 /**
@@ -5,26 +6,18 @@ import { isCjkCodePoint } from "../../utils/scriptSegments.js";
 * whitespace or hyphen; CJK text can break after every ideograph so a
 * partial line is filled instead of pushing the whole run to the next line.
 */
-function findWordBreaks(text) {
-	const breaks = [];
-	for (let index = 0; index < text.length;) {
-		const codePoint = text.codePointAt(index);
-		if (codePoint === void 0) break;
-		const charLength = codePoint > 65535 ? 2 : 1;
-		const char = text[index];
-		if (char === " " || char === "-" || char === "	") breaks.push(index + charLength);
-		else if (isCjkCodePoint(codePoint)) breaks.push(index + charLength);
-		index += charLength;
-	}
-	return breaks;
-}
+const findWordBreaks = (text, policy) => getLineBreakProvider().findBreaks(text, policy);
+const findGraphemeBreaks = (text, policy) => getLineBreakProvider().findGraphemeBreaks(text, policy);
+const findHyphenationBreaks = (text, policy) => getLineBreakProvider().findHyphenationBreaks?.(text, policy) ?? [];
+const isHangingPunctuation = (text, policy) => {
+	return (getLineBreakProvider().isHangingPunctuation ?? defaultLineBreakProvider.isHangingPunctuation)?.(text, policy) ?? false;
+};
 function isBreakChar(char) {
 	if (char === void 0) return false;
-	if (char === " " || char === "-" || char === "	") return true;
-	const codePoint = char.codePointAt(0);
-	if (codePoint === void 0) return false;
+	if (/\s/u.test(char) || char === "-" || char === "­" || char === "​") return true;
 	if (char >= "\udc00" && char <= "\udfff") return true;
-	return isCjkCodePoint(codePoint);
+	const codePoint = char.codePointAt(0);
+	return codePoint !== void 0 && isCjkCodePoint(codePoint);
 }
 //#endregion
-export { findWordBreaks, isBreakChar };
+export { findGraphemeBreaks, findHyphenationBreaks, findWordBreaks, isBreakChar, isHangingPunctuation };

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

@@ -16,6 +16,7 @@ declare const DEFAULT_TAB_STOP_TWIPS = 720;
 declare function resolveListMarkerFont(block: ParagraphBlock): {
   fontFamily: string;
   fontSize: number;
+  bold?: boolean;
 };
 /**
  * Compute the marker's inline-block width in pixels, or 0 if the paragraph
@@ -36,5 +37,7 @@ declare function resolveListMarkerFont(block: ParagraphBlock): {
  * grid is not erased by custom tabs, just augmented).
  */
 declare function getListMarkerInlineWidth(block: ParagraphBlock): number;
+/** Paint-only offset that places the marker around its authored list anchor. */
+declare function getListMarkerVisualOffset(block: ParagraphBlock): number;
 //#endregion
-export { DEFAULT_TAB_STOP_TWIPS, getListMarkerInlineWidth, resolveListMarkerFont };
+export { DEFAULT_TAB_STOP_TWIPS, getListMarkerInlineWidth, getListMarkerVisualOffset, resolveListMarkerFont };

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

@@ -19,9 +19,13 @@ const TWIPS_TO_PX = 96 / 1440;
 function resolveListMarkerFont(block) {
 	const attrs = block.attrs;
 	const firstTextRun = block.runs.find((r) => r.kind === "text");
+	const fontFamily = attrs?.listMarkerFontFamily ?? firstTextRun?.fontFamily ?? attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY;
+	const fontSize = attrs?.listMarkerFontSize ?? firstTextRun?.fontSize ?? attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE;
+	const bold = attrs?.listMarkerBold ?? firstTextRun?.bold;
 	return {
-		fontFamily: attrs?.listMarkerFontFamily ?? firstTextRun?.fontFamily ?? attrs?.defaultFontFamily ?? DEFAULT_FONT_FAMILY,
-		fontSize: attrs?.listMarkerFontSize ?? firstTextRun?.fontSize ?? attrs?.defaultFontSize ?? DEFAULT_FONT_SIZE
+		fontFamily,
+		fontSize,
+		...bold !== void 0 ? { bold } : {}
 	};
 }
 /**
@@ -45,21 +49,23 @@ function resolveListMarkerFont(block) {
 function getListMarkerInlineWidth(block) {
 	const attrs = block.attrs;
 	if (!attrs?.listMarker || attrs.listMarkerHidden) return 0;
-	const { fontFamily, fontSize } = resolveListMarkerFont(block);
+	const { fontFamily, fontSize, bold } = resolveListMarkerFont(block);
 	const style = {
 		fontFamily,
-		fontSize
+		fontSize,
+		...bold !== void 0 ? { bold } : {}
 	};
 	const naturalWidth = measureTextWidth(attrs.listMarker, style);
+	const markerEndOffset = getMarkerEndOffset(naturalWidth, attrs.listMarkerAlignment);
 	const suffix = attrs.listMarkerSuffix ?? "tab";
-	if (suffix === "nothing") return naturalWidth;
-	if (suffix === "space") return naturalWidth + measureTextWidth(" ", style);
+	if (suffix === "nothing") return markerEndOffset;
+	if (suffix === "space") return markerEndOffset + measureTextWidth(" ", style);
 	const indent = attrs.indent;
 	const indentLeft = indent?.left ?? 0;
 	const firstLine = indent?.firstLine ?? 0;
 	const hanging = indent?.hanging ?? 0;
 	const markerStartPx = hanging > 0 ? indentLeft - hanging : indentLeft + firstLine;
-	const minBodyStart = markerStartPx + naturalWidth;
+	const minBodyStart = markerStartPx + markerEndOffset;
 	const customTabs = (attrs.tabs ?? []).filter((t) => t.val !== "clear" && t.val !== "bar").map((t) => t.pos * TWIPS_TO_PX);
 	if (hanging > 0) customTabs.push(indentLeft);
 	const searchStart = hanging > 0 ? Math.max(minBodyStart, indentLeft) : minBodyStart;
@@ -72,5 +78,24 @@ function getListMarkerInlineWidth(block) {
 	if (bodyStart === void 0) return naturalWidth + ptToPx(fontSize) * .5;
 	return bodyStart - markerStartPx;
 }
+/** Paint-only offset that places the marker around its authored list anchor. */
+function getListMarkerVisualOffset(block) {
+	const attrs = block.attrs;
+	if (!attrs?.listMarker || attrs.listMarkerHidden) return 0;
+	const { fontFamily, fontSize, bold } = resolveListMarkerFont(block);
+	const naturalWidth = measureTextWidth(attrs.listMarker, {
+		fontFamily,
+		fontSize,
+		...bold !== void 0 ? { bold } : {}
+	});
+	if (attrs.listMarkerAlignment === "right") return -naturalWidth;
+	if (attrs.listMarkerAlignment === "center") return -naturalWidth / 2;
+	return 0;
+}
+const getMarkerEndOffset = (naturalWidth, alignment) => {
+	if (alignment === "right") return 0;
+	if (alignment === "center") return naturalWidth / 2;
+	return naturalWidth;
+};
 //#endregion
-export { DEFAULT_TAB_STOP_TWIPS, getListMarkerInlineWidth, resolveListMarkerFont };
+export { DEFAULT_TAB_STOP_TWIPS, getListMarkerInlineWidth, getListMarkerVisualOffset, resolveListMarkerFont };

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

@@ -1,10 +1,12 @@
 import { FlowBlock, Measure, TableBlock, TableMeasure, TextBoxBlock, TextBoxMeasure } from "../types.js";
 import { FloatingImageZone } from "./floatingZones.js";
 //#region src/layout-engine/measure/measureBlocks.d.ts
-declare function measureTableCellBlockVisualHeight(block: FlowBlock, blockMeasure: Measure): number;
 declare function measureTableBlock(tableBlock: TableBlock, contentWidth: number, fieldValues?: ReadonlyMap<number, string>): TableMeasure;
 type BandPageGeometry = {
+  pageWidth?: number | number[];
   pageHeight: number | number[];
+  marginLeft?: number | number[];
+  marginRight?: number | number[];
   marginBottom: number | number[];
 };
 /**
@@ -22,4 +24,4 @@ declare function measureTextBoxBlock(tb: TextBoxBlock, fieldValues?: ReadonlyMap
 declare function measureBlocks(blocks: FlowBlock[], contentWidth: number | number[], marginTop?: number | number[], pageGeometry?: BandPageGeometry, fieldValues?: ReadonlyMap<number, string>): Measure[];
 declare function measureSingleBlockWithoutFloatingZones(block: FlowBlock, blockWidth: number, blockIndex: number): Measure;
 //#endregion
-export { measureBlock, measureBlocks, measureSingleBlockWithoutFloatingZones, measureTableBlock, measureTableCellBlockVisualHeight, measureTextBoxBlock };
+export { measureBlock, measureBlocks, measureSingleBlockWithoutFloatingZones, measureTableBlock, measureTextBoxBlock };