ntk 3.0.0 → 3.1.0

package/lib/app.js

@@ -18,6 +18,16 @@ export default class App {
     this.X = display.client;
     this.options = options;
     this._fonts = null;
+    // node-x11 emits X errors it cannot route to a request callback as
+    // 'error' on the client — from inside its packet parser. With no
+    // listener that emit throws and the parser never re-arms, silently
+    // wedging the connection (every later reply is dropped). Benign races
+    // (e.g. a request landing after its window was destroyed) become a
+    // warning instead; pass { onXError } to handle them yourself.
+    this.X.on('error', (err) => {
+      if (this.options.onXError) this.options.onXError(err);
+      else console.warn(`ntk: unhandled X error: ${err.message} (opcode ${err.majorOpcode}, seq ${err.seq})`);
+    });
   }
 
   /** the text API entry point: font matching/loading, shaping, layout */

package/lib/index.js

@@ -38,8 +38,10 @@ import './renderingcontext_opengl.js';
  * @param {object} [options] passed through to x11.createClient
  *   (e.g. { display: ':1' }); ntk additionally understands
  *   { fontSource } — a pluggable system-font lookup (see docs/fonts.md) —
- *   and { glxVisual } — the visual id for getContext('opengl') in
- *   environments where `glxinfo` cannot be shelled out to
+ *   { glxVisual } — the visual id for getContext('opengl') in
+ *   environments where `glxinfo` cannot be shelled out to — and
+ *   { onXError } — called with X protocol errors no request callback
+ *   claimed (default: console.warn)
  * @param {function} [callback] optional node-style callback
  * @returns {Promise<App>}
  */
@@ -120,4 +122,8 @@ export {
   configureTex,
   highlightCode
 };
+// the yoga-layout instance ntk lays HtmlView out with — downstream layout
+// consumers (e.g. the react-x11 renderer) must share it to avoid loading a
+// second WASM copy with potentially mismatched enums
+export { default as Yoga } from 'yoga-layout';
 export default { createClient };

package/lib/window.js

@@ -6,6 +6,31 @@ import Drawable from './drawable.js';
 import Pixmap from './pixmap.js';
 import * as xevents from './events_map.js';
 
+// X window attributes forwarded verbatim from constructor args into the
+// CreateWindow value list (node-x11 valueMask names, see x11
+// lib/corereqs.js). Deliberately not forwarded:
+//  - eventMask: computed from the onXxx handler args (an explicit
+//    args.eventMask is OR-ed into the computed mask instead)
+//  - backingStore: ntk's `backingStore: false` creation option opts out of
+//    client-side double buffering (see docs/window.md) and predates this
+//    list — it is a different concept from the X backing-store attribute,
+//    which is therefore not forwarded to avoid a silent collision
+const forwardedXAttributes = [
+  'backgroundPixmap',
+  'backgroundPixel',
+  'borderPixmap',
+  'borderPixel',
+  'bitGravity',
+  'winGravity',
+  'backingPlanes',
+  'backingPixel',
+  'overrideRedirect',
+  'saveUnder',
+  'doNotPropagateMask',
+  'colormap',
+  'cursor'
+];
+
 export default class Window extends Drawable {
   // one wrapper per X window id and connection: constructing a Window for a
   // known id returns the cached instance
@@ -25,6 +50,8 @@ export default class Window extends Drawable {
     this.app = app;
     this.display = app.display;
     this._mapped = false;
+    this._destroyed = false;
+    this._titleSerial = 0;
     this._readyPromiseResolve = null;
     this._readyPromise = new Promise((resolve) => {
       this._readyPromiseResolve = resolve;
@@ -68,17 +95,25 @@ export default class Window extends Drawable {
         }
       }
 
+      if (typeof args.eventMask === 'number') {
+        this.eventMask |= args.eventMask;
+      }
+
       this.width = args.width ?? 800;
       this.height = args.height ?? 800;
       this.x = args.x ?? 0;
       this.y = args.y ?? 0;
-      X.CreateWindow(this.id, parentId, this.x, this.y, this.width, this.height, 0, 0, 0, 0, {
+      const values = {
         // NorthWest bit gravity: keep the old content anchored during
         // resize instead of discarding it (less flicker between the resize
         // and our redraw)
         bitGravity: 1,
         eventMask: this.eventMask
-      });
+      };
+      for (const name of forwardedXAttributes) {
+        if (args[name] !== undefined) values[name] = args[name];
+      }
+      X.CreateWindow(this.id, parentId, this.x, this.y, this.width, this.height, 0, 0, 0, 0, values);
     } else {
       this.id = args.id;
       this.eventMask = 0;
@@ -171,6 +206,7 @@ export default class Window extends Drawable {
     this.on('map', () => (this._mapped = true));
     this.on('unmap', () => (this._mapped = false));
     this.on('destroy', () => {
+      this._destroyed = true;
       this._forget();
       this._teardownFrame();
       // the server frees window-backed pictures with the window — let
@@ -537,14 +573,26 @@ export default class Window extends Drawable {
   }
 
   setTitle(title) {
-    this.X.ChangeProperty(
-      0,
-      this.id,
-      this.X.atoms.WM_NAME,
-      this.X.atoms.STRING,
-      8,
-      title
-    );
+    const X = this.X;
+    const wid = this.id;
+    // legacy WM_NAME is latin-1 only (node-x11 encodes plain strings as
+    // latin1) — kept for old window managers
+    X.ChangeProperty(0, wid, X.atoms.WM_NAME, X.atoms.STRING, 8, title);
+    // modern WMs prefer the EWMH _NET_WM_NAME property, which is UTF-8;
+    // interned atoms are cached by node-x11, so this round-trips only once.
+    // The lookups are async: by the time they resolve the window may be
+    // destroyed (ChangeProperty would BadWindow) or retitled (an older
+    // write would clobber a newer one) — the serial/destroyed guards drop
+    // the stale write in both cases.
+    const serial = ++this._titleSerial;
+    X.InternAtom(false, '_NET_WM_NAME', (err, netWmName) => {
+      X.InternAtom(false, 'UTF8_STRING', (err2, utf8String) => {
+        if (err || err2 || this._destroyed || serial !== this._titleSerial) return;
+        safeRelease(X, () => {
+          X.ChangeProperty(0, wid, netWmName, utf8String, 8, Buffer.from(title, 'utf8'));
+        });
+      });
+    });
     return this;
   }
 
@@ -622,6 +670,7 @@ export default class Window extends Drawable {
   }
 
   destroy() {
+    this._destroyed = true;
     this._forget();
     this._teardownFrame();
     this.emit('_destroyed');

package/package.json

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