ntk 8.12.2 → 8.12.4

package/lib/fontconfig.js

@@ -255,6 +255,9 @@ function cacheMatches(fc, out) {
   return list;
 }
 
+// fc -> { promise, base }: one child per pattern however many callers ask.
+// `base` is where a prewarm writes its answer (`spawnToFiles`), null for a
+// child whose answer only reaches the event loop.
 const inflight = new Map();
 
 /**
@@ -270,13 +273,14 @@ const inflight = new Map();
  */
 function runFcMatch(fc) {
   const pending = inflight.get(fc);
-  if (pending) return pending;
+  if (pending) return pending.promise;
   const cp = childProcess();
   if (!cp) return Promise.reject(noFontsError(NOT_NODE));
 
-  const promise = new Promise((resolve, reject) => {
+  const entry = { promise: null, base: null };
+  entry.promise = new Promise((resolve, reject) => {
     cp.execFile('fc-match', [...fcMatchArgs, fc], fcMatchOpts, (err, out, stderr) => {
-      inflight.delete(fc);
+      if (inflight.get(fc) === entry) inflight.delete(fc);
       if (!err) return resolve(out);
       // execFile hands stderr to the callback; execFileSync hangs it on the
       // error, which is where the shared diagnosis reads it from
@@ -284,8 +288,152 @@ function runFcMatch(fc) {
       reject(err);
     });
   });
-  inflight.set(fc, promise);
-  return promise;
+  inflight.set(fc, entry);
+  return entry.promise;
+}
+
+// What a prewarm's child runs: fc-match with its answer in a file, then —
+// once that file is complete — the exit status in another, which is what a
+// synchronous caller waits for (`answerSync`). Nothing but shell builtins
+// runs after fc-match, so a PATH that holds fc-match alone is enough.
+const PREWARM_SCRIPT = 'fc-match "$@" > "$0.out" 2> "$0.err"; echo $? > "$0.done"';
+
+// The directory prewarms write into, made on first use: undefined until
+// then, null where it cannot be (no shell, no writable tmpdir), which leaves
+// prewarms on the event loop the way they always were.
+let prewarmDir;
+let prewarmCount = 0;
+
+function prewarmBase() {
+  const fs = builtin('node:fs');
+  const path = builtin('node:path');
+  if (prewarmDir === undefined) {
+    prewarmDir = null;
+    const p = globalThis.process;
+    const os = builtin('node:os');
+    if (p && p.platform !== 'win32' && fs && os && path && fs.existsSync('/bin/sh')) {
+      try {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ntk-fc-'));
+        p.once('exit', () => {
+          try {
+            fs.rmSync(dir, { recursive: true, force: true });
+          } catch {
+            // a tmpdir cleaned up under us is already clean
+          }
+        });
+        prewarmDir = dir;
+      } catch {
+        // a read-only or missing tmpdir: prewarm the old way
+      }
+    }
+  }
+  return prewarmDir === null ? null : path.join(prewarmDir, String(prewarmCount++));
+}
+
+/** The status and answer a prewarm left, once it has left them; null while
+ *  it is still running. */
+function readPrewarm(base) {
+  const fs = builtin('node:fs');
+  let done;
+  try {
+    done = fs.readFileSync(`${base}.done`, 'utf8');
+  } catch {
+    return null;
+  }
+  // `echo` writes the status and the newline in one go, but a read can land
+  // between the file appearing and its bytes arriving
+  if (!done.endsWith('\n')) return null;
+  const status = Number(done);
+  let out = '';
+  if (status === 0) {
+    try {
+      out = fs.readFileSync(`${base}.out`, 'utf8');
+    } catch {
+      return { status: -1, out: '' };
+    }
+  }
+  return { status, out };
+}
+
+function removePrewarm(base) {
+  const fs = builtin('node:fs');
+  for (const ext of ['.out', '.err', '.done']) {
+    try {
+      fs.unlinkSync(base + ext);
+    } catch {
+      // never written, or already gone
+    }
+  }
+}
+
+/**
+ * A prewarm's child, answering through files so that the synchronous path
+ * can take its answer without the event loop (`answerSync`) — which the
+ * first text layout is holding, from inside a render, for as long as the
+ * first frame takes. A prewarm answered through `execFile` alone lands after
+ * that, so the layout it was started for spawned fc-match a second time and
+ * waited for that one instead.
+ *
+ * Null where files cannot be used; the caller prewarms the old way.
+ */
+function spawnToFiles(fc) {
+  const cp = childProcess();
+  const base = cp ? prewarmBase() : null;
+  if (base === null) return null;
+  let child;
+  try {
+    child = cp.spawn('/bin/sh', ['-c', PREWARM_SCRIPT, base, ...fcMatchArgs, fc], {
+      stdio: 'ignore'
+    });
+  } catch {
+    return null;
+  }
+  const entry = { promise: null, base, answer: undefined };
+  entry.promise = new Promise((resolve, reject) => {
+    const settle = () => {
+      if (inflight.get(fc) === entry) inflight.delete(fc);
+      // answered already, by a synchronous caller that could not wait
+      if (entry.answer === undefined) {
+        const left = readPrewarm(base);
+        removePrewarm(base);
+        entry.answer = left && left.status === 0 ? left.out : null;
+      }
+      if (entry.answer !== null) resolve(entry.answer);
+      else reject(new Error(`fc-match for "${fc}" did not answer`));
+    };
+    child.once('error', settle);
+    child.once('exit', settle);
+  });
+  inflight.set(fc, entry);
+  return entry;
+}
+
+// the synchronous path's nap while a prewarm finishes
+const nap = new Int32Array(new SharedArrayBuffer(4));
+
+// How long the synchronous path waits on a prewarm before asking fc-match
+// itself. fc-match answers in tens of milliseconds, and a prewarm that is
+// running has a head start on any spawn that could replace it.
+const PREWARM_WAIT_MS = 3000;
+
+/**
+ * An in-flight prewarm's answer, waited for synchronously: its stdout, or
+ * null if it failed or took too long — the caller then spawns fc-match
+ * itself, which is also what reports why.
+ */
+function answerSync(fc, entry) {
+  const deadline = performance.now() + PREWARM_WAIT_MS;
+  let left = readPrewarm(entry.base);
+  while (left === null && performance.now() < deadline) {
+    Atomics.wait(nap, 0, 0, 1);
+    left = readPrewarm(entry.base);
+  }
+  if (inflight.get(fc) === entry) inflight.delete(fc);
+  if (entry.answer === undefined) {
+    entry.answer = left && left.status === 0 ? left.out : null;
+    if (left !== null) removePrewarm(entry.base);
+  }
+  return entry.answer;
 }
 
 /**
@@ -294,8 +442,10 @@ function runFcMatch(fc) {
  * matchSortedSync is deliberately synchronous — it answers from inside text
  * layout — so the first layout for a pattern pays the fc-match spawn (~50ms)
  * as a first-paint stall. Starting the same command here with a non-blocking
- * execFile, while the X connection is still being set up, moves that cost off
- * the critical path (issue #182).
+ * spawn, while the X connection is still being set up, moves that cost off
+ * the critical path (issue #182). The child answers through files as well as
+ * through the event loop, so a layout that asks for the pattern before the
+ * loop has run takes the prewarm's answer rather than spawning its own.
  *
  * Never rejects and never reports: a prewarm is an optimization, and an app
  * that never renders text must not crash — or even warn — over a missing
@@ -304,9 +454,6 @@ function runFcMatch(fc) {
  * `unavailable`: the first sync throw keeps its original spawn error as
  * `cause`.
  *
- * A sync call racing this one wins — the child's result is discarded
- * whenever the pattern is already cached by the time it exits.
- *
  * `matchSorted` is the reporting variant: same spawn, same cache, but it
  * awaits an answer and so has somewhere to put a failure.
  *
@@ -316,7 +463,8 @@ function runFcMatch(fc) {
 export function prewarm(pattern = {}) {
   const fc = patternFor(pattern);
   if (sortedCache.has(fc) || unavailable) return Promise.resolve();
-  return runFcMatch(fc).then(
+  const pending = inflight.get(fc)?.promise ?? spawnToFiles(fc)?.promise ?? runFcMatch(fc);
+  return pending.then(
     (out) => {
       if (!sortedCache.has(fc)) {
         const list = parseMatches(out);
@@ -327,6 +475,31 @@ export function prewarm(pattern = {}) {
   );
 }
 
+// the faces a family is asked for in: regular, bold, and both in italic
+const FACES = [
+  [400, 'normal'],
+  [700, 'normal'],
+  [400, 'italic'],
+  [700, 'italic']
+];
+const facesWarmed = new Set();
+
+/**
+ * Prewarm a family in the four faces text is set in — once per family.
+ *
+ * A document asks for its family's faces one at a time, as layout reaches
+ * the first bold word, the first emphasis, and each ask that misses is a
+ * synchronous fc-match on the way to the first frame: a Markdown document
+ * waited on five of them, 600 ms on XQuartz. Started together they run side
+ * by side, and each later ask finds its answer there.
+ */
+export function prewarmFaces(pattern = {}) {
+  const family = pattern.family || 'sans-serif';
+  if (facesWarmed.has(family) || unavailable) return;
+  facesWarmed.add(family);
+  for (const [weight, style] of FACES) prewarm({ family, weight, style });
+}
+
 /**
  * The same match list as `matchSortedSync`, without blocking for it.
  *
@@ -352,10 +525,18 @@ export async function matchSorted(pattern = {}) {
   if (unavailable) throw noFontsError(unavailable);
 
   let out;
-  try {
-    out = await runFcMatch(fc);
-  } catch (err) {
-    throw fcMatchError(err);
+  const pending = inflight.get(fc);
+  if (pending?.base) {
+    // a prewarm running for the pattern: its answer, or — if it has none —
+    // a spawn of our own, which is what reports why
+    out = await pending.promise.catch(() => undefined);
+  }
+  if (out === undefined) {
+    try {
+      out = await runFcMatch(fc);
+    } catch (err) {
+      throw fcMatchError(err);
+    }
   }
   // A sync call may have answered this pattern while the child ran. Its list
   // is the cached one, and candidates memoize their parsed charset, so hand
@@ -385,6 +566,14 @@ export function matchSortedSync(pattern) {
   if (cached) return cached;
   if (unavailable) throw noFontsError(unavailable);
 
+  // The family's other faces are the next asks (`prewarmFaces`): started
+  // now, they run beside this one instead of after it.
+  prewarmFaces(pattern);
+  const pending = inflight.get(fc);
+  if (pending?.base) {
+    const out = answerSync(fc, pending);
+    if (out !== null) return sortedCache.get(fc) ?? cacheMatches(fc, out);
+  }
   let out;
   try {
     out = execFileSync('fc-match', [...fcMatchArgs, fc], fcMatchOpts);

package/lib/text/font.js

@@ -75,6 +75,12 @@ export default class Font {
     this.path = path;
     /** stable cache key for glyph pages and font caches */
     this.key = `${path}#${postscriptName || fkFont.postscriptName || ''}`;
+    // What the face's tables say, read once. fontkit's getters walk to the
+    // table on every read, and a text layout asks per run and per word: in
+    // a long document they were most of a relayout (see `metrics`).
+    this._upem = 0;
+    this._vertical = null;
+    this._space = -1;
   }
 
   static loadSync(path, postscriptName) {
@@ -214,28 +220,48 @@ export default class Font {
   }
 
   scale(size) {
-    return size / this.fk.unitsPerEm;
+    return size / (this._upem ||= this.fk.unitsPerEm);
   }
 
   /**
    * Pixel-space metrics for a font size. `ascent`/`capHeight`/`xHeight` are
    * positive (above baseline), `descent` is positive (below baseline).
+   *
+   * A new object every call, which a caller may keep or change; the numbers
+   * behind it are the face's, read from its tables once.
    */
   metrics(size) {
+    const v = (this._vertical ??= {
+      ascent: this.fk.ascent,
+      descent: -this.fk.descent,
+      lineGap: this.fk.lineGap,
+      capHeight: this.fk.capHeight,
+      xHeight: this.fk.xHeight
+    });
     const s = this.scale(size);
-    const ascent = this.fk.ascent * s;
-    const descent = -this.fk.descent * s;
-    const lineGap = this.fk.lineGap * s;
+    const ascent = v.ascent * s;
+    const descent = v.descent * s;
+    const lineGap = v.lineGap * s;
     return {
       ascent,
       descent,
       lineGap,
       lineHeight: ascent + descent + lineGap,
-      capHeight: this.fk.capHeight * s,
-      xHeight: this.fk.xHeight * s
+      capHeight: v.capHeight * s,
+      xHeight: v.xHeight * s
     };
   }
 
+  /**
+   * The advance of U+0020 at `size` — what a run of trailing spaces is
+   * worth to a line. Looked up once: it was a cmap lookup for every word a
+   * layout ended with a space, which in a paragraph is every word.
+   */
+  spaceAdvance(size) {
+    if (this._space < 0) this._space = this.fk.glyphForCodePoint(0x20).advanceWidth;
+    return this._space * this.scale(size);
+  }
+
   hasGlyph(codepoint) {
     return this.fk.hasGlyphForCodePoint(codepoint);
   }

package/lib/text/fontsource.js

@@ -51,7 +51,7 @@ import {
   matchSorted,
   matchSortedSync,
   noFontsError,
-  prewarm,
+  prewarmFaces,
   supported
 } from '../fontconfig.js';
 import Font from './font.js';
@@ -116,13 +116,13 @@ export function parseFamilies(family) {
 export class FontconfigFontSource {
   constructor() {
     // Construction is the moment fontconfig is chosen as the lookup path, so
-    // the fc-match spawn for the pattern every widget default resolves to —
+    // the fc-match spawns for the pattern every widget default resolves to —
     // sans-serif at regular weight, exactly as FontManager.match normalizes
-    // it — starts here, asynchronously, instead of stalling the first text
-    // layout for ~50ms. Fire-and-forget: prewarm never rejects, and a source
-    // constructed where fc-match is missing stays silent until (unless) text
-    // is actually rendered.
-    prewarm({ family: 'sans-serif', weight: 400, style: 'normal' });
+    // it — and for its bold and italic start here, asynchronously, instead of
+    // stalling the first text layout for ~50ms each. Fire-and-forget:
+    // prewarm never rejects, and a source constructed where fc-match is
+    // missing stays silent until (unless) text is actually rendered.
+    prewarmFaces({ family: 'sans-serif' });
   }
 
   matchSorted(pattern) {

package/lib/text/layout.js

@@ -324,10 +324,8 @@ export class TextLayout {
     if (last) {
       const m = TRAILING_WS.exec(last.text);
       if (m) {
-        const spaceGlyph = last.span.font.fk.glyphForCodePoint(0x20);
         const spacing = Number.isFinite(last.span.letterSpacing) ? last.span.letterSpacing : 0;
-        wsWidth =
-          m[0].length * (spaceGlyph.advanceWidth * last.span.font.scale(last.span.size) + spacing);
+        wsWidth = m[0].length * (last.span.font.spaceAdvance(last.span.size) + spacing);
       }
     }
     return { fragments, width, wsWidth, required, start, end };

package/lib/text/shape.js

@@ -25,9 +25,29 @@ function neverSwitches(cp) {
  */
 export function embeddingLevels(text, direction = 'auto') {
   const explicit = direction === 'ltr' || direction === 'rtl' ? direction : null;
+  // Text that nothing can make right-to-left is level 0 throughout, which
+  // is what the algorithm would work out a character at a time: every
+  // layout asks, and most text is Latin, CJK or digits with no bidi at all.
+  if (explicit !== 'rtl' && !MAY_REVERSE.test(text)) {
+    return {
+      levels: new Uint8Array(text.length),
+      paragraphs: text.length ? [{ start: 0, end: text.length - 1, level: 0 }] : []
+    };
+  }
   return bidi.getEmbeddingLevels(text, explicit);
 }
 
+/**
+ * What can raise a level in a left-to-right paragraph: a strong
+ * right-to-left character (Hebrew, Arabic, Syriac, Thaana, N'Ko and their
+ * neighbours, their presentation forms, and the right-to-left blocks of the
+ * supplementary planes, found by their high surrogates), an Arabic number,
+ * RLM and ALM, and every explicit embedding, override and isolate. Anything
+ * else resolves to 0.
+ */
+const MAY_REVERSE =
+  /[\u0590-\u08FF\u200F\u202A-\u202E\u2066-\u2069\uFB1D-\uFDFF\uFE70-\uFEFF]|[\uD802\uD803\uD83A\uD83B]/;
+
 /**
  * Compact embedding-levels encoding for the shaping memo key: a single
  * number when uniform over [start, end) — the common case — else

package/package.json

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