ntk 8.0.0 → 8.1.1

package/lib/app.js

@@ -5,6 +5,7 @@ import { chooseGLXConfig } from './glx.js';
 import Picture from './picture.js';
 import Pixmap from './pixmap.js';
 import { DEFAULT_RASTER_POLICY, defaultRasterizer } from './rasterize.js';
+import { dropShadowSurfaces } from './shadow.js';
 import { ShmUploader } from './shm-upload.js';
 import FontManager from './text/fontmanager.js';
 import Window from './window.js';
@@ -543,6 +544,9 @@ export default class App {
       this._shm.dispose();
       this._shm = undefined;
     }
+    // shadow coverage is cached per connection for the same reason solids
+    // are: the contexts that drew it are long gone (see lib/shadow.js)
+    dropShadowSurfaces(this);
     // shared by every context that ever asked (see solidPicture), so their
     // lifetime is the connection's — context teardown must not free them
     for (const picture of this._solidPictures.values()) {

package/lib/fontconfig.js

@@ -7,13 +7,12 @@ function childProcess() {
   return builtin('node:child_process');
 }
 
+const NOT_NODE =
+  'fontconfig matching needs node (the fc-match CLI) and this is not a node environment';
+
 function execFileSync(...args) {
   const cp = childProcess();
-  if (!cp) {
-    throw noFontsError(
-      'fontconfig matching needs node (the fc-match CLI) and this is not a node environment'
-    );
-  }
+  if (!cp) throw noFontsError(NOT_NODE);
   return cp.execFileSync(...args);
 }
 
@@ -87,16 +86,51 @@ const sortedCache = new Map();
 // installs fontconfig into a running process.
 let unavailable = null;
 
+/**
+ * The exit code fc-match left, or null if the child never ran at all.
+ *
+ * The two exec flavours report it differently: execFileSync puts it in
+ * `status` and leaves `code` for the spawn failure, while execFile puts both
+ * in `code`. Normalized here so one diagnosis serves the sync and async
+ * paths rather than two that can drift apart.
+ */
+function exitStatus(err) {
+  if (err.status != null) return err.status;
+  return typeof err.code === 'number' ? err.code : null;
+}
+
 /**
  * Did the spawn itself fail, as opposed to fc-match running and being
- * unhappy? `status` is null only when the child never ran, and these are the
- * codes that mean "no usable binary at this name" rather than a transient
- * failure worth reporting verbatim.
+ * unhappy? No exit code means the child never ran, and these are the codes
+ * that mean "no usable binary at this name" rather than a transient failure
+ * worth reporting verbatim.
  */
 function isSpawnFailure(err) {
-  return (
-    err.status == null && ['ENOENT', 'EACCES', 'EPERM', 'ENOTDIR'].includes(err.code)
-  );
+  return exitStatus(err) == null && ['ENOENT', 'EACCES', 'EPERM', 'ENOTDIR'].includes(err.code);
+}
+
+/**
+ * An fc-match failure -> the error to report for it.
+ *
+ * Only a path that actually reports belongs here: a missing binary is
+ * memoized in `unavailable` on the way through, which is exactly what
+ * `prewarm` must not do (see there). It swallows the raw failure instead.
+ */
+function fcMatchError(err) {
+  if (err.code === 'ERR_NTK_NO_FONTS') return err; // no child_process at all
+  if (isSpawnFailure(err)) {
+    unavailable = 'the fc-match CLI (fontconfig) is not installed here';
+    return noFontsError(unavailable, err);
+  }
+  const status = exitStatus(err);
+  if (status != null) {
+    // fontconfig is installed and said no — an image with fontconfig but no
+    // font package answers "No fonts installed on the system" and exits 1.
+    // Not memoized: unlike a missing binary this can depend on the pattern.
+    const stderr = String(err.stderr || '').trim().split('\n')[0];
+    return noFontsError(`fc-match exited ${status}${stderr ? `: ${stderr}` : ''}`, err);
+  }
+  return err;
 }
 
 function patternFor({ family, weight, style }) {
@@ -109,22 +143,91 @@ function patternFor({ family, weight, style }) {
 
 // One command shared by the sync and async paths, so a prewarmed cache entry
 // is byte-for-byte what the sync call would have computed.
-const fcMatchArgs = ['-s', '--format', '%{file}\t%{postscriptname}\t%{charset}\n'];
+//
+// `%{family}` is a *list*: fontconfig keeps every name a face answers to,
+// localized aliases included (`Hiragino Sans`, `ヒラギノ角ゴシック`, and the
+// style-suffixed forms of both are one face), and `--format` joins them with
+// commas. The fields are tab-separated so a comma inside one costs nothing,
+// and `charset` stays last because it is by far the longest.
+const fcMatchArgs = [
+  '-s',
+  '--format',
+  '%{file}\t%{postscriptname}\t%{family}\t%{charset}\n'
+];
 const fcMatchOpts = { encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 };
 
 /** fc-match -s output -> candidates, filtered to formats fontkit can parse */
 function parseMatches(out) {
   const list = [];
   for (const line of out.split('\n')) {
-    const [path, postscriptName, charset] = line.split('\t');
+    const [path, postscriptName, family, charset] = line.split('\t');
     if (path && supported.test(path)) {
-      list.push({ path, postscriptName, charset: charset || '', _ranges: null });
+      // `families` keeps fontconfig's whole list, in its order; `family` is
+      // the first of them, which is the name fontconfig leads with for the
+      // current locale and the one to show in a UI.
+      const families = family ? family.split(',').filter(Boolean) : [];
+      list.push({
+        path,
+        postscriptName,
+        family: families[0] || '',
+        families,
+        charset: charset || '',
+        _ranges: null
+      });
     }
   }
   return list;
 }
 
-const prewarming = new Map();
+/**
+ * fc-match output -> the cached candidate list for a pattern. Throws for
+ * output that parses to nothing usable, which is a fontconfig answer rather
+ * than a fontconfig failure and so is diagnosed separately.
+ */
+function cacheMatches(fc, out) {
+  const list = parseMatches(out);
+  if (list.length === 0) {
+    throw noFontsError(
+      `fontconfig matched no font ntk can parse for "${fc}" (needs ` +
+        '.ttf/.otf/.woff/.woff2/.ttc/.dfont — bitmap .pcf/.bdf fonts are not usable)'
+    );
+  }
+  sortedCache.set(fc, list);
+  return list;
+}
+
+const inflight = new Map();
+
+/**
+ * fc-match for a pattern, off the event loop — one child per pattern however
+ * many callers ask at once, so a prewarm and an awaiting `matchSorted` share
+ * a single spawn instead of racing two.
+ *
+ * Rejects with the *raw* failure, undiagnosed: `fcMatchError` memoizes a
+ * missing binary, and whether that should happen is the caller's decision,
+ * not this one's.
+ *
+ * @returns {Promise<string>} raw fc-match stdout
+ */
+function runFcMatch(fc) {
+  const pending = inflight.get(fc);
+  if (pending) return pending;
+  const cp = childProcess();
+  if (!cp) return Promise.reject(noFontsError(NOT_NODE));
+
+  const promise = new Promise((resolve, reject) => {
+    cp.execFile('fc-match', [...fcMatchArgs, fc], fcMatchOpts, (err, out, stderr) => {
+      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
+      if (err.stderr === undefined) err.stderr = stderr;
+      reject(err);
+    });
+  });
+  inflight.set(fc, promise);
+  return promise;
+}
 
 /**
  * Seed the match cache for a pattern ahead of time, off the event loop.
@@ -145,87 +248,108 @@ const prewarming = new Map();
  * 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.
+ *
  * @returns {Promise<void>} resolves once the cache is seeded or the attempt
  *   abandoned
  */
 export function prewarm(pattern = {}) {
   const fc = patternFor(pattern);
   if (sortedCache.has(fc) || unavailable) return Promise.resolve();
-  const inflight = prewarming.get(fc);
-  if (inflight) return inflight;
-  const cp = childProcess();
-  if (!cp) return Promise.resolve();
-
-  const promise = new Promise((resolve) => {
-    cp.execFile('fc-match', [...fcMatchArgs, fc], fcMatchOpts, (err, out) => {
-      prewarming.delete(fc);
-      if (!err && !sortedCache.has(fc)) {
+  return runFcMatch(fc).then(
+    (out) => {
+      if (!sortedCache.has(fc)) {
         const list = parseMatches(out);
         if (list.length > 0) sortedCache.set(fc, list);
       }
-      resolve();
-    });
-  });
-  prewarming.set(fc, promise);
-  return promise;
+    },
+    () => {}
+  );
+}
+
+/**
+ * The same match list as `matchSortedSync`, without blocking for it.
+ *
+ * For a caller that is not inside text layout — a font picker matching as
+ * the user types, a preferences page, anything that can await — the sync
+ * spawn is ~100ms of stalled event loop per new pattern and buys nothing.
+ * This runs the identical command through `execFile` instead, shares the
+ * spawn with any prewarm already in flight for the pattern, and fills the
+ * same cache, so a later layout answers from memory.
+ *
+ * Unlike `prewarm` it reports: a missing fc-match rejects here rather than
+ * resolving quietly and leaving the diagnosis to a blocking sync call
+ * afterwards. Rejections carry `code: 'ERR_NTK_NO_FONTS'` exactly as the
+ * sync throws do.
+ *
+ * @returns {Promise<Array<{path, postscriptName, family: string,
+ *   families: string[], charset: string}>>}
+ */
+export async function matchSorted(pattern = {}) {
+  const fc = patternFor(pattern);
+  const cached = sortedCache.get(fc);
+  if (cached) return cached;
+  if (unavailable) throw noFontsError(unavailable);
+
+  let out;
+  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
+  // back what everyone else already holds rather than a fresh copy.
+  return sortedCache.get(fc) ?? cacheMatches(fc, out);
 }
 
 /**
  * Full fontconfig match list for a pattern, best match first — this is the
  * system's font fallback chain. Each candidate carries the unicode coverage
  * fontconfig knows about (`charset`, lazily parsed via `charsetHas`), so a
- * fallback font for a codepoint can be chosen without opening font files.
+ * fallback font for a codepoint can be chosen without opening font files —
+ * and the family name fontconfig already knows, so a *list* of matches can be
+ * shown without opening them either (issue #273: `sans-serif` returns 139
+ * candidates here, and `Font.loadSync` is ~1.2ms a file).
  *
  * Cached per pattern; one fc-match invocation (~50ms) per distinct pattern.
+ * Synchronous because its main caller is text layout, which cannot await;
+ * a caller that can should use `matchSorted` and not block on the spawn.
  *
- * @returns {Array<{path, postscriptName, charset: string}>}
+ * @returns {Array<{path, postscriptName, family: string, families: string[],
+ *   charset: string}>}
  */
 export function matchSortedSync(pattern) {
   const fc = patternFor(pattern);
-  let list = sortedCache.get(fc);
-  if (list) return list;
+  const cached = sortedCache.get(fc);
+  if (cached) return cached;
   if (unavailable) throw noFontsError(unavailable);
 
   let out;
   try {
     out = execFileSync('fc-match', [...fcMatchArgs, fc], fcMatchOpts);
   } catch (err) {
-    if (err.code === 'ERR_NTK_NO_FONTS') throw err; // no child_process at all
-    if (isSpawnFailure(err)) {
-      unavailable = 'the fc-match CLI (fontconfig) is not installed here';
-      throw noFontsError(unavailable, err);
-    }
-    if (err.status != null) {
-      // fontconfig is installed and said no — an image with fontconfig but no
-      // font package answers "No fonts installed on the system" and exits 1.
-      // Not memoized: unlike a missing binary this can depend on the pattern.
-      const stderr = String(err.stderr || '').trim().split('\n')[0];
-      throw noFontsError(`fc-match exited ${err.status}${stderr ? `: ${stderr}` : ''}`, err);
-    }
-    throw err;
+    throw fcMatchError(err);
   }
-
-  list = parseMatches(out);
-  if (list.length === 0) {
-    throw noFontsError(
-      `fontconfig matched no font ntk can parse for "${fc}" (needs ` +
-        '.ttf/.otf/.woff/.woff2/.ttc/.dfont — bitmap .pcf/.bdf fonts are not usable)'
-    );
-  }
-  sortedCache.set(fc, list);
-  return list;
+  return cacheMatches(fc, out);
 }
 
 /**
  * Resolve a font pattern ({family, weight, style}) to the best matching font
- * file. Returns { path, postscriptName } or throws if nothing suitable is
- * installed. Requires the fc-match CLI (fontconfig) — usual on a Linux
- * desktop, absent from slim containers and from stock macOS. Where it is
- * missing, hand ntk the fonts instead (see docs/fonts.md).
+ * file. Returns { path, postscriptName, family, families } or throws if
+ * nothing suitable is installed. Requires the fc-match CLI (fontconfig) —
+ * usual on a Linux desktop, absent from slim containers and from stock
+ * macOS. Where it is missing, hand ntk the fonts instead (see docs/fonts.md).
  */
 export function listFontsSync(pattern) {
   const [best] = matchSortedSync(pattern);
-  return { path: best.path, postscriptName: best.postscriptName };
+  return {
+    path: best.path,
+    postscriptName: best.postscriptName,
+    family: best.family,
+    families: best.families
+  };
 }
 
 /**