ntk 8.12.7 → 8.12.8

package/lib/fontconfig.js

@@ -16,6 +16,40 @@ function execFileSync(...args) {
   return cp.execFileSync(...args);
 }
 
+let fcMatchFound = null;
+
+/**
+ * fc-match's path, looked up once per PATH. Spawned by its bare name, the
+ * system searches PATH for it, and on macOS that is `posix_spawnp`, which
+ * attempts a spawn in every directory ahead of the one that has it: with
+ * fc-match seventh on a developer's PATH, each spawn took 45 ms where the
+ * path itself takes 15 — and the synchronous ones stall the first text
+ * layout. A directory search here is a few stats. Not found, the bare name
+ * is spawned as before, so a missing fontconfig reports exactly as it did.
+ */
+export function fcMatchFile() {
+  const p = globalThis.process;
+  const path = p?.env?.PATH ?? '';
+  if (fcMatchFound !== null && fcMatchFound.path === path) return fcMatchFound.file;
+  let file = 'fc-match';
+  const fs = p?.platform === 'win32' ? undefined : builtin('node:fs');
+  if (fs) {
+    for (const dir of path.split(':')) {
+      const candidate = `${dir || '.'}/fc-match`;
+      try {
+        if (!fs.statSync(candidate).isFile()) continue;
+        fs.accessSync(candidate, fs.constants.X_OK);
+        file = candidate;
+        break;
+      } catch {
+        // not here, or not ours to run: the next directory
+      }
+    }
+  }
+  fcMatchFound = { path, file };
+  return file;
+}
+
 const DOCS = 'https://github.com/sidorares/ntk/blob/master/docs/fonts.md#environments-without-fontconfig';
 
 /**
@@ -279,7 +313,7 @@ function runFcMatch(fc) {
 
   const entry = { promise: null, base: null };
   entry.promise = new Promise((resolve, reject) => {
-    cp.execFile('fc-match', [...fcMatchArgs, fc], fcMatchOpts, (err, out, stderr) => {
+    cp.execFile(fcMatchFile(), [...fcMatchArgs, fc], fcMatchOpts, (err, out, stderr) => {
       if (inflight.get(fc) === entry) inflight.delete(fc);
       if (!err) return resolve(out);
       // execFile hands stderr to the callback; execFileSync hangs it on the
@@ -576,7 +610,7 @@ export function matchSortedSync(pattern) {
   }
   let out;
   try {
-    out = execFileSync('fc-match', [...fcMatchArgs, fc], fcMatchOpts);
+    out = execFileSync(fcMatchFile(), [...fcMatchArgs, fc], fcMatchOpts);
   } catch (err) {
     throw fcMatchError(err);
   }

package/lib/text/fontmanager.js

@@ -182,6 +182,27 @@ function instantiate(font, weight, variations, opticalSize) {
  * fontconfig, e.g. a StaticFontSource in a browser bundle. `source` also
  * takes a font spec: a path, a directory of faces, or font bytes.
  */
+/** A CSS family list's names, unquoted. */
+function familiesOf(family) {
+  return String(family)
+    .split(',')
+    .map((f) => f.trim().replace(/^["']|["']$/g, ''))
+    .filter(Boolean);
+}
+
+/**
+ * The pattern a family and face are matched with — one spelling for both
+ * `match` and `fallbackFor`, since a source caches its lists by pattern and
+ * the two ask about the same face.
+ */
+function patternOf(family, weight, italic) {
+  return {
+    family: familiesOf(family).join(','),
+    weight,
+    style: italic ? 'italic' : 'normal'
+  };
+}
+
 export default class FontManager {
   constructor({ source } = {}) {
     // coerced here rather than in the getter, which is on the match path;
@@ -304,10 +325,7 @@ export default class FontManager {
       return instantiate(face, weight, opts.variations, opticalSizeFor(opts));
     }
 
-    const families = String(family)
-      .split(',')
-      .map((f) => f.trim().replace(/^["']|["']$/g, ''))
-      .filter(Boolean);
+    const families = familiesOf(family);
 
     face = this._matchRegistered(
       families.map((f) => f.toLowerCase()),
@@ -316,11 +334,7 @@ export default class FontManager {
     );
     if (!face) {
       // sources understand comma-separated family lists natively
-      const candidates = this.source.matchSorted({
-        family: families.join(','),
-        weight,
-        style: italic ? 'italic' : 'normal'
-      });
+      const candidates = this.source.matchSorted(patternOf(family, weight, italic));
       face = this._open(candidates[0]);
     }
     this._matches.set(cacheKey, face);
@@ -369,7 +383,12 @@ export default class FontManager {
       const source = this.source;
       let candidates;
       try {
-        candidates = source.matchSorted({ family, weight: opts.weight, style: opts.style });
+        // The pattern `match` asks for this family and face, so the list the
+        // match or a prewarm already fetched answers: asked with the span's
+        // raw weight — undefined for regular text — it was another pattern,
+        // and the first character to need a fallback waited on a fc-match
+        // of its own.
+        candidates = source.matchSorted(patternOf(family, numWeight(opts.weight), !!opts.style?.includes('italic')));
       } catch (err) {
         // no system fonts to fall back to is an answer, not a crash; a source
         // that failed for any other reason is a real bug and still propagates

package/lib/text/layout.js

@@ -3,6 +3,7 @@ import LineBreaker from 'linebreak';
 import { rasterizePolys } from '../rasterize.js';
 import { drawGlyphRuns } from './glyphs.js';
 import { embeddingLevels, normalizedLevels, reorderRuns } from './shape.js';
+import { worthKeeping } from './paragraphs.js';
 
 const WS = new Set([0x20, 0x09, 0xa0]);
 const HARD_BREAKS = /[\n\r\u2028\u2029]+$/;
@@ -55,7 +56,9 @@ export class TextLayout {
     // Everything up to the line fill is the same at every width, and a
     // font manager keeps it (text/paragraphs.js): a relayout at a new width
     // starts at the fill.
-    const kept = fonts._paragraphs;
+    // A short text skips it (`PARAGRAPH_MIN_CHARS`): a label is cheap to
+    // prepare and seldom laid out at another width.
+    const kept = worthKeeping(content) ? fonts._paragraphs : undefined;
     const key = kept ? kept.keyOf(content) : null;
     let paragraph = kept?.find(key, options.direction, content, style);
     if (!paragraph) {

package/lib/text/paragraphs.js

@@ -21,6 +21,29 @@
 /** How many characters of paragraphs a generation holds. */
 export const PARAGRAPH_GENERATION = 1 << 19;
 
+/**
+ * The shortest paragraph worth keeping, in code units. Shorter text does not
+ * ask the cache at all: a label's preparation is a few microseconds and the
+ * lookup and copies about one of them, while a label is seldom laid out at
+ * a second width. Kept, a UI's labels mounted a quarter slower and a ticking
+ * counter redrew a quarter slower, to save nothing; the paragraphs a resize
+ * lays out again are a document's, and those are longer than this.
+ */
+export const PARAGRAPH_MIN_CHARS = 64;
+
+/** Whether `content` is long enough to keep (`PARAGRAPH_MIN_CHARS`), counted
+ *  without building anything. */
+export function worthKeeping(content) {
+  if (typeof content === 'string') return content.length >= PARAGRAPH_MIN_CHARS;
+  let chars = 0;
+  for (const span of content) {
+    const text = span.text;
+    chars += typeof text === 'string' ? text.length : String(text ?? '').length;
+    if (chars >= PARAGRAPH_MIN_CHARS) return true;
+  }
+  return false;
+}
+
 export class ParagraphCache {
   constructor(limit = PARAGRAPH_GENERATION) {
     this._limit = limit;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntk",
-  "version": "8.12.7",
+  "version": "8.12.8",
   "description": "Desktop UI toolkit for X11 with canvas-like 2d and OpenGL rendering",
   "author": "Andrey Sidorov <sidorares@yandex.ru>",
   "license": "MIT",