react-native-gtkx 0.2.0-alpha.2 → 0.3.0-alpha.1

package/dist/gtkx/bridge/view-box.js

@@ -1,14 +1,37 @@
-// RnGtkxViewBox — the GtkBox subclass every View renders. Its contains()
-// consults a per-widget flag: a "pass-through" box is never returned by
-// GTK's pick (RN pointerEvents="box-none" — the box is transparent while
-// children stay pickable, and toggling the mode never remounts the
-// subtree); otherwise it reproduces the default bounds check. Registered
-// lazily like RnGtkxLayout (registration needs GObject, class identity
-// must exist before the first instance).
+// RnGtkxViewBox — the GtkBox subclass every View renders — and the whole of
+// RN's pointerEvents, which is a picking question and therefore lives here.
+//
+// Two of the four modes are the box's own contains(): "box-none" makes it
+// invisible to GTK's pick while its children stay pickable, and hitSlop
+// grows the rect the check uses. The other two are can-target on the widget
+// ("none", the whole subtree) or on its children ("box-only").
+//
+// can-target is a single boolean per widget and TWO things want to write it
+// — the widget's own pointerEvents, and a box-only ancestor masking it — so
+// neither may write it directly. `setPointerTarget` records what the
+// widget's own prop wants and applies the combination; the mask is derived
+// from the live parent every time, so a widget that React moves elsewhere
+// cannot end up stuck untargetable. Blanket-restoring children to `true` is
+// what made nesting a pointerEvents inside a box-only view unsupported
+// before: the restore pass could not know that a child wanted to be
+// untargetable for its own reasons.
+//
+// `zIndex` is the other half of the same subject and lives here for the same
+// reason: RN's z-order is a PAINT order and a PICK order, and this widget is
+// the only thing that owns both. See the block above the zIndex section below.
+//
+// Registered lazily like RnGtkxLayout (registration needs GObject, class
+// identity must exist before the first instance).
+import * as Graphene from "@gtkx/gi/graphene";
 import * as Gtk from "@gtkx/gi/gtk";
 import { createElementComponent } from "@gtkx/react/internal";
 import { registerClass } from "@gtkx/runtime";
 const passthrough = new WeakSet();
+/** Widgets whose DIRECT children are masked — RN's pointerEvents="box-only". */
+const boxOnly = new WeakSet();
+/** What each widget's own pointerEvents wants, before any mask. */
+const ownTarget = new WeakMap();
+const hitSlops = new WeakMap();
 /** box-none toggle: picking consults this live, no invalidation needed. */
 export const setBoxPassthrough = (widget, enabled) => {
     if (enabled) {
@@ -18,6 +41,329 @@ export const setBoxPassthrough = (widget, enabled) => {
         passthrough.delete(widget);
     }
 };
+/**
+ * Grows the rect this widget's contains() accepts. Only RnGtkxViewBox
+ * consults it — RN's hitSlop is a picking change and nothing in JS can
+ * substitute for one, because a press outside the widget is never delivered
+ * to it in the first place.
+ */
+export const setHitSlop = (widget, slop) => {
+    if (slop === null) {
+        hitSlops.delete(widget);
+    }
+    else {
+        hitSlops.set(widget, slop);
+    }
+};
+const isMasked = (widget) => {
+    const parent = widget.getParent();
+    return parent !== null && boxOnly.has(parent);
+};
+const applyTarget = (widget) => {
+    widget.setCanTarget(!isMasked(widget) && (ownTarget.get(widget) ?? true));
+};
+/**
+ * What this widget's own `pointerEvents` wants its can-target to be. A
+ * box-only ancestor still overrides it, and stops overriding it the moment
+ * the ancestor's mode changes — without either of them having to know about
+ * the other.
+ */
+export const setPointerTarget = (widget, targetable) => {
+    ownTarget.set(widget, targetable);
+    applyTarget(widget);
+};
+/**
+ * Masks or unmasks a widget's direct children — RN's
+ * pointerEvents="box-only". Re-applied every commit rather than only on
+ * change, because the child set moves with the renders.
+ */
+export const setBoxOnly = (widget, enabled) => {
+    if (enabled) {
+        boxOnly.add(widget);
+    }
+    else {
+        boxOnly.delete(widget);
+    }
+    for (let child = widget.getFirstChild(); child !== null; child = child.getNextSibling()) {
+        applyTarget(child);
+    }
+};
+// --- zIndex ---------------------------------------------------------------
+//
+// RN's `zIndex` reorders PAINT among siblings. GTK4 paints a container's
+// children in child order and has no z-order property, so the obvious fix —
+// reorder the widgets — is the wrong one: widget order is the order this
+// platform keeps its shadow tree in sync with (`syncChildOrder` in
+// components/use-layout-child.ts), so restacking for paint would silently
+// restack the LAYOUT.
+//
+// Paint order and layout order do not have to be the same, though, and we own
+// the widget: `allocate` stays in Yoga's order and `snapshot` walks the
+// children in zIndex order instead. That is what Android does too
+// (`ViewGroup.getChildDrawingOrder`) and for the same reason.
+//
+// The half that is easy to miss is that `gtk_widget_pick()` descends in
+// REVERSE child order, so sorting the paint alone leaves a raised view drawn
+// on top and still unclickable. GTK4 has no `pick` vfunc (GtkWidgetClass's
+// public vtable ends at `contains`, verified against gtk 4.22's header and
+// gtkx's generated registry), and the only per-point hook it offers is
+// `contains()` — which is exactly the vfunc this file already overrides. So
+// picking is made to agree by having a covered widget answer "not me" where a
+// higher-painting sibling of one of its ancestors would answer instead.
+//
+// Everything below is behind `raisedCount`, which is 0 in every app that never
+// writes the style: one integer comparison, and both vfuncs take the path they
+// took before any of this existed.
+/** Non-zero zIndex per widget. Absent means 0, which is RN's default. */
+const zIndexes = new WeakMap();
+/**
+ * How many widgets in the process currently carry a non-zero `zIndex`.
+ *
+ * The fast path's whole guard. `snapshot()` and `contains()` read this first,
+ * so a tree that never raises anything pays one integer comparison per call
+ * and no allocation, no sort, and no per-child work beyond what GTK's own
+ * snapshot does.
+ */
+let raisedCount = 0;
+/**
+ * Cached paint order per container: an array in paint order, or `null` for
+ * "plain child order, nothing to do". Recomputed on change (a zIndex write, a
+ * commit that touched the container's children) rather than per snapshot —
+ * `useSortable` puts `zIndex` in its style object every frame but changes its
+ * VALUE about twice per drag.
+ */
+const paintOrders = new WeakMap();
+/**
+ * The container's live children, in child order, as the LAST ALLOCATE PASS
+ * walked them.
+ *
+ * The snapshot vfunc has to visit every child either way, and walking the
+ * sibling chain from JS is what costs: each `getNextSibling()` mints a fresh
+ * native wrapper, measured at 1.9 µs per child against 1.0 µs for the
+ * `snapshotChild()` that follows it (docs/research/z-index.md). The container's
+ * `allocate()` hook already walks exactly this chain, so it hands the array
+ * over instead and the paint pass reuses it.
+ *
+ * Safe because a child cannot appear, disappear or move without queueing a
+ * resize on this container, and GTK runs the layout phase before the paint
+ * phase — so an allocate always lands between a change and the snapshot that
+ * would see it. A container whose allocate never ran (no RnGtkxLayout, e.g. a
+ * bare slot host) simply has no entry, and the vfunc walks live.
+ */
+const childOrders = new WeakMap();
+const sameChildren = (a, b) => {
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let index = 0; index < a.length; index += 1) {
+        if (a[index] !== b[index]) {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * Publishes the child list the container's allocate pass just walked.
+ *
+ * Cheap on the hot path by construction: the array is one the caller built
+ * anyway, and the paint order is only invalidated when the children actually
+ * differ — an allocate for a pure move (which is most of them, one per
+ * animated frame) leaves the cached sort alone.
+ */
+export const cacheChildOrder = (container, children) => {
+    const previous = childOrders.get(container);
+    childOrders.set(container, children);
+    if (previous === undefined || !sameChildren(previous, children)) {
+        paintOrders.delete(container);
+    }
+};
+/** Containers known to hold at least one raised child, for the picking walk. */
+const zOrderedParents = new WeakSet();
+/**
+ * Widgets that paint but are not touch targets of their own: the GtkLabel a
+ * `Text` renders and the GtkPicture an `Image` renders. Neither component has
+ * a press prop, so nothing is ever attached to them — but GTK targets them by
+ * default, and `gtk_widget_pick()` reaches a child BEFORE it asks the parent's
+ * `contains()`. That is the one hole in the occlusion check below: a covered
+ * `View` can answer "not me", a bare GtkLabel inside it cannot.
+ *
+ * So while a container has a raised child, the paint-only leaves under it are
+ * made untargetable and the pick lands on their nearest `View` instead — which
+ * is the same widget the press would have propagated to anyway, and which does
+ * answer the occlusion question. Restored the moment nothing is raised there,
+ * because it is not free of consequence: `pointerEvents: "box-none"` on a View
+ * whose only child is a `Text` would otherwise fall through to whatever is
+ * behind it. Documented in docs/api.md.
+ */
+const paintOnlyLeaves = new WeakSet();
+/**
+ * Marks a widget as painting-only for picking purposes — see above. Called
+ * once per widget by the components that own one (`Text`, `Image`).
+ */
+export const setPaintOnlyLeaf = (widget) => {
+    paintOnlyLeaves.add(widget);
+};
+const applyLeafTargeting = (container, suppress) => {
+    for (let child = container.getFirstChild(); child !== null; child = child.getNextSibling()) {
+        if (paintOnlyLeaves.has(child)) {
+            setPointerTarget(child, !suppress);
+        }
+        // A nested container that is STILL raised keeps its own suppression: an
+        // outer container coming back down must not restore leaves an inner one
+        // is relying on.
+        if (suppress || !zOrderedParents.has(child)) {
+            applyLeafTargeting(child, suppress);
+        }
+    }
+};
+/**
+ * Drops a container's cached paint order and asks for a redraw.
+ *
+ * Called from the zIndex writer and from the container's per-commit effect
+ * (components/use-layout-child.ts), which is what covers a child mounting,
+ * unmounting or being MOVED by React — the three ways the order can change
+ * without any zIndex being written.
+ */
+export const invalidateZOrder = (container) => {
+    // The child list too: a commit is the one thing that can change it, and the
+    // allocate the commit queues puts a fresh one back before the next paint.
+    childOrders.delete(container);
+    if (!paintOrders.delete(container)) {
+        return;
+    }
+    container.queueDraw();
+    if (zOrderedParents.has(container)) {
+        // Recomputed now rather than at the next snapshot, for the same reason
+        // setZIndex does it: a container that just lost its last raised child
+        // (the commit that unmounted it) would otherwise never be asked again —
+        // the fast path stops calling paintOrderFor once nothing is raised — and
+        // would keep its paint-only leaves untargetable forever.
+        paintOrderFor(container);
+    }
+};
+/**
+ * RN's `zIndex` for one child. `0` (the default, and `undefined`) clears it.
+ *
+ * RN applies `zIndex` unconditionally — unlike CSS, which ignores `z-index`
+ * on a `position: static` box. Nothing here looks at `position` either.
+ */
+export const setZIndex = (widget, value) => {
+    const previous = zIndexes.get(widget) ?? 0;
+    if (previous === value) {
+        return;
+    }
+    if (value === 0) {
+        zIndexes.delete(widget);
+        raisedCount -= 1;
+    }
+    else {
+        zIndexes.set(widget, value);
+        if (previous === 0) {
+            raisedCount += 1;
+        }
+    }
+    const parent = widget.getParent();
+    if (parent === null) {
+        return;
+    }
+    paintOrders.delete(parent);
+    // Unconditional, unlike invalidateZOrder's: the container may never have
+    // had a cache to drop and its paint still just changed.
+    parent.queueDraw();
+    if (value === 0) {
+        // Recomputed eagerly on the way DOWN, never lazily: once nothing is
+        // raised the fast path stops calling paintOrderFor at all, so a container
+        // that lost its last raised child would never get the chance to undo what
+        // being raised did to it (paint order, leaf targeting).
+        paintOrderFor(parent);
+    }
+};
+/** The container's children, from the allocate pass if it has run. */
+const childrenOf = (container) => {
+    const cached = childOrders.get(container);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const children = [];
+    for (let child = container.getFirstChild(); child !== null; child = child.getNextSibling()) {
+        children.push(child);
+    }
+    return children;
+};
+const paintOrderFor = (container) => {
+    if (paintOrders.has(container)) {
+        return paintOrders.get(container) ?? null;
+    }
+    const children = childrenOf(container);
+    let raised = false;
+    for (const child of children) {
+        if (zIndexes.has(child)) {
+            raised = true;
+            break;
+        }
+    }
+    let order = null;
+    if (raised) {
+        zOrderedParents.add(container);
+        // Once per recompute, not per frame, and only for a container that
+        // actually has something raised: the walk is what catches a `Text` that
+        // mounted into an already-raised container since the last one.
+        applyLeafTargeting(container, true);
+        // Stable by construction. RN keeps document order among equal zIndexes,
+        // and an unstable sort would let equal siblings swap between frames —
+        // flicker that is miserable to attribute. `Array.prototype.sort` has been
+        // required to be stable since ES2019; the index tiebreak makes that
+        // independent of the engine rather than assumed of it.
+        order = children
+            .map((widget, index) => ({
+            widget,
+            index,
+            z: zIndexes.get(widget) ?? 0,
+        }))
+            .sort((a, b) => a.z - b.z || a.index - b.index)
+            .map((entry) => entry.widget);
+    }
+    else if (zOrderedParents.delete(container)) {
+        applyLeafTargeting(container, false);
+    }
+    paintOrders.set(container, order);
+    return order;
+};
+/**
+ * Whether a higher-painting sibling of this widget — or of any of its
+ * ancestors — would take the pick at this point.
+ *
+ * `pick()` on the sibling rather than a bounds test, because "would GTK have
+ * answered inside that subtree" IS the question, and it comes with the rest of
+ * RN's rules for free: a raised view with `pointerEvents: "none"` is not
+ * targetable, so it does not occlude either.
+ *
+ * The recursion terminates because it only ever asks about siblings STRICTLY
+ * higher in the same container's paint order.
+ */
+const isOccluded = (widget, x, y) => {
+    let child = widget;
+    let parent = child.getParent();
+    while (parent !== null) {
+        if (zOrderedParents.has(parent)) {
+            const order = paintOrderFor(parent);
+            if (order !== null) {
+                const index = order.indexOf(child);
+                for (let above = index + 1; above < order.length; above += 1) {
+                    const sibling = order[above];
+                    const [ok, point] = widget.computePoint(sibling, new Graphene.Point({ x, y }));
+                    if (ok &&
+                        sibling.pick(point.x, point.y, Gtk.PickFlags.DEFAULT) !== null) {
+                        return true;
+                    }
+                }
+            }
+        }
+        child = parent;
+        parent = child.getParent();
+    }
+    return false;
+};
 let component = null;
 export const getViewBoxComponent = () => {
     if (component) {
@@ -28,8 +374,47 @@ export const getViewBoxComponent = () => {
             if (passthrough.has(this)) {
                 return false;
             }
-            // The default widget behavior: inside the widget's own bounds.
-            return x >= 0 && y >= 0 && x < this.getWidth() && y < this.getHeight();
+            // GTK translates the point into this widget's coordinates before
+            // asking, and does not pre-check the bounds, so a negative x or a y
+            // past the height is a legitimate question — which is what lets
+            // hitSlop answer yes to it.
+            const slop = hitSlops.get(this);
+            const inside = slop === undefined
+                ? // The default widget behavior: inside the widget's own bounds.
+                    x >= 0 && y >= 0 && x < this.getWidth() && y < this.getHeight()
+                : x >= -slop.left &&
+                    y >= -slop.top &&
+                    x < this.getWidth() + slop.right &&
+                    y < this.getHeight() + slop.bottom;
+            if (!inside || raisedCount === 0) {
+                return inside;
+            }
+            // Something in this process is raised: this widget only answers where
+            // nothing painted above it would have.
+            return !isOccluded(this, x, y);
+        }
+        // GTK's own container snapshot is `gtk_widget_real_snapshot`, which walks
+        // first-to-last calling gtk_widget_snapshot_child — the loop below with
+        // nothing in front of it. There is no way to chain up to it from here
+        // (gtkx installs the vfunc but exposes no parent-class call, and
+        // gtk_widget_snapshot() is not public C API either), so the fast path
+        // reproduces it rather than delegating to it.
+        //
+        // No `override`: `snapshot` is a real vfunc in gtkx's codegen but is
+        // missing from the shipped gtk.d.ts (same as in svg-node.ts).
+        snapshot(snapshot) {
+            if (raisedCount !== 0) {
+                const order = paintOrderFor(this);
+                if (order !== null) {
+                    for (const child of order) {
+                        this.snapshotChild(child, snapshot);
+                    }
+                    return;
+                }
+            }
+            for (const child of childrenOf(this)) {
+                this.snapshotChild(child, snapshot);
+            }
         }
     }
     // Explicit typeName: bundlers minify class names.

package/dist/gtkx/bridge/view-box.js.map

@@ -1 +1 @@
-{"version":3,"file":"view-box.js","sourceRoot":"","sources":["../../../src/gtkx/bridge/view-box.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,wEAAwE;AACxE,yEAAyE;AACzE,mEAAmE;AACnE,yEAAyE;AACzE,uEAAuE;AACvE,yCAAyC;AACzC,OAAO,KAAK,GAAG,MAAM,cAAc,CAAA;AACnC,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAE7C,MAAM,WAAW,GAAG,IAAI,OAAO,EAAU,CAAA;AAEzC,2EAA2E;AAC3E,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,MAAkB,EAClB,OAAgB,EACV,EAAE;IACR,IAAI,OAAO,EAAE,CAAC;QACZ,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;IACzB,CAAC;SAAM,CAAC;QACN,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAC5B,CAAC;AACH,CAAC,CAAA;AAID,IAAI,SAAS,GAA4B,IAAI,CAAA;AAE7C,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAqB,EAAE;IACxD,IAAI,SAAS,EAAE,CAAC;QACd,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,MAAM,aAAc,SAAQ,GAAG,CAAC,GAAG;QACxB,QAAQ,CAAC,CAAS,EAAE,CAAS;YACpC,IAAI,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC1B,OAAO,KAAK,CAAA;YACd,CAAC;YACD,+DAA+D;YAC/D,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,SAAS,EAAE,CAAA;QACxE,CAAC;KACF;IACD,kDAAkD;IAClD,aAAa,CAAC,aAAa,EAAE,EAAE,QAAQ,EAAE,eAAe,EAAE,CAAC,CAAA;IAC3D,SAAS,GAAG,sBAAsB,CAAC,eAAe,CAAC,CAAA;IACnD,OAAO,SAAS,CAAA;AAClB,CAAC,CAAA","sourcesContent":["// RnGtkxViewBox — the GtkBox subclass every View renders. Its contains()\n// consults a per-widget flag: a \"pass-through\" box is never returned by\n// GTK's pick (RN pointerEvents=\"box-none\" — the box is transparent while\n// children stay pickable, and toggling the mode never remounts the\n// subtree); otherwise it reproduces the default bounds check. Registered\n// lazily like RnGtkxLayout (registration needs GObject, class identity\n// must exist before the first instance).\nimport * as Gtk from \"@gtkx/gi/gtk\"\nimport { createElementComponent } from \"@gtkx/react/internal\"\nimport { registerClass } from \"@gtkx/runtime\"\n\nconst passthrough = new WeakSet<object>()\n\n/** box-none toggle: picking consults this live, no invalidation needed. */\nexport const setBoxPassthrough = (\n  widget: Gtk.Widget,\n  enabled: boolean,\n): void => {\n  if (enabled) {\n    passthrough.add(widget)\n  } else {\n    passthrough.delete(widget)\n  }\n}\n\ntype ViewBoxComponent = ReturnType<typeof createElementComponent>\n\nlet component: ViewBoxComponent | null = null\n\nexport const getViewBoxComponent = (): ViewBoxComponent => {\n  if (component) {\n    return component\n  }\n\n  class RnGtkxViewBox extends Gtk.Box {\n    override contains(x: number, y: number): boolean {\n      if (passthrough.has(this)) {\n        return false\n      }\n      // The default widget behavior: inside the widget's own bounds.\n      return x >= 0 && y >= 0 && x < this.getWidth() && y < this.getHeight()\n    }\n  }\n  // Explicit typeName: bundlers minify class names.\n  registerClass(RnGtkxViewBox, { typeName: \"RnGtkxViewBox\" })\n  component = createElementComponent(\"RnGtkxViewBox\")\n  return component\n}\n"]}
+{"version":3,"file":"view-box.js","sourceRoot":"","sources":["../../../src/gtkx/bridge/view-box.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,4EAA4E;AAC5E,EAAE;AACF,0EAA0E;AAC1E,wEAAwE;AACxE,4EAA4E;AAC5E,+DAA+D;AAC/D,EAAE;AACF,4EAA4E;AAC5E,4EAA4E;AAC5E,qEAAqE;AACrE,2EAA2E;AAC3E,0EAA0E;AAC1E,4EAA4E;AAC5E,uEAAuE;AACvE,oEAAoE;AACpE,oCAAoC;AACpC,EAAE;AACF,6EAA6E;AAC7E,6EAA6E;AAC7E,+EAA+E;AAC/E,EAAE;AACF,yEAAyE;AACzE,kDAAkD;AAClD,OAAO,KAAK,QAAQ,MAAM,mBAAmB,CAAA;AAC7C,OAAO,KAAK,GAAG,MAAM,cAAc,CAAA;AACnC,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAC7D,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAE7C,MAAM,WAAW,GAAG,IAAI,OAAO,EAAU,CAAA;AACzC,gFAAgF;AAChF,MAAM,OAAO,GAAG,IAAI,OAAO,EAAU,CAAA;AACrC,mEAAmE;AACnE,MAAM,SAAS,GAAG,IAAI,OAAO,EAAmB,CAAA;AAShD,MAAM,QAAQ,GAAG,IAAI,OAAO,EAAmB,CAAA;AAE/C,2EAA2E;AAC3E,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,MAAkB,EAClB,OAAgB,EACV,EAAE;IACR,IAAI,OAAO,EAAE,CAAC;QACZ,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;IACzB,CAAC;SAAM,CAAC;QACN,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAC5B,CAAC;AACH,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,MAAkB,EAAE,IAAoB,EAAQ,EAAE;IAC3E,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QAClB,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IACzB,CAAC;SAAM,CAAC;QACN,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IAC5B,CAAC;AACH,CAAC,CAAA;AAED,MAAM,QAAQ,GAAG,CAAC,MAAkB,EAAW,EAAE;IAC/C,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,CAAA;IACjC,OAAO,MAAM,KAAK,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;AAC/C,CAAC,CAAA;AAED,MAAM,WAAW,GAAG,CAAC,MAAkB,EAAQ,EAAE;IAC/C,MAAM,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,CAAA;AAC3E,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,MAAkB,EAClB,UAAmB,EACb,EAAE;IACR,SAAS,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;IACjC,WAAW,CAAC,MAAM,CAAC,CAAA;AACrB,CAAC,CAAA;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,MAAkB,EAAE,OAAgB,EAAQ,EAAE;IACvE,IAAI,OAAO,EAAE,CAAC;QACZ,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;IACrB,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IACxB,CAAC;IACD,KACE,IAAI,KAAK,GAAG,MAAM,CAAC,aAAa,EAAE,EAClC,KAAK,KAAK,IAAI,EACd,KAAK,GAAG,KAAK,CAAC,cAAc,EAAE,EAC9B,CAAC;QACD,WAAW,CAAC,KAAK,CAAC,CAAA;IACpB,CAAC;AACH,CAAC,CAAA;AAED,6EAA6E;AAC7E,EAAE;AACF,yEAAyE;AACzE,4EAA4E;AAC5E,yEAAyE;AACzE,mEAAmE;AACnE,0EAA0E;AAC1E,sBAAsB;AACtB,EAAE;AACF,8EAA8E;AAC9E,wEAAwE;AACxE,kEAAkE;AAClE,8DAA8D;AAC9D,EAAE;AACF,wEAAwE;AACxE,6EAA6E;AAC7E,2EAA2E;AAC3E,2EAA2E;AAC3E,uEAAuE;AACvE,4EAA4E;AAC5E,8EAA8E;AAC9E,wEAAwE;AACxE,EAAE;AACF,+EAA+E;AAC/E,+EAA+E;AAC/E,mCAAmC;AAEnC,yEAAyE;AACzE,MAAM,QAAQ,GAAG,IAAI,OAAO,EAAsB,CAAA;AAElD;;;;;;;GAOG;AACH,IAAI,WAAW,GAAG,CAAC,CAAA;AAEnB;;;;;;GAMG;AACH,MAAM,WAAW,GAAG,IAAI,OAAO,EAAmC,CAAA;AAElE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,GAAG,IAAI,OAAO,EAA4B,CAAA;AAE3D,MAAM,YAAY,GAAG,CAAC,CAAe,EAAE,CAAe,EAAW,EAAE;IACjE,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAA;IACd,CAAC;IACD,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QACjD,IAAI,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,KAAK,CAAA;QACd,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,SAAqB,EACrB,QAAsB,EAChB,EAAE;IACR,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;IAC3C,WAAW,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAA;IACpC,IAAI,QAAQ,KAAK,SAAS,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC;QAChE,WAAW,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;IAC/B,CAAC;AACH,CAAC,CAAA;AAED,gFAAgF;AAChF,MAAM,eAAe,GAAG,IAAI,OAAO,EAAc,CAAA;AAEjD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,eAAe,GAAG,IAAI,OAAO,EAAc,CAAA;AAEjD;;;GAGG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,MAAkB,EAAQ,EAAE;IAC3D,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;AAC7B,CAAC,CAAA;AAED,MAAM,kBAAkB,GAAG,CAAC,SAAqB,EAAE,QAAiB,EAAQ,EAAE;IAC5E,KACE,IAAI,KAAK,GAAG,SAAS,CAAC,aAAa,EAAE,EACrC,KAAK,KAAK,IAAI,EACd,KAAK,GAAG,KAAK,CAAC,cAAc,EAAE,EAC9B,CAAC;QACD,IAAI,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YAC/B,gBAAgB,CAAC,KAAK,EAAE,CAAC,QAAQ,CAAC,CAAA;QACpC,CAAC;QACD,wEAAwE;QACxE,wEAAwE;QACxE,iBAAiB;QACjB,IAAI,QAAQ,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YAC5C,kBAAkB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;QACrC,CAAC;IACH,CAAC;AACH,CAAC,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,SAAqB,EAAQ,EAAE;IAC9D,4EAA4E;IAC5E,0EAA0E;IAC1E,WAAW,CAAC,MAAM,CAAC,SAAS,CAAC,CAAA;IAC7B,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;QACnC,OAAM;IACR,CAAC;IACD,SAAS,CAAC,SAAS,EAAE,CAAA;IACrB,IAAI,eAAe,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;QACnC,uEAAuE;QACvE,sEAAsE;QACtE,wEAAwE;QACxE,yEAAyE;QACzE,yDAAyD;QACzD,aAAa,CAAC,SAAS,CAAC,CAAA;IAC1B,CAAC;AACH,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,MAAkB,EAAE,KAAa,EAAQ,EAAE;IACnE,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAC1C,IAAI,QAAQ,KAAK,KAAK,EAAE,CAAC;QACvB,OAAM;IACR,CAAC;IACD,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QAChB,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;QACvB,WAAW,IAAI,CAAC,CAAA;IAClB,CAAC;SAAM,CAAC;QACN,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;QAC3B,IAAI,QAAQ,KAAK,CAAC,EAAE,CAAC;YACnB,WAAW,IAAI,CAAC,CAAA;QAClB,CAAC;IACH,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,CAAA;IACjC,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,OAAM;IACR,CAAC;IACD,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAC1B,yEAAyE;IACzE,wDAAwD;IACxD,MAAM,CAAC,SAAS,EAAE,CAAA;IAClB,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QAChB,oEAAoE;QACpE,0EAA0E;QAC1E,0EAA0E;QAC1E,wDAAwD;QACxD,aAAa,CAAC,MAAM,CAAC,CAAA;IACvB,CAAC;AACH,CAAC,CAAA;AAED,sEAAsE;AACtE,MAAM,UAAU,GAAG,CAAC,SAAqB,EAAgB,EAAE;IACzD,MAAM,MAAM,GAAG,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;IACzC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,MAAM,CAAA;IACf,CAAC;IACD,MAAM,QAAQ,GAAiB,EAAE,CAAA;IACjC,KACE,IAAI,KAAK,GAAG,SAAS,CAAC,aAAa,EAAE,EACrC,KAAK,KAAK,IAAI,EACd,KAAK,GAAG,KAAK,CAAC,cAAc,EAAE,EAC9B,CAAC;QACD,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IACtB,CAAC;IACD,OAAO,QAAQ,CAAA;AACjB,CAAC,CAAA;AAED,MAAM,aAAa,GAAG,CAAC,SAAqB,EAAuB,EAAE;IACnE,IAAI,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;QAC/B,OAAO,WAAW,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,IAAI,CAAA;IAC3C,CAAC;IACD,MAAM,QAAQ,GAAG,UAAU,CAAC,SAAS,CAAC,CAAA;IACtC,IAAI,MAAM,GAAG,KAAK,CAAA;IAClB,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;QAC7B,IAAI,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YACxB,MAAM,GAAG,IAAI,CAAA;YACb,MAAK;QACP,CAAC;IACH,CAAC;IACD,IAAI,KAAK,GAAwB,IAAI,CAAA;IACrC,IAAI,MAAM,EAAE,CAAC;QACX,eAAe,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;QAC9B,mEAAmE;QACnE,wEAAwE;QACxE,+DAA+D;QAC/D,kBAAkB,CAAC,SAAS,EAAE,IAAI,CAAC,CAAA;QACnC,wEAAwE;QACxE,sEAAsE;QACtE,0EAA0E;QAC1E,oEAAoE;QACpE,uDAAuD;QACvD,KAAK,GAAG,QAAQ;aACb,GAAG,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;YACvB,MAAM;YACN,KAAK;YACL,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC;SAC7B,CAAC,CAAC;aACF,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC;aAC9C,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IACjC,CAAC;SAAM,IAAI,eAAe,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;QAC7C,kBAAkB,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;IACtC,CAAC;IACD,WAAW,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;IACjC,OAAO,KAAK,CAAA;AACd,CAAC,CAAA;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,GAAG,CAAC,MAAkB,EAAE,CAAS,EAAE,CAAS,EAAW,EAAE;IACvE,IAAI,KAAK,GAAG,MAAM,CAAA;IAClB,IAAI,MAAM,GAAG,KAAK,CAAC,SAAS,EAAE,CAAA;IAC9B,OAAO,MAAM,KAAK,IAAI,EAAE,CAAC;QACvB,IAAI,eAAe,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;YAChC,MAAM,KAAK,GAAG,aAAa,CAAC,MAAM,CAAC,CAAA;YACnC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;gBACnB,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;gBAClC,KAAK,IAAI,KAAK,GAAG,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;oBAC7D,MAAM,OAAO,GAAG,KAAK,CAAC,KAAK,CAAE,CAAA;oBAC7B,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,GAAG,MAAM,CAAC,YAAY,CACrC,OAAO,EACP,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAC7B,CAAA;oBACD,IACE,EAAE;wBACF,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,IAAI,EAC9D,CAAC;wBACD,OAAO,IAAI,CAAA;oBACb,CAAC;gBACH,CAAC;YACH,CAAC;QACH,CAAC;QACD,KAAK,GAAG,MAAM,CAAA;QACd,MAAM,GAAG,KAAK,CAAC,SAAS,EAAE,CAAA;IAC5B,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC,CAAA;AAID,IAAI,SAAS,GAA4B,IAAI,CAAA;AAE7C,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAqB,EAAE;IACxD,IAAI,SAAS,EAAE,CAAC;QACd,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,MAAM,aAAc,SAAQ,GAAG,CAAC,GAAG;QACxB,QAAQ,CAAC,CAAS,EAAE,CAAS;YACpC,IAAI,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC1B,OAAO,KAAK,CAAA;YACd,CAAC;YACD,iEAAiE;YACjE,oEAAoE;YACpE,gEAAgE;YAChE,4BAA4B;YAC5B,MAAM,IAAI,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;YAC/B,MAAM,MAAM,GACV,IAAI,KAAK,SAAS;gBAChB,CAAC,CAAC,+DAA+D;oBAC/D,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,GAAG,IAAI,CAAC,SAAS,EAAE;gBACjE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI;oBACf,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;oBACd,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,GAAG,IAAI,CAAC,KAAK;oBAChC,CAAC,GAAG,IAAI,CAAC,SAAS,EAAE,GAAG,IAAI,CAAC,MAAM,CAAA;YACxC,IAAI,CAAC,MAAM,IAAI,WAAW,KAAK,CAAC,EAAE,CAAC;gBACjC,OAAO,MAAM,CAAA;YACf,CAAC;YACD,sEAAsE;YACtE,uCAAuC;YACvC,OAAO,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;QAChC,CAAC;QAED,0EAA0E;QAC1E,wEAAwE;QACxE,sEAAsE;QACtE,iEAAiE;QACjE,sEAAsE;QACtE,8CAA8C;QAC9C,EAAE;QACF,qEAAqE;QACrE,8DAA8D;QAC9D,QAAQ,CAAC,QAAsB;YAC7B,IAAI,WAAW,KAAK,CAAC,EAAE,CAAC;gBACtB,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,CAAA;gBACjC,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;oBACnB,KAAK,MAAM,KAAK,IAAI,KAAK,EAAE,CAAC;wBAC1B,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;oBACrC,CAAC;oBACD,OAAM;gBACR,CAAC;YACH,CAAC;YACD,KAAK,MAAM,KAAK,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC;gBACrC,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;YACrC,CAAC;QACH,CAAC;KACF;IACD,kDAAkD;IAClD,aAAa,CAAC,aAAa,EAAE,EAAE,QAAQ,EAAE,eAAe,EAAE,CAAC,CAAA;IAC3D,SAAS,GAAG,sBAAsB,CAAC,eAAe,CAAC,CAAA;IACnD,OAAO,SAAS,CAAA;AAClB,CAAC,CAAA","sourcesContent":["// RnGtkxViewBox — the GtkBox subclass every View renders — and the whole of\n// RN's pointerEvents, which is a picking question and therefore lives here.\n//\n// Two of the four modes are the box's own contains(): \"box-none\" makes it\n// invisible to GTK's pick while its children stay pickable, and hitSlop\n// grows the rect the check uses. The other two are can-target on the widget\n// (\"none\", the whole subtree) or on its children (\"box-only\").\n//\n// can-target is a single boolean per widget and TWO things want to write it\n// — the widget's own pointerEvents, and a box-only ancestor masking it — so\n// neither may write it directly. `setPointerTarget` records what the\n// widget's own prop wants and applies the combination; the mask is derived\n// from the live parent every time, so a widget that React moves elsewhere\n// cannot end up stuck untargetable. Blanket-restoring children to `true` is\n// what made nesting a pointerEvents inside a box-only view unsupported\n// before: the restore pass could not know that a child wanted to be\n// untargetable for its own reasons.\n//\n// `zIndex` is the other half of the same subject and lives here for the same\n// reason: RN's z-order is a PAINT order and a PICK order, and this widget is\n// the only thing that owns both. See the block above the zIndex section below.\n//\n// Registered lazily like RnGtkxLayout (registration needs GObject, class\n// identity must exist before the first instance).\nimport * as Graphene from \"@gtkx/gi/graphene\"\nimport * as Gtk from \"@gtkx/gi/gtk\"\nimport { createElementComponent } from \"@gtkx/react/internal\"\nimport { registerClass } from \"@gtkx/runtime\"\n\nconst passthrough = new WeakSet<object>()\n/** Widgets whose DIRECT children are masked — RN's pointerEvents=\"box-only\". */\nconst boxOnly = new WeakSet<object>()\n/** What each widget's own pointerEvents wants, before any mask. */\nconst ownTarget = new WeakMap<object, boolean>()\n\nexport type HitSlop = {\n  top: number\n  right: number\n  bottom: number\n  left: number\n}\n\nconst hitSlops = new WeakMap<object, HitSlop>()\n\n/** box-none toggle: picking consults this live, no invalidation needed. */\nexport const setBoxPassthrough = (\n  widget: Gtk.Widget,\n  enabled: boolean,\n): void => {\n  if (enabled) {\n    passthrough.add(widget)\n  } else {\n    passthrough.delete(widget)\n  }\n}\n\n/**\n * Grows the rect this widget's contains() accepts. Only RnGtkxViewBox\n * consults it — RN's hitSlop is a picking change and nothing in JS can\n * substitute for one, because a press outside the widget is never delivered\n * to it in the first place.\n */\nexport const setHitSlop = (widget: Gtk.Widget, slop: HitSlop | null): void => {\n  if (slop === null) {\n    hitSlops.delete(widget)\n  } else {\n    hitSlops.set(widget, slop)\n  }\n}\n\nconst isMasked = (widget: Gtk.Widget): boolean => {\n  const parent = widget.getParent()\n  return parent !== null && boxOnly.has(parent)\n}\n\nconst applyTarget = (widget: Gtk.Widget): void => {\n  widget.setCanTarget(!isMasked(widget) && (ownTarget.get(widget) ?? true))\n}\n\n/**\n * What this widget's own `pointerEvents` wants its can-target to be. A\n * box-only ancestor still overrides it, and stops overriding it the moment\n * the ancestor's mode changes — without either of them having to know about\n * the other.\n */\nexport const setPointerTarget = (\n  widget: Gtk.Widget,\n  targetable: boolean,\n): void => {\n  ownTarget.set(widget, targetable)\n  applyTarget(widget)\n}\n\n/**\n * Masks or unmasks a widget's direct children — RN's\n * pointerEvents=\"box-only\". Re-applied every commit rather than only on\n * change, because the child set moves with the renders.\n */\nexport const setBoxOnly = (widget: Gtk.Widget, enabled: boolean): void => {\n  if (enabled) {\n    boxOnly.add(widget)\n  } else {\n    boxOnly.delete(widget)\n  }\n  for (\n    let child = widget.getFirstChild();\n    child !== null;\n    child = child.getNextSibling()\n  ) {\n    applyTarget(child)\n  }\n}\n\n// --- zIndex ---------------------------------------------------------------\n//\n// RN's `zIndex` reorders PAINT among siblings. GTK4 paints a container's\n// children in child order and has no z-order property, so the obvious fix —\n// reorder the widgets — is the wrong one: widget order is the order this\n// platform keeps its shadow tree in sync with (`syncChildOrder` in\n// components/use-layout-child.ts), so restacking for paint would silently\n// restack the LAYOUT.\n//\n// Paint order and layout order do not have to be the same, though, and we own\n// the widget: `allocate` stays in Yoga's order and `snapshot` walks the\n// children in zIndex order instead. That is what Android does too\n// (`ViewGroup.getChildDrawingOrder`) and for the same reason.\n//\n// The half that is easy to miss is that `gtk_widget_pick()` descends in\n// REVERSE child order, so sorting the paint alone leaves a raised view drawn\n// on top and still unclickable. GTK4 has no `pick` vfunc (GtkWidgetClass's\n// public vtable ends at `contains`, verified against gtk 4.22's header and\n// gtkx's generated registry), and the only per-point hook it offers is\n// `contains()` — which is exactly the vfunc this file already overrides. So\n// picking is made to agree by having a covered widget answer \"not me\" where a\n// higher-painting sibling of one of its ancestors would answer instead.\n//\n// Everything below is behind `raisedCount`, which is 0 in every app that never\n// writes the style: one integer comparison, and both vfuncs take the path they\n// took before any of this existed.\n\n/** Non-zero zIndex per widget. Absent means 0, which is RN's default. */\nconst zIndexes = new WeakMap<Gtk.Widget, number>()\n\n/**\n * How many widgets in the process currently carry a non-zero `zIndex`.\n *\n * The fast path's whole guard. `snapshot()` and `contains()` read this first,\n * so a tree that never raises anything pays one integer comparison per call\n * and no allocation, no sort, and no per-child work beyond what GTK's own\n * snapshot does.\n */\nlet raisedCount = 0\n\n/**\n * Cached paint order per container: an array in paint order, or `null` for\n * \"plain child order, nothing to do\". Recomputed on change (a zIndex write, a\n * commit that touched the container's children) rather than per snapshot —\n * `useSortable` puts `zIndex` in its style object every frame but changes its\n * VALUE about twice per drag.\n */\nconst paintOrders = new WeakMap<Gtk.Widget, Gtk.Widget[] | null>()\n\n/**\n * The container's live children, in child order, as the LAST ALLOCATE PASS\n * walked them.\n *\n * The snapshot vfunc has to visit every child either way, and walking the\n * sibling chain from JS is what costs: each `getNextSibling()` mints a fresh\n * native wrapper, measured at 1.9 µs per child against 1.0 µs for the\n * `snapshotChild()` that follows it (docs/research/z-index.md). The container's\n * `allocate()` hook already walks exactly this chain, so it hands the array\n * over instead and the paint pass reuses it.\n *\n * Safe because a child cannot appear, disappear or move without queueing a\n * resize on this container, and GTK runs the layout phase before the paint\n * phase — so an allocate always lands between a change and the snapshot that\n * would see it. A container whose allocate never ran (no RnGtkxLayout, e.g. a\n * bare slot host) simply has no entry, and the vfunc walks live.\n */\nconst childOrders = new WeakMap<Gtk.Widget, Gtk.Widget[]>()\n\nconst sameChildren = (a: Gtk.Widget[], b: Gtk.Widget[]): boolean => {\n  if (a.length !== b.length) {\n    return false\n  }\n  for (let index = 0; index < a.length; index += 1) {\n    if (a[index] !== b[index]) {\n      return false\n    }\n  }\n  return true\n}\n\n/**\n * Publishes the child list the container's allocate pass just walked.\n *\n * Cheap on the hot path by construction: the array is one the caller built\n * anyway, and the paint order is only invalidated when the children actually\n * differ — an allocate for a pure move (which is most of them, one per\n * animated frame) leaves the cached sort alone.\n */\nexport const cacheChildOrder = (\n  container: Gtk.Widget,\n  children: Gtk.Widget[],\n): void => {\n  const previous = childOrders.get(container)\n  childOrders.set(container, children)\n  if (previous === undefined || !sameChildren(previous, children)) {\n    paintOrders.delete(container)\n  }\n}\n\n/** Containers known to hold at least one raised child, for the picking walk. */\nconst zOrderedParents = new WeakSet<Gtk.Widget>()\n\n/**\n * Widgets that paint but are not touch targets of their own: the GtkLabel a\n * `Text` renders and the GtkPicture an `Image` renders. Neither component has\n * a press prop, so nothing is ever attached to them — but GTK targets them by\n * default, and `gtk_widget_pick()` reaches a child BEFORE it asks the parent's\n * `contains()`. That is the one hole in the occlusion check below: a covered\n * `View` can answer \"not me\", a bare GtkLabel inside it cannot.\n *\n * So while a container has a raised child, the paint-only leaves under it are\n * made untargetable and the pick lands on their nearest `View` instead — which\n * is the same widget the press would have propagated to anyway, and which does\n * answer the occlusion question. Restored the moment nothing is raised there,\n * because it is not free of consequence: `pointerEvents: \"box-none\"` on a View\n * whose only child is a `Text` would otherwise fall through to whatever is\n * behind it. Documented in docs/api.md.\n */\nconst paintOnlyLeaves = new WeakSet<Gtk.Widget>()\n\n/**\n * Marks a widget as painting-only for picking purposes — see above. Called\n * once per widget by the components that own one (`Text`, `Image`).\n */\nexport const setPaintOnlyLeaf = (widget: Gtk.Widget): void => {\n  paintOnlyLeaves.add(widget)\n}\n\nconst applyLeafTargeting = (container: Gtk.Widget, suppress: boolean): void => {\n  for (\n    let child = container.getFirstChild();\n    child !== null;\n    child = child.getNextSibling()\n  ) {\n    if (paintOnlyLeaves.has(child)) {\n      setPointerTarget(child, !suppress)\n    }\n    // A nested container that is STILL raised keeps its own suppression: an\n    // outer container coming back down must not restore leaves an inner one\n    // is relying on.\n    if (suppress || !zOrderedParents.has(child)) {\n      applyLeafTargeting(child, suppress)\n    }\n  }\n}\n\n/**\n * Drops a container's cached paint order and asks for a redraw.\n *\n * Called from the zIndex writer and from the container's per-commit effect\n * (components/use-layout-child.ts), which is what covers a child mounting,\n * unmounting or being MOVED by React — the three ways the order can change\n * without any zIndex being written.\n */\nexport const invalidateZOrder = (container: Gtk.Widget): void => {\n  // The child list too: a commit is the one thing that can change it, and the\n  // allocate the commit queues puts a fresh one back before the next paint.\n  childOrders.delete(container)\n  if (!paintOrders.delete(container)) {\n    return\n  }\n  container.queueDraw()\n  if (zOrderedParents.has(container)) {\n    // Recomputed now rather than at the next snapshot, for the same reason\n    // setZIndex does it: a container that just lost its last raised child\n    // (the commit that unmounted it) would otherwise never be asked again —\n    // the fast path stops calling paintOrderFor once nothing is raised — and\n    // would keep its paint-only leaves untargetable forever.\n    paintOrderFor(container)\n  }\n}\n\n/**\n * RN's `zIndex` for one child. `0` (the default, and `undefined`) clears it.\n *\n * RN applies `zIndex` unconditionally — unlike CSS, which ignores `z-index`\n * on a `position: static` box. Nothing here looks at `position` either.\n */\nexport const setZIndex = (widget: Gtk.Widget, value: number): void => {\n  const previous = zIndexes.get(widget) ?? 0\n  if (previous === value) {\n    return\n  }\n  if (value === 0) {\n    zIndexes.delete(widget)\n    raisedCount -= 1\n  } else {\n    zIndexes.set(widget, value)\n    if (previous === 0) {\n      raisedCount += 1\n    }\n  }\n  const parent = widget.getParent()\n  if (parent === null) {\n    return\n  }\n  paintOrders.delete(parent)\n  // Unconditional, unlike invalidateZOrder's: the container may never have\n  // had a cache to drop and its paint still just changed.\n  parent.queueDraw()\n  if (value === 0) {\n    // Recomputed eagerly on the way DOWN, never lazily: once nothing is\n    // raised the fast path stops calling paintOrderFor at all, so a container\n    // that lost its last raised child would never get the chance to undo what\n    // being raised did to it (paint order, leaf targeting).\n    paintOrderFor(parent)\n  }\n}\n\n/** The container's children, from the allocate pass if it has run. */\nconst childrenOf = (container: Gtk.Widget): Gtk.Widget[] => {\n  const cached = childOrders.get(container)\n  if (cached !== undefined) {\n    return cached\n  }\n  const children: Gtk.Widget[] = []\n  for (\n    let child = container.getFirstChild();\n    child !== null;\n    child = child.getNextSibling()\n  ) {\n    children.push(child)\n  }\n  return children\n}\n\nconst paintOrderFor = (container: Gtk.Widget): Gtk.Widget[] | null => {\n  if (paintOrders.has(container)) {\n    return paintOrders.get(container) ?? null\n  }\n  const children = childrenOf(container)\n  let raised = false\n  for (const child of children) {\n    if (zIndexes.has(child)) {\n      raised = true\n      break\n    }\n  }\n  let order: Gtk.Widget[] | null = null\n  if (raised) {\n    zOrderedParents.add(container)\n    // Once per recompute, not per frame, and only for a container that\n    // actually has something raised: the walk is what catches a `Text` that\n    // mounted into an already-raised container since the last one.\n    applyLeafTargeting(container, true)\n    // Stable by construction. RN keeps document order among equal zIndexes,\n    // and an unstable sort would let equal siblings swap between frames —\n    // flicker that is miserable to attribute. `Array.prototype.sort` has been\n    // required to be stable since ES2019; the index tiebreak makes that\n    // independent of the engine rather than assumed of it.\n    order = children\n      .map((widget, index) => ({\n        widget,\n        index,\n        z: zIndexes.get(widget) ?? 0,\n      }))\n      .sort((a, b) => a.z - b.z || a.index - b.index)\n      .map((entry) => entry.widget)\n  } else if (zOrderedParents.delete(container)) {\n    applyLeafTargeting(container, false)\n  }\n  paintOrders.set(container, order)\n  return order\n}\n\n/**\n * Whether a higher-painting sibling of this widget — or of any of its\n * ancestors — would take the pick at this point.\n *\n * `pick()` on the sibling rather than a bounds test, because \"would GTK have\n * answered inside that subtree\" IS the question, and it comes with the rest of\n * RN's rules for free: a raised view with `pointerEvents: \"none\"` is not\n * targetable, so it does not occlude either.\n *\n * The recursion terminates because it only ever asks about siblings STRICTLY\n * higher in the same container's paint order.\n */\nconst isOccluded = (widget: Gtk.Widget, x: number, y: number): boolean => {\n  let child = widget\n  let parent = child.getParent()\n  while (parent !== null) {\n    if (zOrderedParents.has(parent)) {\n      const order = paintOrderFor(parent)\n      if (order !== null) {\n        const index = order.indexOf(child)\n        for (let above = index + 1; above < order.length; above += 1) {\n          const sibling = order[above]!\n          const [ok, point] = widget.computePoint(\n            sibling,\n            new Graphene.Point({ x, y }),\n          )\n          if (\n            ok &&\n            sibling.pick(point.x, point.y, Gtk.PickFlags.DEFAULT) !== null\n          ) {\n            return true\n          }\n        }\n      }\n    }\n    child = parent\n    parent = child.getParent()\n  }\n  return false\n}\n\ntype ViewBoxComponent = ReturnType<typeof createElementComponent>\n\nlet component: ViewBoxComponent | null = null\n\nexport const getViewBoxComponent = (): ViewBoxComponent => {\n  if (component) {\n    return component\n  }\n\n  class RnGtkxViewBox extends Gtk.Box {\n    override contains(x: number, y: number): boolean {\n      if (passthrough.has(this)) {\n        return false\n      }\n      // GTK translates the point into this widget's coordinates before\n      // asking, and does not pre-check the bounds, so a negative x or a y\n      // past the height is a legitimate question — which is what lets\n      // hitSlop answer yes to it.\n      const slop = hitSlops.get(this)\n      const inside =\n        slop === undefined\n          ? // The default widget behavior: inside the widget's own bounds.\n            x >= 0 && y >= 0 && x < this.getWidth() && y < this.getHeight()\n          : x >= -slop.left &&\n            y >= -slop.top &&\n            x < this.getWidth() + slop.right &&\n            y < this.getHeight() + slop.bottom\n      if (!inside || raisedCount === 0) {\n        return inside\n      }\n      // Something in this process is raised: this widget only answers where\n      // nothing painted above it would have.\n      return !isOccluded(this, x, y)\n    }\n\n    // GTK's own container snapshot is `gtk_widget_real_snapshot`, which walks\n    // first-to-last calling gtk_widget_snapshot_child — the loop below with\n    // nothing in front of it. There is no way to chain up to it from here\n    // (gtkx installs the vfunc but exposes no parent-class call, and\n    // gtk_widget_snapshot() is not public C API either), so the fast path\n    // reproduces it rather than delegating to it.\n    //\n    // No `override`: `snapshot` is a real vfunc in gtkx's codegen but is\n    // missing from the shipped gtk.d.ts (same as in svg-node.ts).\n    snapshot(snapshot: Gtk.Snapshot): void {\n      if (raisedCount !== 0) {\n        const order = paintOrderFor(this)\n        if (order !== null) {\n          for (const child of order) {\n            this.snapshotChild(child, snapshot)\n          }\n          return\n        }\n      }\n      for (const child of childrenOf(this)) {\n        this.snapshotChild(child, snapshot)\n      }\n    }\n  }\n  // Explicit typeName: bundlers minify class names.\n  registerClass(RnGtkxViewBox, { typeName: \"RnGtkxViewBox\" })\n  component = createElementComponent(\"RnGtkxViewBox\")\n  return component\n}\n"]}

package/dist/gtkx/bridge/widget-css.d.ts

@@ -0,0 +1,17 @@
+import { type Widget } from "@gtkx/gi/gtk";
+export type WidgetCss = {
+    /**
+     * Replaces the widget's imperative declarations. `body` is a GTK CSS
+     * declaration list without a selector or braces (`background-color: rgb(1,
+     * 2, 3);`); an empty string removes everything this provider contributes.
+     */
+    set(body: string): void;
+    /** Detaches the provider. Safe to call more than once. */
+    dispose(): void;
+};
+/**
+ * Attaches a private CSS provider to `widget`. Writes are O(1) in the size of
+ * the widget tree and do not touch the shared stylesheet, so nothing about
+ * the static style path — including its memoisation — changes.
+ */
+export declare const createWidgetCss: (widget: Widget) => WidgetCss;

package/dist/gtkx/bridge/widget-css.js

@@ -0,0 +1,72 @@
+// One GtkCssProvider per animated widget: the imperative escape hatch that
+// lets a colour reach a MOUNTED widget without a React render.
+//
+// The ordinary path is a memoised class in one global stylesheet
+// (../../style/registry.ts + @gtkx/css), and it is the wrong shape for an
+// animation by construction — its cache key IS the CSS text, so a value that
+// changes every frame mints a class per frame, appends a rule to a document
+// that is never pruned, and makes GTK re-parse the whole thing. Measured on
+// the VM: 0.8 ms for the first frame, 6.8 ms by frame 600, still climbing,
+// plus 600 permanently-live classes for one second of animation.
+//
+// WHY THE WIDGET'S OWN STYLE CONTEXT AND NOT THE DISPLAY. Both were measured
+// (docs/research/animated-colors.md). `Gtk.StyleContext.addProviderForDisplay`
+// is the non-deprecated API, but a display-level provider invalidates every
+// CSS node on the display each time it is reloaded, so the cost of one
+// animated colour is proportional to how many widgets are on screen: +527 µs
+// per frame in a 60-widget tree, +1634 µs at 300. A provider on the widget's
+// own style context invalidates that widget alone — +79 µs at 60 widgets,
+// +24 µs at 300, i.e. flat, and inside the noise of the paint it triggers
+// anyway.
+//
+// `gtk_widget_get_style_context()` and `gtk_style_context_add_provider()` are
+// deprecated (GTK 4.10), and GTK's own migration note points at exactly the
+// display-wide replacement measured above. This file is where that trade is
+// made and where it will be re-made: if GTK5 removes the per-widget cascade,
+// the fallback is a display-wide provider plus a unique class per widget, at
+// the measured cost — the surface here does not change.
+//
+// The selector is `*`, not a class. Verified against GTK 4.22: a provider on
+// a widget's style context matches THAT widget's CSS node and not its
+// children (a `min-width` written through it moved the widget and left its
+// child alone), and unlike a class it cannot be destroyed by React writing
+// the `cssClasses` prop — which it would be, since gtkx sets the whole list.
+import { CssProvider, STYLE_PROVIDER_PRIORITY_APPLICATION, } from "@gtkx/gi/gtk";
+// One above APPLICATION, which is where both @gtkx/css's stylesheet and any
+// app-level CSS land. A driven value has to win over the static class it is
+// replacing for the duration of the animation; it stays below USER (800) so
+// a user stylesheet still overrides everything, as GTK intends.
+const PRIORITY = STYLE_PROVIDER_PRIORITY_APPLICATION + 1;
+/**
+ * Attaches a private CSS provider to `widget`. Writes are O(1) in the size of
+ * the widget tree and do not touch the shared stylesheet, so nothing about
+ * the static style path — including its memoisation — changes.
+ */
+export const createWidgetCss = (widget) => {
+    const provider = new CssProvider();
+    // Held rather than re-fetched: getStyleContext() is a call into GTK, and
+    // removeProvider must be given the same context addProvider was.
+    const context = widget.getStyleContext();
+    context.addProvider(provider, PRIORITY);
+    let current = null;
+    let disposed = false;
+    return {
+        set(body) {
+            if (disposed || body === current) {
+                return;
+            }
+            current = body;
+            // An empty rule is still a rule GTK has to parse and match, so an
+            // empty body loads an empty document instead.
+            provider.loadFromString(body === "" ? "" : `* { ${body} }`);
+        },
+        dispose() {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            context.removeProvider(provider);
+        },
+    };
+};
+//# sourceMappingURL=widget-css.js.map

package/dist/gtkx/bridge/widget-css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"widget-css.js","sourceRoot":"","sources":["../../../src/gtkx/bridge/widget-css.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,+DAA+D;AAC/D,EAAE;AACF,iEAAiE;AACjE,0EAA0E;AAC1E,6EAA6E;AAC7E,4EAA4E;AAC5E,4EAA4E;AAC5E,2EAA2E;AAC3E,iEAAiE;AACjE,EAAE;AACF,6EAA6E;AAC7E,+EAA+E;AAC/E,4EAA4E;AAC5E,uEAAuE;AACvE,6EAA6E;AAC7E,6EAA6E;AAC7E,0EAA0E;AAC1E,0EAA0E;AAC1E,UAAU;AACV,EAAE;AACF,8EAA8E;AAC9E,4EAA4E;AAC5E,4EAA4E;AAC5E,6EAA6E;AAC7E,6EAA6E;AAC7E,wDAAwD;AACxD,EAAE;AACF,6EAA6E;AAC7E,sEAAsE;AACtE,2EAA2E;AAC3E,2EAA2E;AAC3E,6EAA6E;AAC7E,OAAO,EACL,WAAW,EACX,mCAAmC,GAGpC,MAAM,cAAc,CAAA;AAarB,4EAA4E;AAC5E,4EAA4E;AAC5E,4EAA4E;AAC5E,gEAAgE;AAChE,MAAM,QAAQ,GAAG,mCAAmC,GAAG,CAAC,CAAA;AAExD;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,MAAc,EAAa,EAAE;IAC3D,MAAM,QAAQ,GAAG,IAAI,WAAW,EAAE,CAAA;IAClC,yEAAyE;IACzE,iEAAiE;IACjE,MAAM,OAAO,GAAiB,MAAM,CAAC,eAAe,EAAE,CAAA;IACtD,OAAO,CAAC,WAAW,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;IAEvC,IAAI,OAAO,GAAkB,IAAI,CAAA;IACjC,IAAI,QAAQ,GAAG,KAAK,CAAA;IAEpB,OAAO;QACL,GAAG,CAAC,IAAI;YACN,IAAI,QAAQ,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;gBACjC,OAAM;YACR,CAAC;YACD,OAAO,GAAG,IAAI,CAAA;YACd,kEAAkE;YAClE,8CAA8C;YAC9C,QAAQ,CAAC,cAAc,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,CAAA;QAC7D,CAAC;QACD,OAAO;YACL,IAAI,QAAQ,EAAE,CAAC;gBACb,OAAM;YACR,CAAC;YACD,QAAQ,GAAG,IAAI,CAAA;YACf,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAA;QAClC,CAAC;KACF,CAAA;AACH,CAAC,CAAA","sourcesContent":["// One GtkCssProvider per animated widget: the imperative escape hatch that\n// lets a colour reach a MOUNTED widget without a React render.\n//\n// The ordinary path is a memoised class in one global stylesheet\n// (../../style/registry.ts + @gtkx/css), and it is the wrong shape for an\n// animation by construction — its cache key IS the CSS text, so a value that\n// changes every frame mints a class per frame, appends a rule to a document\n// that is never pruned, and makes GTK re-parse the whole thing. Measured on\n// the VM: 0.8 ms for the first frame, 6.8 ms by frame 600, still climbing,\n// plus 600 permanently-live classes for one second of animation.\n//\n// WHY THE WIDGET'S OWN STYLE CONTEXT AND NOT THE DISPLAY. Both were measured\n// (docs/research/animated-colors.md). `Gtk.StyleContext.addProviderForDisplay`\n// is the non-deprecated API, but a display-level provider invalidates every\n// CSS node on the display each time it is reloaded, so the cost of one\n// animated colour is proportional to how many widgets are on screen: +527 µs\n// per frame in a 60-widget tree, +1634 µs at 300. A provider on the widget's\n// own style context invalidates that widget alone — +79 µs at 60 widgets,\n// +24 µs at 300, i.e. flat, and inside the noise of the paint it triggers\n// anyway.\n//\n// `gtk_widget_get_style_context()` and `gtk_style_context_add_provider()` are\n// deprecated (GTK 4.10), and GTK's own migration note points at exactly the\n// display-wide replacement measured above. This file is where that trade is\n// made and where it will be re-made: if GTK5 removes the per-widget cascade,\n// the fallback is a display-wide provider plus a unique class per widget, at\n// the measured cost — the surface here does not change.\n//\n// The selector is `*`, not a class. Verified against GTK 4.22: a provider on\n// a widget's style context matches THAT widget's CSS node and not its\n// children (a `min-width` written through it moved the widget and left its\n// child alone), and unlike a class it cannot be destroyed by React writing\n// the `cssClasses` prop — which it would be, since gtkx sets the whole list.\nimport {\n  CssProvider,\n  STYLE_PROVIDER_PRIORITY_APPLICATION,\n  StyleContext,\n  type Widget,\n} from \"@gtkx/gi/gtk\"\n\nexport type WidgetCss = {\n  /**\n   * Replaces the widget's imperative declarations. `body` is a GTK CSS\n   * declaration list without a selector or braces (`background-color: rgb(1,\n   * 2, 3);`); an empty string removes everything this provider contributes.\n   */\n  set(body: string): void\n  /** Detaches the provider. Safe to call more than once. */\n  dispose(): void\n}\n\n// One above APPLICATION, which is where both @gtkx/css's stylesheet and any\n// app-level CSS land. A driven value has to win over the static class it is\n// replacing for the duration of the animation; it stays below USER (800) so\n// a user stylesheet still overrides everything, as GTK intends.\nconst PRIORITY = STYLE_PROVIDER_PRIORITY_APPLICATION + 1\n\n/**\n * Attaches a private CSS provider to `widget`. Writes are O(1) in the size of\n * the widget tree and do not touch the shared stylesheet, so nothing about\n * the static style path — including its memoisation — changes.\n */\nexport const createWidgetCss = (widget: Widget): WidgetCss => {\n  const provider = new CssProvider()\n  // Held rather than re-fetched: getStyleContext() is a call into GTK, and\n  // removeProvider must be given the same context addProvider was.\n  const context: StyleContext = widget.getStyleContext()\n  context.addProvider(provider, PRIORITY)\n\n  let current: string | null = null\n  let disposed = false\n\n  return {\n    set(body) {\n      if (disposed || body === current) {\n        return\n      }\n      current = body\n      // An empty rule is still a rule GTK has to parse and match, so an\n      // empty body loads an empty document instead.\n      provider.loadFromString(body === \"\" ? \"\" : `* { ${body} }`)\n    },\n    dispose() {\n      if (disposed) {\n        return\n      }\n      disposed = true\n      context.removeProvider(provider)\n    },\n  }\n}\n"]}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { ActivityIndicator, Animated, AppRegistry, Easing, FlatList, Image, Modal, IntrinsicRoot, PanResponder, NestedRoot, Pressable, Root, SafeAreaView, ScrollView, SectionList, StatusBar, Switch, Text, TextInput, TouchableOpacity, View, type ActivityIndicatorProps, type FlatListProps, type GestureResponderEvent, type ImageProps, type ImageSource, type LayoutEvent, type ListRenderItemInfo, type MeasureHandle, type MeasureInWindowOnSuccessCallback, type MeasureLayoutOnSuccessCallback, type MeasureOnSuccessCallback, type ModalProps, type NativeTouch, type PanResponderCallbacks, type PanResponderGestureState, type PanResponderInstance, type PressableProps, type PressableStateCallbackType, type IntrinsicRootProps, type NestedRootProps, type PressEvent, type ResponderProps, type RootProps, type RunApplicationParams, type ScrollEvent, type ScrollViewHandle, type ScrollViewProps, type SectionListProps, type SwitchProps, type TextInputProps, type TextProps, type TouchHistory, type TouchRecord, type TouchableOpacityProps, type ViewabilityConfig, type ViewHandle, type ViewProps, type ViewToken, } from "./components/index";
+export { ActivityIndicator, Animated, AppRegistry, Easing, findNodeHandle, FlatList, Image, Modal, IntrinsicRoot, PanResponder, NestedRoot, Pressable, Root, SafeAreaView, ScrollView, SectionList, StatusBar, Switch, Text, TextInput, TouchableHighlight, TouchableOpacity, TouchableWithoutFeedback, View, VirtualizedList, type ActivityIndicatorProps, type FlatListProps, type GestureResponderEvent, type ImageHandle, type ImageProps, type ImageSource, type LayoutEvent, type ListRenderItemInfo, type MeasureHandle, type MeasureInWindowOnSuccessCallback, type MeasureLayoutOnSuccessCallback, type MeasureOnSuccessCallback, type ItemLayout, type ModalProps, type NativeTouch, type NodeHandle, type PanResponderCallbacks, type PanResponderGestureState, type PanResponderInstance, type PressableProps, type PressableStateCallbackType, type IntrinsicRootProps, type NestedRootProps, type PressEvent, type ResponderProps, type RootProps, type RunApplicationParams, type ScrollEvent, type ScrollViewHandle, type ScrollViewProps, type SectionListProps, type SwitchProps, type TextHandle, type TextInputProps, type TextProps, type TouchHistory, type TouchRecord, type TouchableHighlightProps, type TouchableOpacityProps, type TouchableWithoutFeedbackProps, type ViewabilityConfig, type ViewHandle, type ViewProps, type ViewToken, } from "./components/index";
 export type { FlatListHandle } from "./components/flat-list";
-export { Alert, Appearance, AppState, BackHandler, DevSettings, Dimensions, I18nManager, InteractionManager, Linking, Platform, useColorScheme, useWindowDimensions, type AlertButton, type AlertButtonStyle, type AlertOptions, type AppearancePreferences, type AppStateEvent, type AppStateStatus, type ColorSchemeName, type DimensionKey, type DimensionsPayload, type InteractionPromise, type PlatformSelectSpec, type ScaledSize, } from "./apis/index";
+export { Alert, Appearance, AppState, BackHandler, DevSettings, Dimensions, I18nManager, InteractionManager, Keyboard, Linking, LogBox, Platform, useColorScheme, useWindowDimensions, type AlertButton, type AlertButtonStyle, type AlertOptions, type AppearancePreferences, type AppStateEvent, type AppStateStatus, type ColorSchemeName, type DimensionKey, type DimensionsPayload, type InteractionPromise, type KeyboardEvent, type KeyboardEventName, type LogBoxIgnorePattern, type PlatformOSType, type PlatformSelectSpec, type ScaledSize, } from "./apis/index";
 export { PlatformColor, StyleSheet } from "./style/index";
-export type { BoxShadowValue, DimensionValue, FlatStyle, LayoutStyle, PointerEventsValue, StyleProp, TextDecorationLine, TransformPart, VisualStyle, } from "./contracts";
+export type { BoxShadowValue, DimensionValue, FlatStyle, ImageStyle, LayoutStyle, PointerEventsValue, StyleProp, TextDecorationLine, TextStyle, TransformPart, ViewStyle, VisualStyle, } from "./contracts";
 export declare const version = "0.1.0";

package/dist/index.js

@@ -1,7 +1,7 @@
 // Public surface of react-native-gtkx, mirroring the `react-native` module.
 // Components · APIs · StyleSheet, with the Yoga layout engine underneath.
-export { ActivityIndicator, Animated, AppRegistry, Easing, FlatList, Image, Modal, IntrinsicRoot, PanResponder, NestedRoot, Pressable, Root, SafeAreaView, ScrollView, SectionList, StatusBar, Switch, Text, TextInput, TouchableOpacity, View, } from "./components/index";
-export { Alert, Appearance, AppState, BackHandler, DevSettings, Dimensions, I18nManager, InteractionManager, Linking, Platform, useColorScheme, useWindowDimensions, } from "./apis/index";
+export { ActivityIndicator, Animated, AppRegistry, Easing, findNodeHandle, FlatList, Image, Modal, IntrinsicRoot, PanResponder, NestedRoot, Pressable, Root, SafeAreaView, ScrollView, SectionList, StatusBar, Switch, Text, TextInput, TouchableHighlight, TouchableOpacity, TouchableWithoutFeedback, View, VirtualizedList, } from "./components/index";
+export { Alert, Appearance, AppState, BackHandler, DevSettings, Dimensions, I18nManager, InteractionManager, Keyboard, Linking, LogBox, Platform, useColorScheme, useWindowDimensions, } from "./apis/index";
 export { PlatformColor, StyleSheet } from "./style/index";
 export const version = "0.1.0";
 //# sourceMappingURL=index.js.map