ntk 8.16.1 → 8.17.0

package/lib/text/font.js

@@ -134,9 +134,45 @@ function statedOrGlyph(fk, field, codePoint) {
   }
 }
 
+/**
+ * fontkit's TrueType glyph reads its box from the glyph's header without
+ * asking whether it has one: `_getCBox` decodes a header where the glyph's
+ * data starts, and an empty glyph — a space, or one a subsetter left with
+ * no outline — has no data, where `_decode` beside it says so and draws
+ * nothing. Mid-table it read the next glyph's box. At the table's end it
+ * read past it, and in a WOFF, whose tables are each their own buffer, that
+ * threw: a face from fonts.com ends its glyph table on four empty glyphs,
+ * the space among them, and every layout in it threw, which left a whole
+ * document blank. An empty glyph's box is its empty outline's, as the rest
+ * of fontkit has it. Installed once, on the class every TrueType glyph is.
+ */
+const MENDED = new WeakSet();
+
+function mendEmptyGlyphBoxes(fk) {
+  if (!fk.directory?.tables?.glyf) return;
+  let glyph;
+  try {
+    glyph = fk.getGlyph(0);
+  } catch {
+    return;
+  }
+  const proto = Object.getPrototypeOf(glyph);
+  if (!proto || MENDED.has(proto)) return;
+  MENDED.add(proto);
+  const own = proto._getCBox;
+  const outline = Object.getPrototypeOf(proto)?._getCBox;
+  if (typeof own !== 'function' || typeof outline !== 'function') return;
+  proto._getCBox = function (internal) {
+    const offsets = this._font.loca?.offsets;
+    if (offsets && offsets[this.id] === offsets[this.id + 1]) return outline.call(this, internal);
+    return own.call(this, internal);
+  };
+}
+
 export default class Font {
   constructor(fkFont, path, postscriptName) {
     answerWithCharacters(fkFont);
+    mendEmptyGlyphBoxes(fkFont);
     this.fk = fkFont;
     this.path = path;
     /** stable cache key for glyph pages and font caches */

package/lib/text/layout.js

@@ -110,6 +110,30 @@ function sameItem(before, span) {
   return before === span || span.kernAcross || before.kernAcross;
 }
 
+/**
+ * The width a line's entries take as the line is fitted, white space and
+ * all: each item's part — a span's, or a run of them `sameItem` joins —
+ * rounded as the layout rounds (`LineFit`), with its kerning. A line's
+ * `advance`: where the text goes on after the line on the same one, as it
+ * does after a piece of a line composed a piece at a time, the white space
+ * it ends on is inside the line, and in the item it ends, which is rounded
+ * once with it, as Blink measures an element's text with its spaces.
+ */
+function fittedEntries(entries, round) {
+  let fitted = 0;
+  let item = 0;
+  let span = null;
+  for (const e of entries) {
+    if (span !== null && !sameItem(span, e.span)) {
+      fitted += round(item);
+      item = 0;
+    }
+    item += (e.kern ?? 0) + e.run.width + (e.kernAfter ?? 0);
+    span = e.span;
+  }
+  return entries.length ? fitted + round(item) : 0;
+}
+
 /** How a layout rounds its items before it adds them (`LineFit`). */
 function itemRounding(options) {
   return options.fit === 'items' ? snapUp : unrounded;
@@ -187,12 +211,15 @@ function isWsGlyph(g) {
  *   is that sum. Default: the advances as they add up (`LineFit`)
  *
  * The result is inspectable before/without drawing: `width`, `height`,
- * `truncated`, and `lines[] = { x, y, height, baseline, width, ascent,
- * descent, runs, start, end }` with
+ * `truncated`, and `lines[] = { x, y, height, baseline, width, advance,
+ * ascent, descent, runs, start, end }` with
  * `runs[] = { x, width, run, span, start, end }` in visual order
  * (`start`/`end` are logical UTF-16 ranges into the full text). A line's
  * box is `y` to `y + height`; its glyphs sit centred in it, from
- * `baseline - ascent` to `baseline + descent`.
+ * `baseline - ascent` to `baseline + descent`. Its `width` leaves out the
+ * white space it ends on, as a line's end does; its `advance` keeps it, in
+ * the item it ends, which is how far the line moves the pen where text goes
+ * on after it on the same line.
  *
  * `caretPosition(index)` / `indexAt(x, y)` map logical code-point indices
  * to visual caret geometry and back (bidi/ligature/trailing-whitespace
@@ -334,6 +361,9 @@ export class TextLayout {
           }
         }
       }
+      // how far the line moves the pen where text goes on after it on the
+      // same line: its trailing white space kept, in the item it ends
+      let advance = fittedEntries(entries, round);
       let trailing = stripTrailingWhitespace(entries);
       const contentEnd = trailing
         ? trailing.start
@@ -363,6 +393,7 @@ export class TextLayout {
         // whatever whitespace was stripped is gone for good, not merely
         // pushed past the line edge: there is no wrap for it to precede
         trailing = null;
+        advance = null;
         lineEnd = contentEnd;
       }
       entries = reorderRuns(entries);
@@ -424,6 +455,7 @@ export class TextLayout {
         height: box,
         baseline: y + leading + ascent,
         width: fitted,
+        advance: trailing && advance !== null ? Math.max(fitted, advance) : fitted,
         ascent,
         descent,
         runs,

package/package.json

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