@stll/folio-core 0.47.7 → 0.48.0

package/dist/utils/scriptSegments.js

@@ -52,9 +52,32 @@ function hasCjk(text) {
 function isComplexScriptCodePoint(cp) {
 	return cp >= 1424 && cp <= 1535 || cp >= 1536 && cp <= 1791 || cp >= 1792 && cp <= 1871 || cp >= 1872 && cp <= 1919 || cp >= 1920 && cp <= 1983 || cp >= 1984 && cp <= 2047 || cp >= 2048 && cp <= 2111 || cp >= 2112 && cp <= 2143 || cp >= 2144 && cp <= 2159 || cp >= 2160 && cp <= 2207 || cp >= 2208 && cp <= 2303 || cp >= 2304 && cp <= 3455 || cp >= 3456 && cp <= 3583 || cp >= 3584 && cp <= 3711 || cp >= 3712 && cp <= 3839 || cp >= 3840 && cp <= 4095 || cp >= 4096 && cp <= 4255 || cp >= 6016 && cp <= 6143 || cp >= 64285 && cp <= 64335 || cp >= 64336 && cp <= 65023 || cp >= 65136 && cp <= 65279 || cp >= 68864 && cp <= 68927 || cp >= 69312 && cp <= 69375 || cp >= 69424 && cp <= 69487 || cp >= 69488 && cp <= 69551 || cp >= 125184 && cp <= 125279 || cp >= 126464 && cp <= 126719;
 }
-/** Which font slot a single code point selects. CJK wins where ranges meet. */
-function scriptClassOf(cp) {
-	if (isCjkCodePoint(cp)) return SCRIPT_CLASS.eastAsia;
+/**
+* True when `w:rFonts/@w:hint="eastAsia"` moves a code point from the
+* `w:hAnsi` slot to the `w:eastAsia` slot (ECMA-376 §17.3.2.26): the ranges
+* the font-slot table resolves to the East Asian font whenever the hint is
+* `eastAsia`. Basic Latin never moves, and neither do the accented letters of
+* Latin-1 Supplement and the Latin Extended blocks, whose move the table also
+* conditions on the run's East Asian language.
+*/
+function isEastAsiaHintCodePoint(cp) {
+	return cp === 161 || cp === 164 || cp === 167 || cp === 168 || cp === 170 || cp === 173 || cp === 175 || cp >= 176 && cp <= 180 || cp >= 182 && cp <= 186 || cp >= 188 && cp <= 191 || cp === 215 || cp === 247 || cp >= 688 && cp <= 879 || cp >= 880 && cp <= 1023 || cp >= 1024 && cp <= 1279 || cp >= 8192 && cp <= 10175 || cp >= 57344 && cp <= 63743 || cp >= 64256 && cp <= 64284;
+}
+/**
+* Whether a run's `w:hint="eastAsia"` takes effect. A run under `w:cs` or
+* `w:rtl` formats every character with the complex-script slot, which the
+* hint does not override.
+*/
+function eastAsiaHintApplies(run) {
+	return run.eastAsiaHint === true && run.forceComplexScript !== true && run.rtl !== true;
+}
+/**
+* Which font slot a single code point selects. CJK wins where ranges meet.
+* `eastAsiaHint` is the run's effective `w:hint="eastAsia"`
+* (see {@link eastAsiaHintApplies}).
+*/
+function scriptClassOf(cp, eastAsiaHint = false) {
+	if (isCjkCodePoint(cp) || eastAsiaHint && isEastAsiaHintCodePoint(cp)) return SCRIPT_CLASS.eastAsia;
 	if (isComplexScriptCodePoint(cp)) return SCRIPT_CLASS.complex;
 	return SCRIPT_CLASS.western;
 }
@@ -83,16 +106,26 @@ function hasComplexScript(text) {
 	return false;
 }
 /**
+* True when some code point of the text selects the `w:eastAsia` slot: a CJK
+* code point, or under an effective `w:hint="eastAsia"` one the hint moves.
+*/
+function hasEastAsiaSlotText(text, eastAsiaHint = false) {
+	if (!eastAsiaHint) return hasCjk(text);
+	for (const ch of text) if (scriptClassOf(ch.codePointAt(0), true) === SCRIPT_CLASS.eastAsia) return true;
+	return false;
+}
+/**
 * Split text into maximal runs of one script class (CJK vs. non-CJK). Iterates
 * by code point so astral ideographs (surrogate pairs) are never split between
 * fonts. Empty input yields no segments; single-class input yields one.
+* `eastAsiaHint` is the run's effective `w:hint="eastAsia"`.
 */
-function segmentByScript(text) {
+function segmentByScript(text, eastAsiaHint = false) {
 	const segments = [];
 	let current = "";
 	let currentScript = SCRIPT_CLASS.western;
 	for (const ch of text) {
-		const script = scriptClassOf(ch.codePointAt(0));
+		const script = scriptClassOf(ch.codePointAt(0), eastAsiaHint);
 		if (current.length === 0) {
 			current = ch;
 			currentScript = script;
@@ -116,4 +149,4 @@ function segmentByScript(text) {
 	return segments;
 }
 //#endregion
-export { SCRIPT_CLASS, hasCjk, hasComplexScript, hasRightToLeft, isCjkCodePoint, isComplexScriptCodePoint, isRightToLeftCodePoint, scriptClassOf, segmentByScript };
+export { SCRIPT_CLASS, eastAsiaHintApplies, hasCjk, hasComplexScript, hasEastAsiaSlotText, hasRightToLeft, isCjkCodePoint, isComplexScriptCodePoint, isEastAsiaHintCodePoint, isRightToLeftCodePoint, scriptClassOf, segmentByScript };

package/dist/utils/textFormattingMerge.d.ts

@@ -2,10 +2,24 @@ import { document_d_exports } from "../types/document.js";
 //#region src/utils/textFormattingMerge.d.ts
 declare const STYLE_TOGGLE_KEYS: readonly ["bold", "boldCs", "italic", "italicCs", "allCaps", "emboss", "imprint", "outline", "shadow", "smallCaps", "strike", "hidden"];
 /**
- * Merge the properties exposed by one resolved style definition.
+ * Merge one style's own run-formatting declarations onto its already-resolved
+ * `w:basedOn` ancestor.
  *
- * A false toggle at a child style level does not cancel the inherited state. The
- * ordinary merge remains unchanged for direct formatting and non-toggle properties.
+ * ECMA-376 §17.7.3 resolves a toggle property (bold, italic, allCaps, ...) for a
+ * single style tier by walking the `basedOn` chain from the style itself towards
+ * its root: read the value the style declares; if it declares none, move to the
+ * parent and repeat. The first value found — whether an explicit "on" or an
+ * explicit "off" — is that tier's value, and it is *not* combined with whatever
+ * a weaker ancestor further up the chain happened to say. A style's own
+ * `<w:b w:val="0"/>` therefore turns bold off outright, even when its base style
+ * is bold; it does not defer to the base.
+ *
+ * That is exactly last-defined-wins, i.e. `mergeTextFormatting`'s existing
+ * behaviour for every other property. The toggle behaviour §17.7.3 is actually
+ * known for — combining a table style's, a paragraph style's and a character
+ * style's resolved values by Boolean XOR — combines the *outputs* of separate
+ * `basedOn` walks like this one; it is not part of resolving a single walk, so
+ * it has no place in this function.
  */
 declare function mergeStyleTextFormatting(target: document_d_exports.TextFormatting | undefined, source: document_d_exports.TextFormatting | undefined): document_d_exports.TextFormatting | undefined;
 declare function mergeTextFormatting(target: document_d_exports.TextFormatting | undefined, source: document_d_exports.TextFormatting | undefined): document_d_exports.TextFormatting | undefined;

package/dist/utils/textFormattingMerge.js

@@ -15,21 +15,27 @@ const STYLE_TOGGLE_KEYS = [
 	"hidden"
 ];
 /**
-* Merge the properties exposed by one resolved style definition.
+* Merge one style's own run-formatting declarations onto its already-resolved
+* `w:basedOn` ancestor.
 *
-* A false toggle at a child style level does not cancel the inherited state. The
-* ordinary merge remains unchanged for direct formatting and non-toggle properties.
+* ECMA-376 §17.7.3 resolves a toggle property (bold, italic, allCaps, ...) for a
+* single style tier by walking the `basedOn` chain from the style itself towards
+* its root: read the value the style declares; if it declares none, move to the
+* parent and repeat. The first value found — whether an explicit "on" or an
+* explicit "off" — is that tier's value, and it is *not* combined with whatever
+* a weaker ancestor further up the chain happened to say. A style's own
+* `<w:b w:val="0"/>` therefore turns bold off outright, even when its base style
+* is bold; it does not defer to the base.
+*
+* That is exactly last-defined-wins, i.e. `mergeTextFormatting`'s existing
+* behaviour for every other property. The toggle behaviour §17.7.3 is actually
+* known for — combining a table style's, a paragraph style's and a character
+* style's resolved values by Boolean XOR — combines the *outputs* of separate
+* `basedOn` walks like this one; it is not part of resolving a single walk, so
+* it has no place in this function.
 */
 function mergeStyleTextFormatting(target, source) {
-	const result = mergeTextFormatting(target, source);
-	if (!result || !source) return result;
-	for (const key of STYLE_TOGGLE_KEYS) {
-		if (source[key] !== false) continue;
-		const inherited = target?.[key];
-		if (inherited === void 0) Reflect.deleteProperty(result, key);
-		else result[key] = inherited;
-	}
-	return result;
+	return mergeTextFormatting(target, source);
 }
 /**
 * A merge answers "what does this text look like once the style, the paragraph

package/dist/utils/trailingText.d.ts

@@ -0,0 +1,22 @@
+//#region src/utils/trailingText.d.ts
+/**
+ * Linear scans over the end of a text run. Layout calls these on every
+ * measure and paint pass, and run text can be arbitrarily long, so they
+ * must not backtrack the way an end-anchored regular expression does.
+ */
+/** Index where the trailing run of U+0020 spaces begins; `text.length` when there is none. */
+declare function trailingSpaceStart(text: string): number;
+type TrailingToken = {
+  /** Last run of non-whitespace characters. */
+  token: string;
+  /** Whitespace after the token, up to the end of the text. */
+  separator: string;
+};
+/**
+ * Split off the last whitespace-delimited token and the whitespace that
+ * follows it, or return undefined when the text has no non-whitespace
+ * character.
+ */
+declare function splitTrailingToken(text: string): TrailingToken | undefined;
+//#endregion
+export { TrailingToken, splitTrailingToken, trailingSpaceStart };

package/dist/utils/trailingText.js

@@ -0,0 +1,32 @@
+//#region src/utils/trailingText.ts
+/**
+* Linear scans over the end of a text run. Layout calls these on every
+* measure and paint pass, and run text can be arbitrarily long, so they
+* must not backtrack the way an end-anchored regular expression does.
+*/
+const WHITESPACE = /\s/u;
+const isWhitespaceUnit = (text, index) => WHITESPACE.test(text.charAt(index));
+/** Index where the trailing run of U+0020 spaces begins; `text.length` when there is none. */
+function trailingSpaceStart(text) {
+	let start = text.length;
+	while (start > 0 && text.charCodeAt(start - 1) === 32) start--;
+	return start;
+}
+/**
+* Split off the last whitespace-delimited token and the whitespace that
+* follows it, or return undefined when the text has no non-whitespace
+* character.
+*/
+function splitTrailingToken(text) {
+	let tokenEnd = text.length;
+	while (tokenEnd > 0 && isWhitespaceUnit(text, tokenEnd - 1)) tokenEnd--;
+	if (tokenEnd === 0) return;
+	let tokenStart = tokenEnd;
+	while (tokenStart > 0 && !isWhitespaceUnit(text, tokenStart - 1)) tokenStart--;
+	return {
+		token: text.slice(tokenStart, tokenEnd),
+		separator: text.slice(tokenEnd)
+	};
+}
+//#endregion
+export { splitTrailingToken, trailingSpaceStart };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/folio-core",
-  "version": "0.47.7",
+  "version": "0.48.0",
   "description": "Headless, framework-neutral core of folio: the OOXML (.docx) parser, document model, ProseMirror integration, and page-layout engine. No React.",
   "keywords": [
     "document-model",
@@ -128,7 +128,7 @@
     "perf": "bun scripts/profile-editor.ts"
   },
   "dependencies": {
-    "@stll/docx-core": "^0.25.3",
+    "@stll/docx-core": "^0.26.0",
     "@stll/docx-utils": "^0.1.0",
     "@stll/template-conditions": ">=0.4.0 <1.0.0",
     "better-result": "3.0.1",