ntk 8.16.2 → 8.17.0

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.2",
+  "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",