react-x11 2.47.4 → 2.48.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-x11",
-  "version": "2.47.4",
+  "version": "2.48.0",
   "description": "react renderer with X11 as a target",
   "main": "./src/index.js",
   "files": [
@@ -109,7 +109,7 @@
     "yoga-layout": "^3.2.1"
   },
   "optionalDependencies": {
-    "@windowkit/appkit": "^0.28.0",
+    "@windowkit/appkit": "^0.29.0",
     "@windowkit/wayland": "^3.1.1",
     "@windowkit/win32": "^0.0.9",
     "dbus-native": "^0.16.0",

package/src/cocoa/app.js

@@ -71,6 +71,9 @@ const PUMP_INTERVAL_MS = 8;
 // to 100, docs/windows.md §"Resize"). `createRoot({ cocoa: { resizeWait } })`
 // sets it; 0 is no handshake at all.
 const RESIZE_WAIT_MS = 50;
+// What `createRoot({ cocoa: { paneStretch } })` and
+// REACT_X11_COCOA_PANE_STRETCH take (src/cocoa/panehost.js, `_stretch`).
+const PANE_STRETCH = ['behind', 'never', 'always'];
 // How often the screen layout is re-read while something is watching it, in
 // ms. There is no event to wait for — the bridge keeps its `NSScreen` copy
 // current on macOS's notification and emits nothing (#617) — so
@@ -149,6 +152,24 @@ export class CocoaApp {
       );
     }
     this._resizeWait = resizeWait;
+    // How a `<Frame>` pane's last frame is shown while the frame of the
+    // size its layer was just given is on its way (src/cocoa/panehost.js,
+    // `_stretch`): 'behind' stretches it across once the pane falls behind
+    // `resizeWait`, 'never' keeps it at its size however late the pane is,
+    // and 'always' stretches it both ways. Apart from `resizeWait`, which
+    // is also how long AppKit holds the window's edge for a frame, so a
+    // pane that is never to be stretched would otherwise need a budget
+    // that held the drag back as long.
+    const paneStretch =
+      options.cocoa?.paneStretch ??
+      (process.env.REACT_X11_COCOA_PANE_STRETCH || 'behind');
+    if (!PANE_STRETCH.includes(paneStretch)) {
+      throw new TypeError(
+        'react-x11: cocoa.paneStretch (REACT_X11_COCOA_PANE_STRETCH) is ' +
+          `one of ${PANE_STRETCH.join(', ')} — got ${paneStretch}.`,
+      );
+    }
+    this._paneStretch = paneStretch;
 
     // The activation policy has to be fixed before the app finishes
     // launching — a Regular launch registers a Dock tile, so an agent app

package/src/cocoa/dnd.js

@@ -34,7 +34,8 @@
 // the pasteboard, so an in-app drop still gets `e.items` by reference and
 // `e.source === 'internal'`, the contract the X11 transport keeps. Other
 // applications read the pasteboard, where a thunk is a promise the bridge
-// asks `provide` to keep.
+// asks `provide` to keep — on the main thread. On a worker the bridge takes
+// no `provide`, and a thunk resolves as the drag begins (`dragSpec`).
 //
 // ## Types
 //
@@ -223,6 +224,16 @@ export const wire = (value) =>
  * to keep. The files thunk alone resolves now, because the items cannot
  * be counted without it.
  *
+ * Unless the app is on a worker (`upFront`, threaded mode): AppKit asks a
+ * provider from inside its own callback on the main thread, which a worker
+ * cannot answer in time, so the bridge refuses `provide` there with a
+ * TypeError. That was every drag on a Mac, since an app runs on a worker
+ * by default. There every thunk resolves now, as the win32 backend has
+ * them, and this is the external promotion `_resolve` caches for: an
+ * in-app drop is handed the same value by reference. A value that resolves
+ * to nothing, or that JSON cannot carry (a cycle, a node), is left off
+ * the pasteboard rather than failing the drag; an in-app drop still has it.
+ *
  * No image, and so no slide-back. The picture of the drag is the app's own
  * `<popup dragPreview>`; what the system session carries is a blank 1×1.
  * Left at AppKit's default, a refused or cancelled drop plays
@@ -236,7 +247,7 @@ export const wire = (value) =>
  * to animate from `onDragEnd`. Not a seam: there is no system image for
  * a caller to want slid back.
  */
-export function dragSpec(session, native, scale) {
+export function dragSpec(session, native, scale, { upFront = false } = {}) {
   const types = session.types;
   const reverse = new Map(); // uti -> react-x11 type
   const items = [];
@@ -256,7 +267,17 @@ export function dragSpec(session, native, scale) {
     if (!uti || uti in first) continue;
     reverse.set(uti, type);
     const raw = session._data[type];
-    first[uti] = typeof raw === 'function' ? null : wire(raw);
+    if (!upFront) {
+      first[uti] = typeof raw === 'function' ? null : wire(raw);
+      continue;
+    }
+    const value = session._resolve(type);
+    if (value == null) continue;
+    try {
+      first[uti] = wire(value);
+    } catch {
+      // not something the pasteboard can carry; the in-app drop has it
+    }
   }
   if (Object.keys(first).length) {
     if (items.length) Object.assign(items[0], first);
@@ -269,7 +290,11 @@ export function dragSpec(session, native, scale) {
     items,
     operations: session.actions,
     slideBack: false,
-    provide: (uti) => wire(session._resolve(reverse.get(uti) ?? uti)),
+    ...(upFront
+      ? null
+      : {
+          provide: (uti) => wire(session._resolve(reverse.get(uti) ?? uti)),
+        }),
   };
 }
 

package/src/cocoa/panehost.js

@@ -91,7 +91,8 @@ class PaneLayer {
    * and a smeared strip. The budget is the window's live-resize
    * handshake's (`createRoot({ cocoa: { resizeWait } })`), how long a frame
    * of a new size may take before the old one is shown in its place: 0
-   * stretches always, both ways, as before.
+   * stretches always, both ways, as before. And the app may say otherwise
+   * whatever the budget (`_stretch`).
    *
    * Down the layer the frame is at its size whatever this says. A width
    * moves where a page's lines break, and what comes is a page laid out
@@ -116,8 +117,9 @@ class PaneLayer {
    * decides the rest (`_answered`).
    */
   _anchoredNow() {
+    const stretch = this._stretch();
+    if (stretch !== 'behind') return stretch === 'never';
     const budget = this.app._resizeWait ?? RESIZE_WAIT_MS;
-    if (!(budget > 0)) return false;
     // a size asked longer ago than the budget, and no frame of any since
     const oldest = this._asked[0];
     if (oldest && now() - Math.max(oldest.at, this._answeredAt) > budget) {
@@ -126,6 +128,23 @@ class PaneLayer {
     return !this._behind;
   }
 
+  /**
+   * When the frame the layer holds is stretched to bounds that are not its
+   * size: `'behind'`, across, once the pane falls behind the budget
+   * (`_anchoredNow`); `'never'`, kept at its size and its edge carried over
+   * however late the pane is; `'always'`, both ways, Core Animation's own.
+   * The app's `cocoa.paneStretch` (REACT_X11_COCOA_PANE_STRETCH), and
+   * `'behind'` where it names none, or `'always'` at a budget of 0, which
+   * waits for no frame. An app that says `'never'` was not served by the
+   * budget: as long as AppKit holds the window's edge for a frame, so a
+   * budget a slow page never misses held every step of the drag back.
+   */
+  _stretch() {
+    const stretch = this.app._paneStretch ?? 'behind';
+    if (stretch !== 'behind') return stretch;
+    return (this.app._resizeWait ?? RESIZE_WAIT_MS) > 0 ? 'behind' : 'always';
+  }
+
   /**
    * The props that show the frame the layer holds in bounds that are not
    * its size, where they changed. At its size and from the top left, as a
@@ -138,7 +157,8 @@ class PaneLayer {
    * the frame is stretched, and down it is still at its size
    * (`_anchoredNow`): the whole of each row stretched to the new width,
    * cropped or with its last row carried down. Both rects are the whole
-   * when the frame is the layer's size, and at a budget of 0.
+   * when the frame is the layer's size, and where it is stretched always
+   * (`_stretch`).
    *
    * Anchored by gravity alone, the strip the frame did not cover showed
    * whatever was under the pane, which is the `<Frame>`'s background: in
@@ -159,8 +179,7 @@ class PaneLayer {
     const rect = this._rect;
     let crop = null;
     let edge = null;
-    const budget = this.app._resizeWait ?? RESIZE_WAIT_MS;
-    if (frame && rect && budget > 0) {
+    if (frame && rect && this._stretch() !== 'always') {
       // across at its size while the pane keeps up, and down always; an
       // axis stretched is shown whole, the frame's every column across
       const across = this._anchoredNow();

package/src/cocoa/window.js

@@ -520,7 +520,9 @@ export class CocoaWindow {
     if (this.destroyed) return null;
     const began = this._native.beginDrag(
       this._h,
-      dragSpec(session, this._native, this.scale),
+      dragSpec(session, this._native, this.scale, {
+        upFront: this.app._threaded,
+      }),
     );
     this.app._afterInput();
     return began;

package/src/index.d.ts

@@ -306,6 +306,11 @@ export interface RootOptions {
    * the next comes, and past it, it is stretched across to the pane's new
    * width and stays at its size down it; at 0 every one is stretched both
    * ways.
+   * `paneStretch` says when a `<Frame>` pane's last frame is stretched
+   * instead, whatever `resizeWait` is: `'behind'` (the default) as above,
+   * `'never'` keeps it at its size however late the pane's next frame is,
+   * and `'always'` stretches it both ways. `REACT_X11_COCOA_PANE_STRETCH`
+   * says the same from the environment.
    * `screenPoll` is how often the screen layout is re-read while a
    * {@link useScreens} subscriber is mounted, in ms — 500 by default, 0 for
    * never. macOS has no event for a display plugged in, unplugged or
@@ -333,6 +338,7 @@ export interface RootOptions {
     frameInterval?: number;
     pumpInterval?: number;
     resizeWait?: number;
+    paneStretch?: 'behind' | 'never' | 'always';
     screenPoll?: number;
     appName?: string;
     activationPolicy?: 'regular' | 'accessory' | 'prohibited';

package/src/nodes/window/floors.js

@@ -333,7 +333,8 @@ export function dirtyOutside(node, boundaries, paths) {
  * Undefined where it cannot be summed: a child with no extent on hand, a
  * negative margin (the boxes would overlap, and the last would not have to
  * be the lowest), or nothing in flow at all — a leaf's answer, which is
- * `contentSpan`'s to give.
+ * `contentSpan`'s to give. All but the first are the column's own, and a
+ * spine never sums a column that has them (`columnSums`).
  */
 export function columnHeightSpan(node) {
   const yoga = node.yoga;
@@ -363,6 +364,30 @@ export function columnHeightSpan(node) {
   );
 }
 
+/**
+ * Whether `columnHeightSpan` has an answer for this column once its children
+ * carry extents: everything else it asks — something in flow, margins down
+ * that are lengths and pull no box over the one before it, a gap that is a
+ * length — asked ahead of the measurement, from the same readings.
+ *
+ * A spine asks it before it sums a column (`isSummableColumn`), because once
+ * the measurement is under way a sum with no answer has nowhere to go: it is
+ * written as the column's extent, an extent of none writes the style's own
+ * minimum, and the column — and every column summed above it — lost its
+ * floor to a label that changed beside a block with `marginTop: -4`.
+ */
+export function columnSums(node) {
+  if (columnGap(node) === undefined) return false;
+  let count = 0;
+  for (const child of node.children) {
+    if (!inFlow(child)) continue;
+    const { top, bottom } = marginsDown(child);
+    if (!(top >= 0 && bottom >= 0)) return false;
+    count += 1;
+  }
+  return count !== 0;
+}
+
 /**
  * `marginDown` for both edges of a box, kept on the box with the style object
  * it was read under. A margin reaches yoga only from the style

package/src/nodes/window/spine.js

@@ -36,6 +36,7 @@
 // length — is not a spine, and the tree is measured whole.
 
 import {
+  columnSums,
   declaresOwnMinimum,
   inFlow,
   mainAxisOf,
@@ -74,7 +75,9 @@ const PADDINGS = [
  * main axis without wrapping, and with a height that is its content's —
  * nothing named on the height axis (`declaresOwnMinimum`), so neither a
  * size, a floor, a ceiling nor a clip stands between its children and its
- * extent.
+ * extent. And one the sum has an answer for (`columnSums`): a column with a
+ * block pulled up over the one before it is measured, as a root, rather
+ * than summed into no extent and no floor.
  */
 export function isSummableColumn(node) {
   const style = node.style;
@@ -86,7 +89,8 @@ export function isSummableColumn(node) {
     mainAxisOf(node) === 'height' &&
     style.flexDirection !== 'column-reverse' &&
     (style.flexWrap == null || style.flexWrap === 'nowrap') &&
-    !declaresOwnMinimum(node, 'height')
+    !declaresOwnMinimum(node, 'height') &&
+    columnSums(node)
   );
 }
 
@@ -129,6 +133,17 @@ export function spineScope(root, sources, listOnly) {
   const spine = new Set();
   const stops = new Set();
   const offered = new OfferedWidths(root);
+  // asked once a column: a dozen rows that arrive in one column of a
+  // thousand ask it of that column a dozen times (`columnSums`)
+  const summable = new Map();
+  const sums = (column) => {
+    let answer = summable.get(column);
+    if (answer === undefined) {
+      answer = isSummableColumn(column);
+      summable.set(column, answer);
+    }
+    return answer;
+  };
   for (const source of sources) {
     const list = listOnly(source);
     // the way up to where the change stops mattering
@@ -148,7 +163,7 @@ export function spineScope(root, sources, listOnly) {
     let top = -1;
     for (let i = path.length - 1; i >= 0; i--) {
       const summed = i > 0 || list;
-      if (!summed || !isSummableColumn(path[i])) {
+      if (!summed || !sums(path[i])) {
         top = i;
         break;
       }
@@ -379,6 +394,9 @@ function rootWidths(node, offered, stop) {
   if (!stretched(node)) return null;
   if (MARGINS.some((key) => typeof style[key] === 'string')) return null;
   if (PADDINGS.some((key) => typeof style[key] === 'string')) return null;
+  // …nor a gap that is a share of something: laid out alone, it is a share
+  // of something else
+  if (typeof (style.rowGap ?? style.gap) === 'string') return null;
   return offered.in(parent, stop);
 }