react-x11 2.22.8 → 2.22.10

package/src/nodes/paint.js

@@ -318,13 +318,22 @@ export class NodePaint {
     return false;
   }
 
-  _paintChildren(ctx) {
+  /**
+   * The children, in paint order — or those up to and including `upTo`: an
+   * X11 pane over a `<glarea>` holds its own child and what is under it,
+   * never what is over it (src/gloverlay.js, `_paintPane`).
+   */
+  _paintChildren(ctx, upTo = null) {
     // A retained presenter replays a node's `paint` into a visual of that
     // node's own — its children have visuals of their own, so it sets this
     // for the duration of the call (src/cocoa/presenter.js, `paintSelf`).
     // Never set on the X11 or surface paths, where a frame is one walk.
     if (this._ownPaintOnly) return;
-    const order = this.paintOrder();
+    let order = this.paintOrder();
+    if (upTo !== null) {
+      const at = order.indexOf(upTo);
+      if (at !== -1) order = order.slice(0, at + 1);
+    }
     if (order.length === 0) return;
     if (!this.clipsChildren()) {
       this._paintChildList(ctx, order);

package/src/nodes/window/floors.js

@@ -104,8 +104,9 @@ export const mainAxisOf = (node) => {
 /**
  * Whether `child` is one the floors are **written on** along `axis`: a flex
  * item on its container's main axis whose author left the minimum to the
- * content. The same test `writeFloors` applies, asked ahead of time — it is
- * what decides whether a stale extent is one anybody will read.
+ * content, and which flex could squeeze below it. The same test
+ * `writeFloors` applies, asked ahead of time — it is what decides whether a
+ * stale extent is one anybody will read.
  */
 export function receivesFloor(child, axis) {
   const parent = child.parent;
@@ -118,7 +119,37 @@ export function receivesFloor(child, axis) {
     return false;
   }
   const own = axis === 'width' ? 'minWidth' : 'minHeight';
-  return typeof child.style[own] !== 'number';
+  return typeof child.style[own] !== 'number' && !floorIsNamedSize(child, axis);
+}
+
+/**
+ * Whether this item is its named size on `axis` in every pass, so that the
+ * floor a measurement would write is that same number and can never bind:
+ * a number for its size along the axis, as its flex basis (`flexBasis` unset
+ * or `'auto'`), `flexShrink: 0` and no `flexGrow`. Flex then takes its basis
+ * from that number and neither shrinks nor grows it, and measuring it is work
+ * nobody reads. A table's cells, at their columns' widths, are the case that
+ * paid: every row that scrolled into a `<Table>` was laid out alone for their
+ * floors before its frame could be, over half of a fling's frame time.
+ *
+ * A differential run over random trees, laid out with and without the
+ * rule, found why each clause is there. An auto basis is yoga's own
+ * measurement of the content, which can come out short of what the content
+ * needs, and the floor is what holds the item open. A named size that can
+ * grow is written as the size it grew to in the measuring pass, which the
+ * floor then keeps. And a `flexBasis` of its own is where the basis comes
+ * from instead of the size, and a percentage one is a different length in a
+ * measuring pass than in the real one.
+ */
+function floorIsNamedSize(child, axis) {
+  const style = child.style;
+  const basis = style.flexBasis;
+  return (
+    style.flexShrink === 0 &&
+    !(style.flexGrow > 0) &&
+    (basis === undefined || basis === 'auto') &&
+    typeof (axis === 'width' ? style.width : style.height) === 'number'
+  );
 }
 
 /**
@@ -848,7 +879,12 @@ export function writeFloors(node, axis) {
     // A floor of 0 is what yoga does anyway, and an author who named their
     // own `minWidth`/`minHeight` has already answered — overwriting it would
     // put a measurement of ours above a number they wrote.
-    if (axisIsMain && inFlow(child) && typeof child.style[own] !== 'number') {
+    if (
+      axisIsMain &&
+      inFlow(child) &&
+      typeof child.style[own] !== 'number' &&
+      !floorIsNamedSize(child, axis)
+    ) {
       const extent = horizontal ? child._floorW : child._floorH;
       if (extent > 0) floor = extent;
     }

package/src/win32/a11y.js

@@ -33,24 +33,21 @@ import {
 } from '../a11y.js';
 import { synthesizeClick } from '../events.js';
 import { onApp } from '../trace-registry.js';
+import { A11yPacer } from '../a11ypace.js';
 
 const TRACE = process.env.REACT_X11_TRACE_A11Y === '1';
 
-/**
- * How often commits may push the mirror, in ms. A commit that follows a
- * quiet spell pushes at once; a stream of them — a pan, a drag, a value
- * ticking — pushes once per interval, the last of them catching up.
- *
- * UIA's clients are almost always listening on a desktop Windows (the
- * touch keyboard, the text services and others ask for the tree), so the
- * push is not the rare case the listening gate makes it elsewhere: a walk
- * of the window and a marshalled diff, on every commit. For a graph pane
- * whose every item moves on every step of a pan that was 1.6 ms of each
- * frame. A screen reader reads positions on demand and does not need
- * sixty of them a second; a focus change, which it is waiting on, still
- * pushes at once (`hooks.focus`), as does an announcement.
- */
-const COMMIT_PUSH_MS = 100;
+// How often commits may push the mirror is src/a11ypace.js's to say, for
+// this bridge and the AT-SPI one alike: at once after a quiet spell, and for
+// a stream of commits (a pan, a drag, a value ticking) once per interval,
+// the last push catching up. UIA's clients are almost always listening on a
+// desktop Windows (the touch keyboard, the text services and others ask for
+// the tree), so pushing is not the rare case the listening gate makes it
+// elsewhere. For a graph pane whose every item moves on every step of a pan,
+// a push per commit was 1.6 ms of each frame. A screen reader reads positions
+// on demand and does not need sixty of them a second. What it does wait on
+// is pushed at once: a focus change (`hooks.focus`), an announcement, and a
+// change to the focused element itself (`_touch`).
 
 // --------------------------------------------------------------------------
 // The one translation that is Windows' own
@@ -316,9 +313,12 @@ export class Win32Accessibility {
     this._pushed = new Set();
     this._unsubscribes = [];
     this.dead = false;
-    /** When a commit last pushed, and the push a stream of commits owes. */
-    this._lastCommitPush = -Infinity;
-    this._trailing = null;
+    /** When commits may push (src/a11ypace.js). */
+    this._pacer = new A11yPacer();
+    /** The focused node, and whether a commit changed it: its own changes
+     *  are what a screen reader is waiting to hear, and are not paced. */
+    this._focused = null;
+    this._urgentPending = false;
   }
 
   _idOf(node) {
@@ -454,23 +454,21 @@ export class Win32Accessibility {
     }
   }
 
-  /** A commit's push, at most once per `COMMIT_PUSH_MS`. */
+  /** A commit's push, paced (src/a11ypace.js), and at once where it
+   *  changed the focused element. */
   _commitFlush() {
     if (this.dead || this._dirty.size === 0) return;
-    const now = performance.now();
-    const wait = this._lastCommitPush + COMMIT_PUSH_MS - now;
-    if (wait <= 0) {
-      this._lastCommitPush = now;
-      this.flush();
-      return;
+    const urgent = this._urgentPending;
+    this._urgentPending = false;
+    if (urgent) this._pacer.cancel();
+    if (urgent || this._pacer.ready(() => this._pacedFlush())) {
+      this._pacedFlush();
     }
-    if (this._trailing) return;
-    this._trailing = setTimeout(() => {
-      this._trailing = null;
-      this._lastCommitPush = performance.now();
-      this.flush();
-    }, wait);
-    this._trailing.unref?.();
+  }
+
+  _pacedFlush() {
+    this._pacer.pushed();
+    this.flush();
   }
 
   /** A window's HWND exists now, so what is owed for it can be pushed. */
@@ -501,9 +499,19 @@ export class Win32Accessibility {
     return root && this.toplevels.includes(root) ? root : null;
   }
 
-  _touch(node) {
+  /** `own`: the change is the node's own (its props or text), which is
+   *  urgent where the node is, or is inside, the focused element. */
+  _touch(node, own = false) {
     const win = this._toplevelOf(node);
-    if (win) this._dirty.add(win);
+    if (!win) return;
+    this._dirty.add(win);
+    if (!own || this._focused === null || this._urgentPending) return;
+    for (let n = node; n; n = n.parent) {
+      if (n === this._focused) {
+        this._urgentPending = true;
+        return;
+      }
+    }
   }
 
   // ---- what the shell asks for ------------------------------------------
@@ -594,10 +602,11 @@ export class Win32Accessibility {
     };
     hooks.attached = (parent) => this._touch(parent);
     hooks.detach = (parent) => this._touch(parent);
-    hooks.propsChanged = (node) => this._touch(node);
-    hooks.textContent = (chunk) => this._touch(chunk.parent ?? chunk);
-    hooks.textState = (node) => this._touch(node);
+    hooks.propsChanged = (node) => this._touch(node, true);
+    hooks.textContent = (chunk) => this._touch(chunk.parent ?? chunk, true);
+    hooks.textState = (node) => this._touch(node, true);
     hooks.focus = (previous, next) => {
+      this._focused = next ?? null;
       const win = this._toplevelOf(next ?? previous);
       if (!win) return;
       this._dirty.add(win);
@@ -637,8 +646,7 @@ export class Win32Accessibility {
   bury() {
     if (this.dead) return;
     this.dead = true;
-    if (this._trailing) clearTimeout(this._trailing);
-    this._trailing = null;
+    this._pacer.cancel();
     for (const key of Object.keys(hooks)) hooks[key] = null;
     for (const unsubscribe of this._unsubscribes) unsubscribe();
     this._unsubscribes = [];