react-x11 2.47.5 → 2.48.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-x11",
-  "version": "2.47.5",
+  "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';