react-x11 2.20.0 → 2.21.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-x11",
-  "version": "2.20.0",
+  "version": "2.21.0",
   "description": "react renderer with X11 as a target",
   "main": "./src/index.js",
   "files": [
@@ -108,7 +108,7 @@
     "yoga-layout": "^3.2.1"
   },
   "optionalDependencies": {
-    "@windowkit/appkit": "^0.12.0",
+    "@windowkit/appkit": "^0.13.0",
     "@windowkit/wayland": "^3.1.1",
     "@windowkit/win32": "^0.0.3",
     "dbus-native": "^0.15.1",

package/src/cocoa/fonts.js

@@ -5,7 +5,7 @@
 //   fonts.layout(spans, base, { maxWidth, align, lineHeight, maxLines,
 //                               overflow, direction })
 //     -> { width, height, lines, draw(ctx, x, y),
-//          indexAt(x, y), caretPosition(cp) }
+//          indexAt(x, y), caretPosition(cp), coverage({ pad }) }
 //   fonts.match(family, { weight, style }) -> face
 //   fonts.fallbackFor(codepoint, family, { weight, style }) -> face | null
 //
@@ -144,6 +144,25 @@ class CocoaTextLayout {
   caretPosition(cp) {
     return this._native.layoutCaret(this._handle, this._cuOf(cp));
   }
+
+  /**
+   * How much of each device pixel the glyphs cover, one byte a pixel,
+   * without drawing them anywhere (#673) — for text that is drawn where a 2D
+   * context is not, a GL surface's labels. The raster is the layout's box in
+   * whole pixels with `pad` round it, the layout's origin at (pad, pad).
+   *
+   * The bridge's `layoutCoverage`: each glyph's CoreText outline where the
+   * run put it, unrounded, filled once by the signed-area accumulation ntk
+   * rasterizes with, so the X11 engine and this one give the same bytes for
+   * the same outlines — and none of the font smoothing the screen gets. Not
+   * CoreText's glyph rasterizer, which shrinks a small glyph's counters even
+   * with smoothing off. Null on a bridge that predates it (`@windowkit/appkit`
+   * before 0.13.0), so a caller keeps its readback.
+   */
+  coverage({ pad = 0 } = {}) {
+    if (typeof this._native.layoutCoverage !== 'function') return null;
+    return this._native.layoutCoverage(this._handle, pad) ?? null;
+  }
 }
 
 /**

package/src/win32/fonts.js

@@ -154,6 +154,25 @@ class Win32TextLayout {
     return this._native.layoutCaret(this._handle, this._cuOf(cp));
   }
 
+  /**
+   * How much of each device pixel the glyphs cover, one byte a pixel,
+   * without drawing them anywhere (#673) — for text that is drawn where a 2D
+   * context is not, a GL surface's labels. The raster is the layout's box in
+   * whole pixels with `pad` round it, the layout's origin at (pad, pad).
+   *
+   * DirectWrite's own glyph-run analysis rather than a surface read back:
+   * grayscale, grid fit off, and none of the gamma or enhanced contrast
+   * Direct2D gives text it blends — the outlines' coverage, which is what a
+   * distance field is made from. Null on a bridge that predates it
+   * (`@windowkit/win32` before `layoutCoverage`), so a caller keeps its
+   * readback.
+   */
+  coverage({ pad = 0 } = {}) {
+    if (this._handle == null) return null;
+    if (typeof this._native.layoutCoverage !== 'function') return null;
+    return this._native.layoutCoverage(this._handle, pad) ?? null;
+  }
+
   _cuOf(cp) {
     this._offsets ??= codeUnitOffsets(this._text);
     const at = Math.max(0, Math.min(this._offsets.length - 1, cp));