ntk 8.14.0 → 8.14.1

package/lib/text/anchors.js

@@ -0,0 +1,81 @@
+// fontkit's mark attachment, for a face whose tables leave an anchor out.
+//
+// A mark-to-base, mark-to-ligature or mark-to-mark subtable holds an anchor
+// for each base (ligature component, earlier mark) and mark class, and the
+// OpenType spec lets one be NULL: that subtable attaches no mark of that
+// class to that glyph. HarfBuzz answers "not applied", and the lookup's next
+// subtable gets its turn. fontkit reads the NULL's coordinates and throws
+// `Cannot read properties of null (reading 'xCoordinate')` out of a layout,
+// and faces ship them: Noto Sans Bold holds 2,822, DejaVu Sans Mono 198 (a
+// Lithuanian Į̃ reaches one), Amiri, Noto Naskh Arabic and FreeSerif
+// thousands. Upstream that is foliojs/fontkit#367; #374 returns early
+// instead, which ends the crash but still counts the subtable as applied.
+//
+// Answering "not applied" means wrapping the processor's `applyLookup`,
+// which runs for every glyph at every lookup: 2% of shaping a word the
+// first time. So a face pays it only from the first NULL its text reaches.
+// Until then `applyAnchor` alone is watched — it runs when a mark attaches —
+// and a NULL there abandons the layout (`NO_ANCHOR`), which `Font#_layout`
+// shapes again with the wrapper in. Abandoning loses nothing: fontkit keeps
+// no state from a layout but the tables it decoded, which a second one
+// reads the same.
+
+/**
+ * Thrown through fontkit's layout from a NULL anchor, and caught here or in
+ * `Font#_layout`. One error, made once: a face can reach NULLs many times a
+ * word, and a fresh error would take a stack trace each time. It says what
+ * happened to anything that calls a watched face's `layout` directly.
+ */
+export const NO_ANCHOR = new Error(
+  'a mark attachment subtable has a NULL anchor for this glyph and mark class: ' +
+    "shaped through ntk's Font, that is a subtable that did not apply"
+);
+
+/** The face's GPOS processor, where fontkit shapes it through GPOS; else null. */
+function processorOf(fk) {
+  try {
+    return fk._layoutEngine?.engine?.GPOSProcessor ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Watch a face's mark attachment for a NULL anchor, which then abandons the
+ * layout it is reached in with `NO_ANCHOR`.
+ *
+ * @param {object} fk a fontkit font
+ * @returns {boolean} whether there is anything to watch: false for a face
+ *   fontkit does not position through GPOS
+ */
+export function watchAnchors(fk) {
+  const gpos = processorOf(fk);
+  if (!gpos || typeof gpos.applyAnchor !== 'function') return false;
+  if (Object.hasOwn(gpos, 'applyAnchor')) return true;
+  const applyAnchor = gpos.applyAnchor;
+  gpos.applyAnchor = function (markRecord, baseAnchor, baseGlyphIndex) {
+    if (baseAnchor == null || markRecord.markAnchor == null) throw NO_ANCHOR;
+    return applyAnchor.call(this, markRecord, baseAnchor, baseGlyphIndex);
+  };
+  return true;
+}
+
+/**
+ * From here on a subtable that reaches a NULL anchor is one that did not
+ * apply, so the lookup's next subtable is tried, as HarfBuzz tries it.
+ *
+ * @param {object} fk a fontkit font `watchAnchors` has been handed
+ */
+export function tolerateAnchors(fk) {
+  const gpos = processorOf(fk);
+  if (!gpos || Object.hasOwn(gpos, 'applyLookup')) return;
+  const applyLookup = gpos.applyLookup;
+  gpos.applyLookup = function (lookupType, table) {
+    try {
+      return applyLookup.call(this, lookupType, table);
+    } catch (err) {
+      if (err === NO_ANCHOR) return false;
+      throw err;
+    }
+  };
+}

package/lib/text/font.js

@@ -1,6 +1,7 @@
 import * as fontkit from 'fontkit';
 
 import { flatten, rasterizePath } from '../rasterize.js';
+import { NO_ANCHOR, tolerateAnchors, watchAnchors } from './anchors.js';
 import { marksCover, standInMarks } from './marks.js';
 
 // Axis coordinates are rounded to this many decimals before anything is
@@ -127,6 +128,10 @@ export default class Font {
     // at its first shaping; null once the real ones are back, or never were
     // stood in for
     this._marks = undefined;
+    this._drawable = undefined;
+    // whether the face's mark attachment is watched for a NULL anchor
+    // (./anchors.js): set at its first shaping, false once one has been met
+    this._anchors = false;
   }
 
   static loadSync(path, postscriptName) {
@@ -308,8 +313,29 @@ export default class Font {
     return this._space * this.scale(size);
   }
 
+  /**
+   * Whether fontkit can make a glyph of this face at all. It makes one from
+   * `glyf`, `CFF ` or `CFF2` outlines, or an `sbix` or `COLR`/`CPAL` colour
+   * glyph, and answers null for anything else — and its shaper throws on the
+   * null. A bitmap-only colour font (`CBDT`/`CBLC`) is that face: Noto Color
+   * Emoji and EmojiOne as most Linux desktops ship them, which fontconfig
+   * answers first for an emoji. Its cmap says it has the character and
+   * nothing can be shaped or drawn from it, so it covers nothing here
+   * (`hasGlyph`), and `FontManager` hands it out neither as a match nor as a
+   * fallback.
+   */
+  get drawable() {
+    if (this._drawable === undefined) {
+      const t = this.fk.directory?.tables ?? {};
+      this._drawable = Boolean(
+        t.glyf || t['CFF '] || t.CFF2 || t.sbix || (t.COLR && t.CPAL)
+      );
+    }
+    return this._drawable;
+  }
+
   hasGlyph(codepoint) {
-    return this.fk.hasGlyphForCodePoint(codepoint);
+    return this.drawable && this.fk.hasGlyphForCodePoint(codepoint);
   }
 
   /**
@@ -329,7 +355,7 @@ export default class Font {
    * @returns {number|null} font glyph id, as `shape()` would report in `glyphs[].id`
    */
   glyphIdFor(codepoint) {
-    if (!this.fk.hasGlyphForCodePoint(codepoint)) return null;
+    if (!this.hasGlyph(codepoint)) return null;
     return this.fk.glyphForCodePoint(codepoint).id;
   }
 
@@ -376,16 +402,38 @@ export default class Font {
    */
   _layout(text, opts) {
     const { features, script, language, direction } = opts;
-    if (this._marks === undefined) this._marks = standInMarks(this.fk);
+    if (this._marks === undefined) {
+      this._marks = standInMarks(this.fk);
+      this._anchors = watchAnchors(this.fk);
+    }
     const marks = this._marks;
     // fontkit adds to the features object it is handed: a second shaping
     // gets what the caller asked for, not what the first left there
     const again = marks === null || features == null ? features : Array.isArray(features) ? [...features] : { ...features };
-    const run = this.fk.layout(text, features, script, language, direction);
+    const run = this._fkLayout(text, features, script, language, direction);
     if (marks === null || !run.glyphs.some((glyph) => marksCover(marks.bits, glyph.id))) return run;
     marks.restore();
     this._marks = null;
-    return this.fk.layout(text, again, script, language, direction);
+    return this._fkLayout(text, again, script, language, direction);
+  }
+
+  /**
+   * fontkit's layout, shaped once more where a NULL anchor abandoned it: a
+   * face's mark attachment is watched for one until its text reaches the
+   * first, and takes one as a subtable that did not apply from then on
+   * (./anchors.js).
+   */
+  _fkLayout(text, features, script, language, direction) {
+    if (!this._anchors) return this.fk.layout(text, features, script, language, direction);
+    const again = features == null ? features : Array.isArray(features) ? [...features] : { ...features };
+    try {
+      return this.fk.layout(text, features, script, language, direction);
+    } catch (err) {
+      if (err !== NO_ANCHOR) throw err;
+      tolerateAnchors(this.fk);
+      this._anchors = false;
+      return this.fk.layout(text, again, script, language, direction);
+    }
   }
 
   /** nominal (unshaped) advance of a glyph id, in pixels */

package/lib/text/fontmanager.js

@@ -111,8 +111,12 @@ function shapePrefixOf(style) {
   // plain answered every later request for it with the plain glyphs, and a
   // `tnum` asked for after that point was silently ignored.
   const shaping = shapingKeyOf(style);
+  // The family list too where a face is given, since the letters that face
+  // lacks are set in the families after it (`fallbackFor`): a word shaped
+  // under `Ahem, Times New Roman` answered the same word under `Ahem,
+  // Arial`, in Times.
   return font
-    ? `${font.key}|${style.size}|${style.weight}|${style.style}|${shaping}`
+    ? `${font.key}|${style.family ?? ''}|${style.size}|${style.weight}|${style.style}|${shaping}`
     : `${style.family}|${style.size}|${style.weight}|${style.style}|${variationsKeyOf(
         style.variations
       )}|${opticalKeyOf(style)}|${shaping}`;
@@ -253,6 +257,28 @@ export default class FontManager {
     );
   }
 
+  /**
+   * The best of `candidates` a glyph can be made from (`Font.drawable`):
+   * `emoji`, or a stylesheet's `"Noto Color Emoji"`, is a bitmap-only face
+   * on most Linux desktops, and a base face nothing can be shaped in threw
+   * on the first character of its text. The first candidate still, where
+   * none is — there is nothing better to hand out.
+   */
+  _firstDrawable(candidates) {
+    let first = null;
+    for (const c of candidates) {
+      let font;
+      try {
+        font = this._open(c);
+      } catch {
+        continue; // unparseable candidate — try the next one
+      }
+      if (font.drawable) return font;
+      first ??= font;
+    }
+    return first ?? this._open(candidates[0]);
+  }
+
   /** open (and cache) a match candidate — see fontsource.js for the shape */
   _open(candidate) {
     const key = candidate.key ?? `${candidate.path}#${candidate.postscriptName || ''}`;
@@ -309,7 +335,7 @@ export default class FontManager {
     let bestScore = Infinity;
     for (const family of families) {
       for (const r of this._registered) {
-        if (r.family !== family) continue;
+        if (r.family !== family || !r.font.drawable) continue;
         const score = Math.abs(r.weight - weight) + (r.italic !== italic ? 1000 : 0);
         if (score < bestScore) {
           bestScore = score;
@@ -361,12 +387,19 @@ export default class FontManager {
     if (!face) {
       // sources understand comma-separated family lists natively; one that
       // can answer the best face alone saves reading the fallback chain the
-      // face may never need
+      // face may never need — unless no glyph can be made from that face
       const pattern = patternOf(family, weight, italic);
       const source = this.source;
-      face = this._open(
-        typeof source.matchFirst === 'function' ? source.matchFirst(pattern) : source.matchSorted(pattern)[0]
-      );
+      let head = null;
+      if (typeof source.matchFirst === 'function') {
+        const candidate = source.matchFirst(pattern);
+        try {
+          head = this._open(candidate);
+        } catch {
+          // unparseable: the chain has the next candidate
+        }
+      }
+      face = head?.drawable ? head : this._firstDrawable(source.matchSorted(pattern));
     }
     this._matches.set(cacheKey, face);
     // A long-lived app can name a lot of families. Same sweep as the shaping
@@ -383,9 +416,17 @@ export default class FontManager {
 
   /**
    * Find a font that has a glyph for `codepoint`, for use when the primary
-   * font doesn't. Registered fonts first, then the source's fallback chain
-   * (filtered by the source's coverage data — font files are only opened to
-   * confirm). Returns null when nothing on the system covers the codepoint.
+   * font doesn't. The registered faces of the families the style names
+   * first, in the order it names them, then any registered face, then the
+   * source's fallback chain (filtered by the source's coverage data — font
+   * files are only opened to confirm). Returns null when nothing on the
+   * system covers the codepoint.
+   *
+   * The families first because that is what a list of them is for: CSS's
+   * `font-family: Icons, Arial` sets a letter the icon face lacks in Arial,
+   * as a browser does. Walking every registered face instead gave it to
+   * whichever was registered first — an app's serif — however far down the
+   * list, or off it, that face was.
    *
    * "Nothing covers it" includes "this environment has no system fonts at
    * all". An app that loaded its own faces still reaches here for the first
@@ -404,10 +445,23 @@ export default class FontManager {
     if (perCp.has(codepoint)) return perCp.get(codepoint);
 
     let found = null;
-    for (const r of this._registered) {
-      if (r.font.hasGlyph(codepoint)) {
-        found = r.font;
-        break;
+    if (this._registered.length) {
+      const weight = numWeight(opts.weight);
+      const italic = !!opts.style?.includes('italic');
+      for (const name of familiesOf(family)) {
+        const font = this._matchRegistered([name.toLowerCase()], weight, italic);
+        if (font && font.hasGlyph(codepoint)) {
+          found = font;
+          break;
+        }
+      }
+    }
+    if (!found) {
+      for (const r of this._registered) {
+        if (r.font.hasGlyph(codepoint)) {
+          found = r.font;
+          break;
+        }
       }
     }
     if (!found) {

package/lib/text/shape.js

@@ -74,23 +74,32 @@ export function normalizedLevels(levels, start, end) {
  */
 const OPTIONAL_LIGATURES = ['liga', 'clig', 'dlig', 'hlig'];
 
-/**
- * The features a letter-spaced run shapes with: the optional ligatures off,
- * underneath whatever the caller asked for — a style that names `liga`
- * itself still gets it. `features` is either form fontkit takes, an array of
- * tags to turn on or an object of tag → on/off.
- */
 /**
  * A copy of `features` for fontkit, which **adds to the object it is handed**
  * — `rvrn` and the like, as it plans the shaping. Handed a caller's own
  * object that is a style quietly growing keys, which changes the memo key it
  * is filed under next time, and a frozen one throws.
+ *
+ * A feature a 0 turns off, as CSS writes one (`font-feature-settings: "kern"
+ * 0`, and `font-kerning: none`), goes to fontkit as `false`. It reads a 0 as
+ * off where it plans the OpenType features, but where a face keeps its
+ * kerning in the older `kern` table — Times New Roman's, and DejaVu's beside
+ * its GPOS pairs — it asks `kern !== false`, and a 0 kerned all the same.
  */
 function ownFeatures(features) {
   if (!features) return features;
-  return Array.isArray(features) ? [...features] : { ...features };
+  if (Array.isArray(features)) return [...features];
+  const out = {};
+  for (const tag in features) out[tag] = features[tag] === 0 ? false : features[tag];
+  return out;
 }
 
+/**
+ * The features a letter-spaced run shapes with: the optional ligatures off,
+ * underneath whatever the caller asked for — a style that names `liga`
+ * itself still gets it. `features` is either form fontkit takes, an array of
+ * tags to turn on or an object of tag → on/off.
+ */
 function spacedFeatures(features) {
   const off = Object.fromEntries(OPTIONAL_LIGATURES.map((tag) => [tag, false]));
   if (!features) return off;
@@ -98,7 +107,7 @@ function spacedFeatures(features) {
     for (const tag of features) off[tag] = true;
     return off;
   }
-  return { ...off, ...features };
+  return { ...off, ...ownFeatures(features) };
 }
 
 /**

package/package.json

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