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

package/dist/gtk/controllers.d.ts

@@ -0,0 +1,39 @@
+import { type ReactNode } from "react";
+export type ControllersProps = {
+    /** `Gtk.EventController` elements — `GtkDragSource`, `GtkDropTarget`,
+     *  `GtkShortcutController`, and anything else gtkx exposes as one. */
+    children?: ReactNode;
+};
+/**
+ * Attaches its children as event controllers on the widget of the enclosing
+ * React Native component.
+ *
+ * ```tsx
+ * // Controllers and GtkDragSource are both exported by this subpath.
+ * // (Not written as a real import line: the metro-preset test scans src for
+ * // bare imports with a regex, and an import-shaped sentence in a doc
+ * // comment reads to it exactly like a real one — see components/host-node.)
+ *
+ * <Pressable onPress={open}>
+ *   <Controllers>
+ *     <GtkDragSource actions={Gdk.DragAction.MOVE} onPrepare={…} />
+ *   </Controllers>
+ *   <Text>{task.title}</Text>
+ * </Pressable>
+ * ```
+ *
+ * It renders nothing where it sits: like `WindowControllers`, it is a
+ * portal in React's own sense, so the children keep the context, state and
+ * effects they would have at that position while the attachment lands on
+ * the widget. They are removed when this component unmounts.
+ *
+ * Works inside `View`, `Pressable`, `ScrollView`, `Animated.View` and
+ * `Root` — every component that owns a widget and hands it down. Inside a
+ * GTK widget's own slot there is no enclosing React Native component, and
+ * nothing is attached: pass `controllers={…}` to the widget itself there,
+ * which is the prop this exists to substitute for.
+ *
+ * **Linux-only, and the import says so.** Guard it with `Platform.OS` or
+ * split the file if the same screen also builds for iOS or Android.
+ */
+export declare const Controllers: ({ children }: ControllersProps) => ReactNode;

package/dist/gtk/controllers.js

@@ -0,0 +1,92 @@
+// Attaching a GTK event controller to a component written in React Native.
+//
+// WHY this is a component in THIS subpath rather than a `controllers` prop
+// on `View`. A `View`'s ref is a `ViewHandle` — measure/measureInWindow/
+// measureLayout — and that is right: React Native's contract says nothing
+// about widgets, and an app that reaches through the ref to a `Gtk.Widget`
+// has pinned every internal of this platform as public API. But GTK carries
+// real behaviour that no style and no RN prop expresses — drag-and-drop
+// above all — and before this component there was simply no way to reach it
+// from a row written in React Native (see
+// docs/research/react-native-first-showcase.md, and `examples/tasks-nav`'s
+// rows, which could not be rewritten because of it).
+//
+// A `controllers` prop on `View`/`Pressable` would have been three lines.
+// It was rejected because it puts a GTK concept on the two components an
+// app shares with iOS and Android, imported from the PORTABLE entry point:
+// the file would still compile everywhere, the prop would be ignored off
+// Linux, and the feature would vanish with no diagnostic. The import is the
+// signal on this platform — `react-native-gtkx/gtk` is the line an app
+// knows it is crossing — and a prop on `View` throws that signal away. An
+// ELEMENT, by contrast, is something an RN developer already knows how to
+// put behind a `Platform.OS` check or a `.linux.tsx` split, and its absence
+// is visible in the tree.
+//
+// The shape is not new here: `WindowActions`/`WindowControllers` next door
+// already mean "declare in the app tree, attach to the window". This means
+// "declare in the app tree, attach to the enclosing view" — same portal,
+// same mount/unmount lifecycle, one level down. Nothing was added to
+// `View`, `Pressable`, `ScrollView` or `Animated.View` to make it work on
+// all four: each already publishes its widget through HostNodeContext.
+import { useContext, useEffect, useState } from "react";
+import { HostNodeContext } from "../components/host-node";
+import { createSlotPortal } from "../gtkx/bridge/index";
+/**
+ * Attaches its children as event controllers on the widget of the enclosing
+ * React Native component.
+ *
+ * ```tsx
+ * // Controllers and GtkDragSource are both exported by this subpath.
+ * // (Not written as a real import line: the metro-preset test scans src for
+ * // bare imports with a regex, and an import-shaped sentence in a doc
+ * // comment reads to it exactly like a real one — see components/host-node.)
+ *
+ * <Pressable onPress={open}>
+ *   <Controllers>
+ *     <GtkDragSource actions={Gdk.DragAction.MOVE} onPrepare={…} />
+ *   </Controllers>
+ *   <Text>{task.title}</Text>
+ * </Pressable>
+ * ```
+ *
+ * It renders nothing where it sits: like `WindowControllers`, it is a
+ * portal in React's own sense, so the children keep the context, state and
+ * effects they would have at that position while the attachment lands on
+ * the widget. They are removed when this component unmounts.
+ *
+ * Works inside `View`, `Pressable`, `ScrollView`, `Animated.View` and
+ * `Root` — every component that owns a widget and hands it down. Inside a
+ * GTK widget's own slot there is no enclosing React Native component, and
+ * nothing is attached: pass `controllers={…}` to the widget itself there,
+ * which is the prop this exists to substitute for.
+ *
+ * **Linux-only, and the import says so.** Guard it with `Platform.OS` or
+ * split the file if the same screen also builds for iOS or Android.
+ */
+export const Controllers = ({ children }) => {
+    const host = useContext(HostNodeContext);
+    // Captured in a PASSIVE effect, not a layout effect, and that is forced:
+    // React attaches host refs bottom-up, so the enclosing `<ViewBox
+    // ref={…}>`'s ref is still null while this child's layout effects run on
+    // the first mount. Passive effects run after the whole commit, by which
+    // time it is set. The cost is that controllers attach one commit late —
+    // unobservable for an event controller (no pointer reaches a widget in
+    // its first frame), and the same delay `WindowActions` already documents
+    // for the window.
+    //
+    // react-hooks/set-state-in-effect is disabled rather than worked around:
+    // the rule guards against effects that derive state from PROPS, which
+    // should be computed during render instead. This derives it from an
+    // imperative handle that does not exist until after the commit — the one
+    // case an effect is the only place it can come from. It runs once and
+    // settles (the setter bails on an unchanged value), so there is no
+    // cascade for the rule to be protecting against.
+    const [widget, setWidget] = useState(null);
+    // eslint-disable-next-line react-hooks/set-state-in-effect
+    useEffect(() => setWidget(host?.widgetRef.current ?? null), [host]);
+    if (widget === null) {
+        return null;
+    }
+    return createSlotPortal(children, widget, "controllers");
+};
+//# sourceMappingURL=controllers.js.map

package/dist/gtk/controllers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controllers.js","sourceRoot":"","sources":["../../src/gtk/controllers.tsx"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,EAAE;AACF,2EAA2E;AAC3E,yEAAyE;AACzE,0EAA0E;AAC1E,2EAA2E;AAC3E,4EAA4E;AAC5E,wEAAwE;AACxE,4EAA4E;AAC5E,0CAA0C;AAC1C,2EAA2E;AAC3E,qDAAqD;AACrD,EAAE;AACF,0EAA0E;AAC1E,yEAAyE;AACzE,2EAA2E;AAC3E,yEAAyE;AACzE,4EAA4E;AAC5E,uEAAuE;AACvE,0EAA0E;AAC1E,0EAA0E;AAC1E,4EAA4E;AAC5E,0BAA0B;AAC1B,EAAE;AACF,2EAA2E;AAC3E,2EAA2E;AAC3E,yEAAyE;AACzE,qEAAqE;AACrE,0EAA0E;AAC1E,uEAAuE;AACvE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,EAAkB,MAAM,OAAO,CAAA;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AACzD,OAAO,EAAE,gBAAgB,EAAY,MAAM,sBAAsB,CAAA;AAQjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,EAAE,QAAQ,EAAoB,EAAa,EAAE;IACvE,MAAM,IAAI,GAAG,UAAU,CAAC,eAAe,CAAC,CAAA;IACxC,yEAAyE;IACzE,iEAAiE;IACjE,yEAAyE;IACzE,wEAAwE;IACxE,wEAAwE;IACxE,uEAAuE;IACvE,yEAAyE;IACzE,kBAAkB;IAClB,EAAE;IACF,yEAAyE;IACzE,sEAAsE;IACtE,oEAAoE;IACpE,yEAAyE;IACzE,sEAAsE;IACtE,mEAAmE;IACnE,iDAAiD;IACjD,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,QAAQ,CAAoB,IAAI,CAAC,CAAA;IAC7D,2DAA2D;IAC3D,SAAS,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,OAAO,IAAI,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;IAEnE,IAAI,MAAM,KAAK,IAAI,EAAE,CAAC;QACpB,OAAO,IAAI,CAAA;IACb,CAAC;IACD,OAAO,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,CAAC,CAAA;AAC1D,CAAC,CAAA","sourcesContent":["// Attaching a GTK event controller to a component written in React Native.\n//\n// WHY this is a component in THIS subpath rather than a `controllers` prop\n// on `View`. A `View`'s ref is a `ViewHandle` — measure/measureInWindow/\n// measureLayout — and that is right: React Native's contract says nothing\n// about widgets, and an app that reaches through the ref to a `Gtk.Widget`\n// has pinned every internal of this platform as public API. But GTK carries\n// real behaviour that no style and no RN prop expresses — drag-and-drop\n// above all — and before this component there was simply no way to reach it\n// from a row written in React Native (see\n// docs/research/react-native-first-showcase.md, and `examples/tasks-nav`'s\n// rows, which could not be rewritten because of it).\n//\n// A `controllers` prop on `View`/`Pressable` would have been three lines.\n// It was rejected because it puts a GTK concept on the two components an\n// app shares with iOS and Android, imported from the PORTABLE entry point:\n// the file would still compile everywhere, the prop would be ignored off\n// Linux, and the feature would vanish with no diagnostic. The import is the\n// signal on this platform — `react-native-gtkx/gtk` is the line an app\n// knows it is crossing — and a prop on `View` throws that signal away. An\n// ELEMENT, by contrast, is something an RN developer already knows how to\n// put behind a `Platform.OS` check or a `.linux.tsx` split, and its absence\n// is visible in the tree.\n//\n// The shape is not new here: `WindowActions`/`WindowControllers` next door\n// already mean \"declare in the app tree, attach to the window\". This means\n// \"declare in the app tree, attach to the enclosing view\" — same portal,\n// same mount/unmount lifecycle, one level down. Nothing was added to\n// `View`, `Pressable`, `ScrollView` or `Animated.View` to make it work on\n// all four: each already publishes its widget through HostNodeContext.\nimport { useContext, useEffect, useState, type ReactNode } from \"react\"\nimport { HostNodeContext } from \"../components/host-node\"\nimport { createSlotPortal, type Gtk } from \"../gtkx/bridge/index\"\n\nexport type ControllersProps = {\n  /** `Gtk.EventController` elements — `GtkDragSource`, `GtkDropTarget`,\n   *  `GtkShortcutController`, and anything else gtkx exposes as one. */\n  children?: ReactNode\n}\n\n/**\n * Attaches its children as event controllers on the widget of the enclosing\n * React Native component.\n *\n * ```tsx\n * // Controllers and GtkDragSource are both exported by this subpath.\n * // (Not written as a real import line: the metro-preset test scans src for\n * // bare imports with a regex, and an import-shaped sentence in a doc\n * // comment reads to it exactly like a real one — see components/host-node.)\n *\n * <Pressable onPress={open}>\n *   <Controllers>\n *     <GtkDragSource actions={Gdk.DragAction.MOVE} onPrepare={…} />\n *   </Controllers>\n *   <Text>{task.title}</Text>\n * </Pressable>\n * ```\n *\n * It renders nothing where it sits: like `WindowControllers`, it is a\n * portal in React's own sense, so the children keep the context, state and\n * effects they would have at that position while the attachment lands on\n * the widget. They are removed when this component unmounts.\n *\n * Works inside `View`, `Pressable`, `ScrollView`, `Animated.View` and\n * `Root` — every component that owns a widget and hands it down. Inside a\n * GTK widget's own slot there is no enclosing React Native component, and\n * nothing is attached: pass `controllers={…}` to the widget itself there,\n * which is the prop this exists to substitute for.\n *\n * **Linux-only, and the import says so.** Guard it with `Platform.OS` or\n * split the file if the same screen also builds for iOS or Android.\n */\nexport const Controllers = ({ children }: ControllersProps): ReactNode => {\n  const host = useContext(HostNodeContext)\n  // Captured in a PASSIVE effect, not a layout effect, and that is forced:\n  // React attaches host refs bottom-up, so the enclosing `<ViewBox\n  // ref={…}>`'s ref is still null while this child's layout effects run on\n  // the first mount. Passive effects run after the whole commit, by which\n  // time it is set. The cost is that controllers attach one commit late —\n  // unobservable for an event controller (no pointer reaches a widget in\n  // its first frame), and the same delay `WindowActions` already documents\n  // for the window.\n  //\n  // react-hooks/set-state-in-effect is disabled rather than worked around:\n  // the rule guards against effects that derive state from PROPS, which\n  // should be computed during render instead. This derives it from an\n  // imperative handle that does not exist until after the commit — the one\n  // case an effect is the only place it can come from. It runs once and\n  // settles (the setter bails on an unchanged value), so there is no\n  // cascade for the rule to be protecting against.\n  const [widget, setWidget] = useState<Gtk.Widget | null>(null)\n  // eslint-disable-next-line react-hooks/set-state-in-effect\n  useEffect(() => setWidget(host?.widgetRef.current ?? null), [host])\n\n  if (widget === null) {\n    return null\n  }\n  return createSlotPortal(children, widget, \"controllers\")\n}\n"]}

package/dist/gtk/index.d.ts

@@ -1,7 +1,8 @@
 export * from "./widgets.generated";
 export { Gdk, Gio, GLib, GObject, Gtk, Pango } from "../gtkx/bridge/index";
-export { GMenu, GtkAdjustment, GtkDragSource, GtkDropTarget, GtkShortcut, GtkShortcutController, GtkTextBuffer, } from "../gtkx/bridge/index";
+export { GMenu, GtkAdjustment, GtkDragSource, GtkDropControllerMotion, GtkDropTarget, GtkShortcut, GtkShortcutController, GtkTextBuffer, } from "../gtkx/bridge/index";
 export { ApplicationActions, GSimpleAction, WindowActions, WindowControllers, type ApplicationActionsProps, type GSimpleActionProps, type WindowActionsProps, type WindowControllersProps, } from "./window-actions";
+export { Controllers, type ControllersProps } from "./controllers";
 export { useBindSetting, useSetting, type SettingsSchema, type SettingsSchemaKeys, type SettingValue, } from "../gtkx/bridge/index";
 export { css, cx, injectGlobal } from "../gtkx/bridge/index";
 export { quit, useApplication, useParentWindow } from "../gtkx/bridge/index";

package/dist/gtk/index.js

@@ -14,7 +14,7 @@ export { Gdk, Gio, GLib, GObject, Gtk, Pango } from "../gtkx/bridge/index";
 // adjustment (the model objects `GtkTextView`/`GtkSpinRow`-style widgets
 // bind to), keyboard shortcuts, and the two drag-and-drop controllers. See
 // docs/platform-layer.md "Unwrapped by necessity".
-export { GMenu, GtkAdjustment, GtkDragSource, GtkDropTarget, GtkShortcut, GtkShortcutController, GtkTextBuffer, } from "../gtkx/bridge/index";
+export { GMenu, GtkAdjustment, GtkDragSource, GtkDropControllerMotion, GtkDropTarget, GtkShortcut, GtkShortcutController, GtkTextBuffer, } from "../gtkx/bridge/index";
 // Window and application actions declared inside the app tree instead of
 // around it (the AppRegistry options they replace cannot see app context —
 // see window-actions.tsx). GSimpleAction comes from here rather than
@@ -22,6 +22,12 @@ export { GMenu, GtkAdjustment, GtkDragSource, GtkDropTarget, GtkShortcut, GtkSho
 // duplicate action names; on every other path it is gtkx's element,
 // unchanged.
 export { ApplicationActions, GSimpleAction, WindowActions, WindowControllers, } from "./window-actions";
+// The same idea one level down: event controllers attached to the widget of
+// the enclosing React Native component, so a row written in View/Pressable
+// can still carry GTK drag-and-drop. The door onto GTK behaviour that no RN
+// prop expresses — deliberately an element in THIS subpath rather than a
+// prop on `View`, see controllers.tsx.
+export { Controllers } from "./controllers";
 // GSettings: reads and writes backed by a compiled `.gschema.xml` schema.
 // `useSetting`/`useBindSetting` come straight from @gtkx/react; loading a
 // `.gschema.xml` file into the `SettingsSchema` object they expect is a

package/dist/gtk/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/gtk/index.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,8DAA8D;AAC9D,yCAAyC;AACzC,0EAA0E;AAC1E,cAAc,qBAAqB,CAAA;AAEnC,4EAA4E;AAC5E,8EAA8E;AAC9E,mCAAmC;AACnC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAA;AAE1E,oEAAoE;AACpE,0EAA0E;AAC1E,oEAAoE;AACpE,mEAAmE;AACnE,yEAAyE;AACzE,2EAA2E;AAC3E,mDAAmD;AACnD,OAAO,EACL,KAAK,EACL,aAAa,EACb,aAAa,EACb,aAAa,EACb,WAAW,EACX,qBAAqB,EACrB,aAAa,GACd,MAAM,sBAAsB,CAAA;AAE7B,yEAAyE;AACzE,2EAA2E;AAC3E,qEAAqE;AACrE,yEAAyE;AACzE,oEAAoE;AACpE,aAAa;AACb,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,aAAa,EACb,iBAAiB,GAKlB,MAAM,kBAAkB,CAAA;AAEzB,0EAA0E;AAC1E,0EAA0E;AAC1E,wEAAwE;AACxE,mDAAmD;AACnD,OAAO,EACL,cAAc,EACd,UAAU,GAIX,MAAM,sBAAsB,CAAA;AAE7B,oEAAoE;AACpE,0EAA0E;AAC1E,sEAAsE;AACtE,0EAA0E;AAC1E,uEAAuE;AACvE,yEAAyE;AACzE,yEAAyE;AACzE,6DAA6D;AAC7D,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAE5D,yEAAyE;AACzE,wEAAwE;AACxE,uEAAuE;AACvE,6DAA6D;AAC7D,yEAAyE;AACzE,mEAAmE;AACnE,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA","sourcesContent":["// The full GTK widget surface lives in a generated file: every Gtk.Widget\n// subclass gtkx binds, wrapped so React Native drives it. See\n// scripts/generate-widget-surface.ts and\n// scripts/widget-surface/classification.json for how the list is derived.\nexport * from \"./widgets.generated\"\n\n// The GTK namespaces themselves, exported as values because they carry both\n// the enums you need at runtime — `hscrollbarPolicy={Gtk.PolicyType.NEVER}` —\n// and the types you need for refs.\nexport { Gdk, Gio, GLib, GObject, Gtk, Pango } from \"../gtkx/bridge/index\"\n\n// Auxiliary JSX elements that are not Gtk.Widget subclasses, so the\n// generated widget surface above never sees them — real building blocks a\n// non-trivial app still needs: actions and menus (Gio, used through\n// `Gtk.Application`/`Gtk.ApplicationWindow`), a text buffer and an\n// adjustment (the model objects `GtkTextView`/`GtkSpinRow`-style widgets\n// bind to), keyboard shortcuts, and the two drag-and-drop controllers. See\n// docs/platform-layer.md \"Unwrapped by necessity\".\nexport {\n  GMenu,\n  GtkAdjustment,\n  GtkDragSource,\n  GtkDropTarget,\n  GtkShortcut,\n  GtkShortcutController,\n  GtkTextBuffer,\n} from \"../gtkx/bridge/index\"\n\n// Window and application actions declared inside the app tree instead of\n// around it (the AppRegistry options they replace cannot see app context —\n// see window-actions.tsx). GSimpleAction comes from here rather than\n// straight from the bridge because inside these components it arbitrates\n// duplicate action names; on every other path it is gtkx's element,\n// unchanged.\nexport {\n  ApplicationActions,\n  GSimpleAction,\n  WindowActions,\n  WindowControllers,\n  type ApplicationActionsProps,\n  type GSimpleActionProps,\n  type WindowActionsProps,\n  type WindowControllersProps,\n} from \"./window-actions\"\n\n// GSettings: reads and writes backed by a compiled `.gschema.xml` schema.\n// `useSetting`/`useBindSetting` come straight from @gtkx/react; loading a\n// `.gschema.xml` file into the `SettingsSchema` object they expect is a\n// build-time concern (see docs/platform-layer.md).\nexport {\n  useBindSetting,\n  useSetting,\n  type SettingsSchema,\n  type SettingsSchemaKeys,\n  type SettingValue,\n} from \"../gtkx/bridge/index\"\n\n// @gtkx/css — a real GTK CSS class from a tagged template, the same\n// mechanism the style prop's visual half uses under the hood. Re-exported\n// here rather than left to a direct @gtkx/css dependency for the same\n// reason the namespaces above are: one subpath for the whole gtkx toolkit\n// surface, not just Gtk.Widget subclasses. `GObject` above is exported\n// mainly for `GObject.Value` — constructing a boxed value is required by\n// APIs like `Adw.Breakpoint.addSetter`, which reject a bare JS primitive\n// (see docs/platform-layer.md, \"Two ways to react to size\").\nexport { css, cx, injectGlobal } from \"../gtkx/bridge/index\"\n\n// The window and application AppRegistry itself sits on: useParentWindow\n// reaches the Gtk.Window ancestor (for anything not modeled by a prop —\n// e.g. binding a GSettings key to its own defaultWidth/defaultHeight),\n// useApplication reaches the Adw.Application (e.g. to send a\n// Gio.Notification), quit tears the whole app down programmatically (the\n// same function AppRegistry wires to a window's own close button).\nexport { quit, useApplication, useParentWindow } from \"../gtkx/bridge/index\"\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/gtk/index.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,8DAA8D;AAC9D,yCAAyC;AACzC,0EAA0E;AAC1E,cAAc,qBAAqB,CAAA;AAEnC,4EAA4E;AAC5E,8EAA8E;AAC9E,mCAAmC;AACnC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAA;AAE1E,oEAAoE;AACpE,0EAA0E;AAC1E,oEAAoE;AACpE,mEAAmE;AACnE,yEAAyE;AACzE,2EAA2E;AAC3E,mDAAmD;AACnD,OAAO,EACL,KAAK,EACL,aAAa,EACb,aAAa,EACb,uBAAuB,EACvB,aAAa,EACb,WAAW,EACX,qBAAqB,EACrB,aAAa,GACd,MAAM,sBAAsB,CAAA;AAE7B,yEAAyE;AACzE,2EAA2E;AAC3E,qEAAqE;AACrE,yEAAyE;AACzE,oEAAoE;AACpE,aAAa;AACb,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,aAAa,EACb,iBAAiB,GAKlB,MAAM,kBAAkB,CAAA;AAEzB,4EAA4E;AAC5E,2EAA2E;AAC3E,4EAA4E;AAC5E,yEAAyE;AACzE,uCAAuC;AACvC,OAAO,EAAE,WAAW,EAAyB,MAAM,eAAe,CAAA;AAElE,0EAA0E;AAC1E,0EAA0E;AAC1E,wEAAwE;AACxE,mDAAmD;AACnD,OAAO,EACL,cAAc,EACd,UAAU,GAIX,MAAM,sBAAsB,CAAA;AAE7B,oEAAoE;AACpE,0EAA0E;AAC1E,sEAAsE;AACtE,0EAA0E;AAC1E,uEAAuE;AACvE,yEAAyE;AACzE,yEAAyE;AACzE,6DAA6D;AAC7D,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAE5D,yEAAyE;AACzE,wEAAwE;AACxE,uEAAuE;AACvE,6DAA6D;AAC7D,yEAAyE;AACzE,mEAAmE;AACnE,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA","sourcesContent":["// The full GTK widget surface lives in a generated file: every Gtk.Widget\n// subclass gtkx binds, wrapped so React Native drives it. See\n// scripts/generate-widget-surface.ts and\n// scripts/widget-surface/classification.json for how the list is derived.\nexport * from \"./widgets.generated\"\n\n// The GTK namespaces themselves, exported as values because they carry both\n// the enums you need at runtime — `hscrollbarPolicy={Gtk.PolicyType.NEVER}` —\n// and the types you need for refs.\nexport { Gdk, Gio, GLib, GObject, Gtk, Pango } from \"../gtkx/bridge/index\"\n\n// Auxiliary JSX elements that are not Gtk.Widget subclasses, so the\n// generated widget surface above never sees them — real building blocks a\n// non-trivial app still needs: actions and menus (Gio, used through\n// `Gtk.Application`/`Gtk.ApplicationWindow`), a text buffer and an\n// adjustment (the model objects `GtkTextView`/`GtkSpinRow`-style widgets\n// bind to), keyboard shortcuts, and the two drag-and-drop controllers. See\n// docs/platform-layer.md \"Unwrapped by necessity\".\nexport {\n  GMenu,\n  GtkAdjustment,\n  GtkDragSource,\n  GtkDropControllerMotion,\n  GtkDropTarget,\n  GtkShortcut,\n  GtkShortcutController,\n  GtkTextBuffer,\n} from \"../gtkx/bridge/index\"\n\n// Window and application actions declared inside the app tree instead of\n// around it (the AppRegistry options they replace cannot see app context —\n// see window-actions.tsx). GSimpleAction comes from here rather than\n// straight from the bridge because inside these components it arbitrates\n// duplicate action names; on every other path it is gtkx's element,\n// unchanged.\nexport {\n  ApplicationActions,\n  GSimpleAction,\n  WindowActions,\n  WindowControllers,\n  type ApplicationActionsProps,\n  type GSimpleActionProps,\n  type WindowActionsProps,\n  type WindowControllersProps,\n} from \"./window-actions\"\n\n// The same idea one level down: event controllers attached to the widget of\n// the enclosing React Native component, so a row written in View/Pressable\n// can still carry GTK drag-and-drop. The door onto GTK behaviour that no RN\n// prop expresses — deliberately an element in THIS subpath rather than a\n// prop on `View`, see controllers.tsx.\nexport { Controllers, type ControllersProps } from \"./controllers\"\n\n// GSettings: reads and writes backed by a compiled `.gschema.xml` schema.\n// `useSetting`/`useBindSetting` come straight from @gtkx/react; loading a\n// `.gschema.xml` file into the `SettingsSchema` object they expect is a\n// build-time concern (see docs/platform-layer.md).\nexport {\n  useBindSetting,\n  useSetting,\n  type SettingsSchema,\n  type SettingsSchemaKeys,\n  type SettingValue,\n} from \"../gtkx/bridge/index\"\n\n// @gtkx/css — a real GTK CSS class from a tagged template, the same\n// mechanism the style prop's visual half uses under the hood. Re-exported\n// here rather than left to a direct @gtkx/css dependency for the same\n// reason the namespaces above are: one subpath for the whole gtkx toolkit\n// surface, not just Gtk.Widget subclasses. `GObject` above is exported\n// mainly for `GObject.Value` — constructing a boxed value is required by\n// APIs like `Adw.Breakpoint.addSetter`, which reject a bare JS primitive\n// (see docs/platform-layer.md, \"Two ways to react to size\").\nexport { css, cx, injectGlobal } from \"../gtkx/bridge/index\"\n\n// The window and application AppRegistry itself sits on: useParentWindow\n// reaches the Gtk.Window ancestor (for anything not modeled by a prop —\n// e.g. binding a GSettings key to its own defaultWidth/defaultHeight),\n// useApplication reaches the Adw.Application (e.g. to send a\n// Gio.Notification), quit tears the whole app down programmatically (the\n// same function AppRegistry wires to a window's own close button).\nexport { quit, useApplication, useParentWindow } from \"../gtkx/bridge/index\"\n"]}

package/dist/gtkx/bridge/geometry.js

@@ -14,10 +14,12 @@
 // unrealized widget, a singular transform) — every helper here returns null
 // rather than a plausible-looking zero.
 import * as Graphene from "@gtkx/gi/graphene";
-// Graphene.Point's constructor takes plain scalars, so it does not hit the
-// nested-boxed-struct crash that Graphene.Rect's does (RC2-WORKAROUND
-// graphene-rect-nested-boxed-props, docs/gtkx-rc2-notes.md) — but alloc+init
-// is the shape already proven in svg-node.ts, so use it here too.
+// Graphene.Point's constructor takes plain scalars, so it never hit the
+// nested-boxed-struct crash Graphene.Rect's did (the retired
+// graphene-rect-nested-boxed-props workaround, fixed upstream in rc.3 by our
+// gtkx-org/gtkx#473 — see "Fixed in rc.3" in docs/gtkx-rc4-notes.md).
+// alloc+init stays because it is the cheaper of the two here, not because
+// the constructor is unsafe.
 const point = (x, y) => Graphene.Point.alloc().init(x, y);
 /**
  * Translates a point from `widget`'s coordinates into `target`'s.

package/dist/gtkx/bridge/geometry.js.map

@@ -1 +1 @@
-{"version":3,"file":"geometry.js","sourceRoot":"","sources":["../../../src/gtkx/bridge/geometry.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,qEAAqE;AACrE,EAAE;AACF,0EAA0E;AAC1E,2EAA2E;AAC3E,oEAAoE;AACpE,2EAA2E;AAC3E,4EAA4E;AAC5E,6EAA6E;AAC7E,EAAE;AACF,4EAA4E;AAC5E,2EAA2E;AAC3E,2EAA2E;AAC3E,4EAA4E;AAC5E,wCAAwC;AACxC,OAAO,KAAK,QAAQ,MAAM,mBAAmB,CAAA;AAK7C,2EAA2E;AAC3E,sEAAsE;AACtE,6EAA6E;AAC7E,kEAAkE;AAClE,MAAM,KAAK,GAAG,CAAC,CAAS,EAAE,CAAS,EAAkB,EAAE,CACrD,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AAEnC;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,MAAkB,EAClB,MAAkB,EAClB,CAAS,EACT,CAAS,EACK,EAAE;IAChB,MAAM,CAAC,EAAE,EAAE,UAAU,CAAC,GAAG,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IACjE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAA;AACzD,CAAC,CAAA;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,MAAkB,EAClB,CAAS,EACT,CAAS,EACK,EAAE;IAChB,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,EAAE,CAAA;IAC7B,OAAO,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;AACzD,CAAC,CAAA","sourcesContent":["// Widget geometry in foreign coordinate spaces — what RN's measure()/\n// measureInWindow()/measureLayout() and an event's pageX/pageY need.\n//\n// GTK4 folds a widget's allocated position into its transform relative to\n// its parent, so there is no globally meaningful x/y to read off a widget:\n// the position only exists as an answer to \"in whose coordinates?\".\n// gtk_widget_compute_point() walks that transform chain, which is also why\n// it comes out right inside a scrolled viewport — GtkViewport allocates its\n// child at -adjustment.value, so the scroll offset IS the child's transform.\n//\n// gtk_widget_translate_coordinates() and gtk_widget_get_allocation() do the\n// same job and are deprecated since GTK 4.12; compute_point/compute_bounds\n// are the replacements. Both can legitimately fail (no common ancestor, an\n// unrealized widget, a singular transform) — every helper here returns null\n// rather than a plausible-looking zero.\nimport * as Graphene from \"@gtkx/gi/graphene\"\nimport type * as Gtk from \"@gtkx/gi/gtk\"\n\nexport type Point = { x: number; y: number }\n\n// Graphene.Point's constructor takes plain scalars, so it does not hit the\n// nested-boxed-struct crash that Graphene.Rect's does (RC2-WORKAROUND\n// graphene-rect-nested-boxed-props, docs/gtkx-rc2-notes.md) — but alloc+init\n// is the shape already proven in svg-node.ts, so use it here too.\nconst point = (x: number, y: number): Graphene.Point =>\n  Graphene.Point.alloc().init(x, y)\n\n/**\n * Translates a point from `widget`'s coordinates into `target`'s.\n * Returns null when the two are not in the same widget hierarchy.\n */\nexport const computePointIn = (\n  widget: Gtk.Widget,\n  target: Gtk.Widget,\n  x: number,\n  y: number,\n): Point | null => {\n  const [ok, translated] = widget.computePoint(target, point(x, y))\n  return ok ? { x: translated.x, y: translated.y } : null\n}\n\n/**\n * Translates a point from `widget`'s coordinates into its toplevel's — RN's\n * \"page\" space. Returns null for a widget that is not in a window yet.\n */\nexport const computePointInWindow = (\n  widget: Gtk.Widget,\n  x: number,\n  y: number,\n): Point | null => {\n  const root = widget.getRoot()\n  return root ? computePointIn(widget, root, x, y) : null\n}\n"]}
+{"version":3,"file":"geometry.js","sourceRoot":"","sources":["../../../src/gtkx/bridge/geometry.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,qEAAqE;AACrE,EAAE;AACF,0EAA0E;AAC1E,2EAA2E;AAC3E,oEAAoE;AACpE,2EAA2E;AAC3E,4EAA4E;AAC5E,6EAA6E;AAC7E,EAAE;AACF,4EAA4E;AAC5E,2EAA2E;AAC3E,2EAA2E;AAC3E,4EAA4E;AAC5E,wCAAwC;AACxC,OAAO,KAAK,QAAQ,MAAM,mBAAmB,CAAA;AAK7C,wEAAwE;AACxE,6DAA6D;AAC7D,6EAA6E;AAC7E,sEAAsE;AACtE,0EAA0E;AAC1E,6BAA6B;AAC7B,MAAM,KAAK,GAAG,CAAC,CAAS,EAAE,CAAS,EAAkB,EAAE,CACrD,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AAEnC;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,MAAkB,EAClB,MAAkB,EAClB,CAAS,EACT,CAAS,EACK,EAAE;IAChB,MAAM,CAAC,EAAE,EAAE,UAAU,CAAC,GAAG,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IACjE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAA;AACzD,CAAC,CAAA;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,MAAkB,EAClB,CAAS,EACT,CAAS,EACK,EAAE;IAChB,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,EAAE,CAAA;IAC7B,OAAO,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;AACzD,CAAC,CAAA","sourcesContent":["// Widget geometry in foreign coordinate spaces — what RN's measure()/\n// measureInWindow()/measureLayout() and an event's pageX/pageY need.\n//\n// GTK4 folds a widget's allocated position into its transform relative to\n// its parent, so there is no globally meaningful x/y to read off a widget:\n// the position only exists as an answer to \"in whose coordinates?\".\n// gtk_widget_compute_point() walks that transform chain, which is also why\n// it comes out right inside a scrolled viewport — GtkViewport allocates its\n// child at -adjustment.value, so the scroll offset IS the child's transform.\n//\n// gtk_widget_translate_coordinates() and gtk_widget_get_allocation() do the\n// same job and are deprecated since GTK 4.12; compute_point/compute_bounds\n// are the replacements. Both can legitimately fail (no common ancestor, an\n// unrealized widget, a singular transform) — every helper here returns null\n// rather than a plausible-looking zero.\nimport * as Graphene from \"@gtkx/gi/graphene\"\nimport type * as Gtk from \"@gtkx/gi/gtk\"\n\nexport type Point = { x: number; y: number }\n\n// Graphene.Point's constructor takes plain scalars, so it never hit the\n// nested-boxed-struct crash Graphene.Rect's did (the retired\n// graphene-rect-nested-boxed-props workaround, fixed upstream in rc.3 by our\n// gtkx-org/gtkx#473 — see \"Fixed in rc.3\" in docs/gtkx-rc4-notes.md).\n// alloc+init stays because it is the cheaper of the two here, not because\n// the constructor is unsafe.\nconst point = (x: number, y: number): Graphene.Point =>\n  Graphene.Point.alloc().init(x, y)\n\n/**\n * Translates a point from `widget`'s coordinates into `target`'s.\n * Returns null when the two are not in the same widget hierarchy.\n */\nexport const computePointIn = (\n  widget: Gtk.Widget,\n  target: Gtk.Widget,\n  x: number,\n  y: number,\n): Point | null => {\n  const [ok, translated] = widget.computePoint(target, point(x, y))\n  return ok ? { x: translated.x, y: translated.y } : null\n}\n\n/**\n * Translates a point from `widget`'s coordinates into its toplevel's — RN's\n * \"page\" space. Returns null for a widget that is not in a window yet.\n */\nexport const computePointInWindow = (\n  widget: Gtk.Widget,\n  x: number,\n  y: number,\n): Point | null => {\n  const root = widget.getRoot()\n  return root ? computePointIn(widget, root, x, y) : null\n}\n"]}

package/dist/gtkx/bridge/index.d.ts

@@ -11,15 +11,17 @@ export { Adw, Gdk, Gio, GLib, GObject, Graphene, Gsk, Gtk, Pango };
 export { GtkApplication, GtkGestureClick } from "@gtkx/jsx/gtk";
 export { GMenu, GSimpleAction } from "@gtkx/jsx/gio";
 export { AdwBreakpoint, AdwShortcutsItem, AdwShortcutsSection, AdwToggle, } from "@gtkx/jsx/adw";
-export { GtkAdjustment, GtkDragSource, GtkDropTarget, GtkShortcut, GtkShortcutController, GtkTextBuffer, } from "@gtkx/jsx/gtk";
+export { GtkAdjustment, GtkDragSource, GtkDropControllerMotion, GtkDropTarget, GtkShortcut, GtkShortcutController, GtkTextBuffer, } from "@gtkx/jsx/gtk";
 export * from "./widgets.generated";
-export { createPortal, createRoot, quit, rootElement, useApplication, useBindSetting, useParentWindow, useProperty, useSetting, type Root, type RootElement, type SettingsSchema, type SettingsSchemaKeys, type SettingValue, } from "@gtkx/react";
+export { createPortal, createRoot, quit, rootElement, useApplication, useBindSetting, useParentWindow, useProperty, useSetting, type Root, type RootElement, } from "@gtkx/react";
+export type { SettingsSchema, SettingsSchemaKeys, SettingValue, } from "@gtkx/react/internal";
 export { useSignal } from "./use-signal";
 export { css, cx, injectGlobal } from "@gtkx/css";
+export { createWidgetCss, type WidgetCss } from "./widget-css";
 export { createTextProbe, measureWidget, toNumber } from "./measure";
 export { computePointIn, computePointInWindow, type Point } from "./geometry";
 export { createSlotPortal } from "./slot-portal";
-export { getViewBoxComponent, setBoxPassthrough } from "./view-box";
+export { cacheChildOrder, getViewBoxComponent, invalidateZOrder, setBoxOnly, setBoxPassthrough, setHitSlop, setPaintOnlyLeaf, setPointerTarget, setZIndex, type HitSlop, } from "./view-box";
 export { getSvgNodeComponent, getSvgNodeDescriptor, queueSvgRedraw, resolveSvgColor, resolveSvgPaint, setSvgNodeDescriptor, type SvgDefsDescriptor, type SvgGradientUnits, type SvgGroupDescriptor, type SvgLinearGradientDescriptor, type SvgNodeDescriptor, type SvgPaintSpec, type SvgRadialGradientDescriptor, type SvgShapeDescriptor, type SvgStopDescriptor, type SvgSvgDescriptor, } from "./svg-node";
 export { allocateChild, attachRnLayout, detachRnLayout, queueAllocate, queueResize, type RnLayoutHooks, type RnLayoutOrientation, } from "./layout-manager";
 export { colorScheme, styleManager } from "./theme";

package/dist/gtkx/bridge/index.js

@@ -1,7 +1,7 @@
 // The ONLY module allowed to import @gtkx/* (enforced by eslint no-restricted-imports).
 // gtkx is an RC dependency: when its API moves, this bridge absorbs the change.
 //
-// Caveats baked into this surface (catalogued in docs/gtkx-rc3-notes.md):
+// Caveats baked into this surface (catalogued in docs/gtkx-rc4-notes.md):
 // - 64-bit FFI values arrive as BigInt → normalize with toNumber() at this boundary
 // import-then-export (not `export * as`): the latter is the one syntax the
 // stock @react-native/babel-preset cannot transform — this form keeps
@@ -44,7 +44,7 @@ export { GtkApplication, GtkGestureClick } from "@gtkx/jsx/gtk";
 // docs/platform-layer.md, "Two ways to react to size").
 export { GMenu, GSimpleAction } from "@gtkx/jsx/gio";
 export { AdwBreakpoint, AdwShortcutsItem, AdwShortcutsSection, AdwToggle, } from "@gtkx/jsx/adw";
-export { GtkAdjustment, GtkDragSource, GtkDropTarget, GtkShortcut, GtkShortcutController, GtkTextBuffer, } from "@gtkx/jsx/gtk";
+export { GtkAdjustment, GtkDragSource, GtkDropControllerMotion, GtkDropTarget, GtkShortcut, GtkShortcutController, GtkTextBuffer, } from "@gtkx/jsx/gtk";
 // The full widget surface — every GTK/Adwaita class gtkx binds that derives
 // Gtk.Widget, raw. src/gtk/widgets.generated and src/adw/widgets.generated
 // wrap most of them with wrapReactNative; this file is where @gtkx/jsx is
@@ -57,13 +57,16 @@ export { createPortal, createRoot, quit, rootElement, useApplication, useBindSet
 // there (rc.3 delivers a stale handler).
 export { useSignal } from "./use-signal";
 export { css, cx, injectGlobal } from "@gtkx/css";
+// The imperative counterpart of `css`: a private provider on one widget,
+// for values that change per frame and must not enter the shared stylesheet.
+export { createWidgetCss } from "./widget-css";
 export { createTextProbe, measureWidget, toNumber } from "./measure";
 export { computePointIn, computePointInWindow } from "./geometry";
 // A portal into a NAMED slot of a remote object (the window's action map,
 // its controllers) rather than into its default child slot — see the file
 // for why gtkx's own createPortal is not enough on its own.
 export { createSlotPortal } from "./slot-portal";
-export { getViewBoxComponent, setBoxPassthrough } from "./view-box";
+export { cacheChildOrder, getViewBoxComponent, invalidateZOrder, setBoxOnly, setBoxPassthrough, setHitSlop, setPaintOnlyLeaf, setPointerTarget, setZIndex, } from "./view-box";
 export { getSvgNodeComponent, getSvgNodeDescriptor, queueSvgRedraw, resolveSvgColor, resolveSvgPaint, setSvgNodeDescriptor, } from "./svg-node";
 export { allocateChild, attachRnLayout, detachRnLayout, queueAllocate, queueResize, } from "./layout-manager";
 export { colorScheme, styleManager } from "./theme";

package/dist/gtkx/bridge/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/gtkx/bridge/index.ts"],"names":[],"mappings":"AAAA,wFAAwF;AACxF,gFAAgF;AAChF,EAAE;AACF,0EAA0E;AAC1E,oFAAoF;AAEpF,2EAA2E;AAC3E,sEAAsE;AACtE,qDAAqD;AACrD,OAAO,KAAK,GAAG,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,GAAG,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,GAAG,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,IAAI,MAAM,eAAe,CAAA;AACrC,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAA;AAC3C,OAAO,KAAK,QAAQ,MAAM,mBAAmB,CAAA;AAC7C,OAAO,KAAK,GAAG,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,GAAG,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,KAAK,MAAM,gBAAgB,CAAA;AAEvC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,CAAA;AAElE,uEAAuE;AACvE,2EAA2E;AAC3E,2EAA2E;AAC3E,WAAW;AACX,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAE/D,4EAA4E;AAC5E,6EAA6E;AAC7E,sEAAsE;AACtE,qEAAqE;AACrE,6EAA6E;AAC7E,0EAA0E;AAC1E,4EAA4E;AAC5E,4EAA4E;AAC5E,iCAAiC;AACjC,EAAE;AACF,sDAAsD;AACtD,yEAAyE;AACzE,2EAA2E;AAC3E,yEAAyE;AACzE,0EAA0E;AAC1E,sEAAsE;AACtE,2EAA2E;AAC3E,sEAAsE;AACtE,+DAA+D;AAC/D,sEAAsE;AACtE,wDAAwD;AACxD,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,SAAS,GACV,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,aAAa,EACb,aAAa,EACb,aAAa,EACb,WAAW,EACX,qBAAqB,EACrB,aAAa,GACd,MAAM,eAAe,CAAA;AAEtB,4EAA4E;AAC5E,2EAA2E;AAC3E,0EAA0E;AAC1E,sEAAsE;AACtE,0EAA0E;AAC1E,6BAA6B;AAC7B,cAAc,qBAAqB,CAAA;AAEnC,OAAO,EACL,YAAY,EACZ,UAAU,EACV,IAAI,EACJ,WAAW,EACX,cAAc,EACd,cAAc,EACd,eAAe,EACf,WAAW,EACX,UAAU,GAMX,MAAM,aAAa,CAAA;AAEpB,+EAA+E;AAC/E,yCAAyC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAExC,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAEjD,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AACpE,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAc,MAAM,YAAY,CAAA;AAC7E,0EAA0E;AAC1E,0EAA0E;AAC1E,4DAA4D;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnE,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,cAAc,EACd,eAAe,EACf,eAAe,EACf,oBAAoB,GAWrB,MAAM,YAAY,CAAA;AACnB,OAAO,EACL,aAAa,EACb,cAAc,EACd,cAAc,EACd,aAAa,EACb,WAAW,GAGZ,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA","sourcesContent":["// The ONLY module allowed to import @gtkx/* (enforced by eslint no-restricted-imports).\n// gtkx is an RC dependency: when its API moves, this bridge absorbs the change.\n//\n// Caveats baked into this surface (catalogued in docs/gtkx-rc3-notes.md):\n// - 64-bit FFI values arrive as BigInt → normalize with toNumber() at this boundary\n\n// import-then-export (not `export * as`): the latter is the one syntax the\n// stock @react-native/babel-preset cannot transform — this form keeps\n// consumer apps on their unmodified RN Babel config.\nimport * as Adw from \"@gtkx/gi/adw\"\nimport * as Gdk from \"@gtkx/gi/gdk\"\nimport * as Gio from \"@gtkx/gi/gio\"\nimport * as GLib from \"@gtkx/gi/glib\"\nimport * as GObject from \"@gtkx/gi/gobject\"\nimport * as Graphene from \"@gtkx/gi/graphene\"\nimport * as Gsk from \"@gtkx/gi/gsk\"\nimport * as Gtk from \"@gtkx/gi/gtk\"\nimport * as Pango from \"@gtkx/gi/pango\"\n\nexport { Adw, Gdk, Gio, GLib, GObject, Graphene, Gsk, Gtk, Pango }\n\n// GtkApplication and GtkGestureClick are not Gtk.Widget subclasses (an\n// application object and an event controller, respectively), so the widget\n// surface generator never sees them — kept here by hand, same as before it\n// existed.\nexport { GtkApplication, GtkGestureClick } from \"@gtkx/jsx/gtk\"\n\n// Auxiliary gtkx JSX elements that are not Gtk.Widget/Adw.Widget subclasses\n// either, same reason as the pair above — scripts/generate-widget-surface.ts\n// only classifies widgets, so these fall into its \"notAWidget\" bucket\n// (see scripts/widget-surface/classification.json) and are otherwise\n// unreachable through react-native-gtkx/gtk or /adw. Every one of these is a\n// real, necessary building block for a real app: actions and menus (Gio),\n// a responsive breakpoint (Adw), a text buffer and an adjustment (the model\n// objects GtkTextView/GtkSpinRow etc. bind to), keyboard shortcuts, and the\n// two drag-and-drop controllers.\n//\n// Adw.Breakpoint specifically: independently verified\n// (`Adw.Breakpoint.prototype instanceof Gtk.Widget === false`, prototype\n// chain bottoms out at plain GObject.Object) — it draws nothing and has no\n// size, it is a declaration (a condition plus a set of property setters)\n// attached to a Window/ApplicationWindow/Dialog/BreakpointBin. Running it\n// through wrapReactNative would give it a Yoga node for a widget that\n// occupies no space: a layout bug, not a convenience. Adw.BreakpointBin (a\n// real widget, the container that scopes breakpoints to a subtree) is\n// wrapped normally in ./widgets.generated instead, and is what\n// createSidebarNavigator's own collapse pairs AdwBreakpoint with (see\n// docs/platform-layer.md, \"Two ways to react to size\").\nexport { GMenu, GSimpleAction } from \"@gtkx/jsx/gio\"\nexport {\n  AdwBreakpoint,\n  AdwShortcutsItem,\n  AdwShortcutsSection,\n  AdwToggle,\n} from \"@gtkx/jsx/adw\"\nexport {\n  GtkAdjustment,\n  GtkDragSource,\n  GtkDropTarget,\n  GtkShortcut,\n  GtkShortcutController,\n  GtkTextBuffer,\n} from \"@gtkx/jsx/gtk\"\n\n// The full widget surface — every GTK/Adwaita class gtkx binds that derives\n// Gtk.Widget, raw. src/gtk/widgets.generated and src/adw/widgets.generated\n// wrap most of them with wrapReactNative; this file is where @gtkx/jsx is\n// still allowed to be imported directly (see the eslint carve-out for\n// src/gtkx/bridge/**), so they pull the raw widgets from here rather than\n// from @gtkx/jsx themselves.\nexport * from \"./widgets.generated\"\n\nexport {\n  createPortal,\n  createRoot,\n  quit,\n  rootElement,\n  useApplication,\n  useBindSetting,\n  useParentWindow,\n  useProperty,\n  useSetting,\n  type Root,\n  type RootElement,\n  type SettingsSchema,\n  type SettingsSchemaKeys,\n  type SettingValue,\n} from \"@gtkx/react\"\n\n// useSignal comes from ./use-signal, not @gtkx/react — see the workaround note\n// there (rc.3 delivers a stale handler).\nexport { useSignal } from \"./use-signal\"\n\nexport { css, cx, injectGlobal } from \"@gtkx/css\"\n\nexport { createTextProbe, measureWidget, toNumber } from \"./measure\"\nexport { computePointIn, computePointInWindow, type Point } from \"./geometry\"\n// A portal into a NAMED slot of a remote object (the window's action map,\n// its controllers) rather than into its default child slot — see the file\n// for why gtkx's own createPortal is not enough on its own.\nexport { createSlotPortal } from \"./slot-portal\"\nexport { getViewBoxComponent, setBoxPassthrough } from \"./view-box\"\nexport {\n  getSvgNodeComponent,\n  getSvgNodeDescriptor,\n  queueSvgRedraw,\n  resolveSvgColor,\n  resolveSvgPaint,\n  setSvgNodeDescriptor,\n  type SvgDefsDescriptor,\n  type SvgGradientUnits,\n  type SvgGroupDescriptor,\n  type SvgLinearGradientDescriptor,\n  type SvgNodeDescriptor,\n  type SvgPaintSpec,\n  type SvgRadialGradientDescriptor,\n  type SvgShapeDescriptor,\n  type SvgStopDescriptor,\n  type SvgSvgDescriptor,\n} from \"./svg-node\"\nexport {\n  allocateChild,\n  attachRnLayout,\n  detachRnLayout,\n  queueAllocate,\n  queueResize,\n  type RnLayoutHooks,\n  type RnLayoutOrientation,\n} from \"./layout-manager\"\nexport { colorScheme, styleManager } from \"./theme\"\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/gtkx/bridge/index.ts"],"names":[],"mappings":"AAAA,wFAAwF;AACxF,gFAAgF;AAChF,EAAE;AACF,0EAA0E;AAC1E,oFAAoF;AAEpF,2EAA2E;AAC3E,sEAAsE;AACtE,qDAAqD;AACrD,OAAO,KAAK,GAAG,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,GAAG,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,GAAG,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,IAAI,MAAM,eAAe,CAAA;AACrC,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAA;AAC3C,OAAO,KAAK,QAAQ,MAAM,mBAAmB,CAAA;AAC7C,OAAO,KAAK,GAAG,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,GAAG,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,KAAK,MAAM,gBAAgB,CAAA;AAEvC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,CAAA;AAElE,uEAAuE;AACvE,2EAA2E;AAC3E,2EAA2E;AAC3E,WAAW;AACX,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAE/D,4EAA4E;AAC5E,6EAA6E;AAC7E,sEAAsE;AACtE,qEAAqE;AACrE,6EAA6E;AAC7E,0EAA0E;AAC1E,4EAA4E;AAC5E,4EAA4E;AAC5E,iCAAiC;AACjC,EAAE;AACF,sDAAsD;AACtD,yEAAyE;AACzE,2EAA2E;AAC3E,yEAAyE;AACzE,0EAA0E;AAC1E,sEAAsE;AACtE,2EAA2E;AAC3E,sEAAsE;AACtE,+DAA+D;AAC/D,sEAAsE;AACtE,wDAAwD;AACxD,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,mBAAmB,EACnB,SAAS,GACV,MAAM,eAAe,CAAA;AACtB,OAAO,EACL,aAAa,EACb,aAAa,EACb,uBAAuB,EACvB,aAAa,EACb,WAAW,EACX,qBAAqB,EACrB,aAAa,GACd,MAAM,eAAe,CAAA;AAEtB,4EAA4E;AAC5E,2EAA2E;AAC3E,0EAA0E;AAC1E,sEAAsE;AACtE,0EAA0E;AAC1E,6BAA6B;AAC7B,cAAc,qBAAqB,CAAA;AAEnC,OAAO,EACL,YAAY,EACZ,UAAU,EACV,IAAI,EACJ,WAAW,EACX,cAAc,EACd,cAAc,EACd,eAAe,EACf,WAAW,EACX,UAAU,GAGX,MAAM,aAAa,CAAA;AAcpB,+EAA+E;AAC/E,yCAAyC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAExC,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAEjD,yEAAyE;AACzE,6EAA6E;AAC7E,OAAO,EAAE,eAAe,EAAkB,MAAM,cAAc,CAAA;AAE9D,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AACpE,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAc,MAAM,YAAY,CAAA;AAC7E,0EAA0E;AAC1E,0EAA0E;AAC1E,4DAA4D;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAChD,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,UAAU,EACV,iBAAiB,EACjB,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,SAAS,GAEV,MAAM,YAAY,CAAA;AACnB,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,cAAc,EACd,eAAe,EACf,eAAe,EACf,oBAAoB,GAWrB,MAAM,YAAY,CAAA;AACnB,OAAO,EACL,aAAa,EACb,cAAc,EACd,cAAc,EACd,aAAa,EACb,WAAW,GAGZ,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA","sourcesContent":["// The ONLY module allowed to import @gtkx/* (enforced by eslint no-restricted-imports).\n// gtkx is an RC dependency: when its API moves, this bridge absorbs the change.\n//\n// Caveats baked into this surface (catalogued in docs/gtkx-rc4-notes.md):\n// - 64-bit FFI values arrive as BigInt → normalize with toNumber() at this boundary\n\n// import-then-export (not `export * as`): the latter is the one syntax the\n// stock @react-native/babel-preset cannot transform — this form keeps\n// consumer apps on their unmodified RN Babel config.\nimport * as Adw from \"@gtkx/gi/adw\"\nimport * as Gdk from \"@gtkx/gi/gdk\"\nimport * as Gio from \"@gtkx/gi/gio\"\nimport * as GLib from \"@gtkx/gi/glib\"\nimport * as GObject from \"@gtkx/gi/gobject\"\nimport * as Graphene from \"@gtkx/gi/graphene\"\nimport * as Gsk from \"@gtkx/gi/gsk\"\nimport * as Gtk from \"@gtkx/gi/gtk\"\nimport * as Pango from \"@gtkx/gi/pango\"\n\nexport { Adw, Gdk, Gio, GLib, GObject, Graphene, Gsk, Gtk, Pango }\n\n// GtkApplication and GtkGestureClick are not Gtk.Widget subclasses (an\n// application object and an event controller, respectively), so the widget\n// surface generator never sees them — kept here by hand, same as before it\n// existed.\nexport { GtkApplication, GtkGestureClick } from \"@gtkx/jsx/gtk\"\n\n// Auxiliary gtkx JSX elements that are not Gtk.Widget/Adw.Widget subclasses\n// either, same reason as the pair above — scripts/generate-widget-surface.ts\n// only classifies widgets, so these fall into its \"notAWidget\" bucket\n// (see scripts/widget-surface/classification.json) and are otherwise\n// unreachable through react-native-gtkx/gtk or /adw. Every one of these is a\n// real, necessary building block for a real app: actions and menus (Gio),\n// a responsive breakpoint (Adw), a text buffer and an adjustment (the model\n// objects GtkTextView/GtkSpinRow etc. bind to), keyboard shortcuts, and the\n// two drag-and-drop controllers.\n//\n// Adw.Breakpoint specifically: independently verified\n// (`Adw.Breakpoint.prototype instanceof Gtk.Widget === false`, prototype\n// chain bottoms out at plain GObject.Object) — it draws nothing and has no\n// size, it is a declaration (a condition plus a set of property setters)\n// attached to a Window/ApplicationWindow/Dialog/BreakpointBin. Running it\n// through wrapReactNative would give it a Yoga node for a widget that\n// occupies no space: a layout bug, not a convenience. Adw.BreakpointBin (a\n// real widget, the container that scopes breakpoints to a subtree) is\n// wrapped normally in ./widgets.generated instead, and is what\n// createSidebarNavigator's own collapse pairs AdwBreakpoint with (see\n// docs/platform-layer.md, \"Two ways to react to size\").\nexport { GMenu, GSimpleAction } from \"@gtkx/jsx/gio\"\nexport {\n  AdwBreakpoint,\n  AdwShortcutsItem,\n  AdwShortcutsSection,\n  AdwToggle,\n} from \"@gtkx/jsx/adw\"\nexport {\n  GtkAdjustment,\n  GtkDragSource,\n  GtkDropControllerMotion,\n  GtkDropTarget,\n  GtkShortcut,\n  GtkShortcutController,\n  GtkTextBuffer,\n} from \"@gtkx/jsx/gtk\"\n\n// The full widget surface — every GTK/Adwaita class gtkx binds that derives\n// Gtk.Widget, raw. src/gtk/widgets.generated and src/adw/widgets.generated\n// wrap most of them with wrapReactNative; this file is where @gtkx/jsx is\n// still allowed to be imported directly (see the eslint carve-out for\n// src/gtkx/bridge/**), so they pull the raw widgets from here rather than\n// from @gtkx/jsx themselves.\nexport * from \"./widgets.generated\"\n\nexport {\n  createPortal,\n  createRoot,\n  quit,\n  rootElement,\n  useApplication,\n  useBindSetting,\n  useParentWindow,\n  useProperty,\n  useSetting,\n  type Root,\n  type RootElement,\n} from \"@gtkx/react\"\n\n// rc.4 moved the settings-schema types off the public entry point into\n// /internal, with no replacement on `@gtkx/react` — `useSetting`/\n// `useBindSetting` are still public and still typed by them, so a consumer\n// that wants to name the type of a setting has no supported import for it.\n// We re-export them from here, which is the whole point of the bridge; the\n// ask to put them back is filed in docs/upstream-gtkx.md.\nexport type {\n  SettingsSchema,\n  SettingsSchemaKeys,\n  SettingValue,\n} from \"@gtkx/react/internal\"\n\n// useSignal comes from ./use-signal, not @gtkx/react — see the workaround note\n// there (rc.3 delivers a stale handler).\nexport { useSignal } from \"./use-signal\"\n\nexport { css, cx, injectGlobal } from \"@gtkx/css\"\n\n// The imperative counterpart of `css`: a private provider on one widget,\n// for values that change per frame and must not enter the shared stylesheet.\nexport { createWidgetCss, type WidgetCss } from \"./widget-css\"\n\nexport { createTextProbe, measureWidget, toNumber } from \"./measure\"\nexport { computePointIn, computePointInWindow, type Point } from \"./geometry\"\n// A portal into a NAMED slot of a remote object (the window's action map,\n// its controllers) rather than into its default child slot — see the file\n// for why gtkx's own createPortal is not enough on its own.\nexport { createSlotPortal } from \"./slot-portal\"\nexport {\n  cacheChildOrder,\n  getViewBoxComponent,\n  invalidateZOrder,\n  setBoxOnly,\n  setBoxPassthrough,\n  setHitSlop,\n  setPaintOnlyLeaf,\n  setPointerTarget,\n  setZIndex,\n  type HitSlop,\n} from \"./view-box\"\nexport {\n  getSvgNodeComponent,\n  getSvgNodeDescriptor,\n  queueSvgRedraw,\n  resolveSvgColor,\n  resolveSvgPaint,\n  setSvgNodeDescriptor,\n  type SvgDefsDescriptor,\n  type SvgGradientUnits,\n  type SvgGroupDescriptor,\n  type SvgLinearGradientDescriptor,\n  type SvgNodeDescriptor,\n  type SvgPaintSpec,\n  type SvgRadialGradientDescriptor,\n  type SvgShapeDescriptor,\n  type SvgStopDescriptor,\n  type SvgSvgDescriptor,\n} from \"./svg-node\"\nexport {\n  allocateChild,\n  attachRnLayout,\n  detachRnLayout,\n  queueAllocate,\n  queueResize,\n  type RnLayoutHooks,\n  type RnLayoutOrientation,\n} from \"./layout-manager\"\nexport { colorScheme, styleManager } from \"./theme\"\n"]}

package/dist/gtkx/bridge/slot-portal.js.map

@@ -1 +1 @@
-{"version":3,"file":"slot-portal.js","sourceRoot":"","sources":["../../../src/gtkx/bridge/slot-portal.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,aAAa,EAA0C,MAAM,OAAO,CAAA;AAE7E,2EAA2E;AAC3E,yEAAyE;AACzE,8CAA8C;AAC9C,MAAM,YAAY,GAAG,WAGnB,CAAA;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,QAAmB,EACnB,MAAsB,EACtB,IAAY,EACZ,GAAY,EACD,EAAE,CACb,YAAY,CACV,aAAa,CAAC,YAAY,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,QAAQ,CAAC,EACzD,MAAM,EACN,GAAG,CACJ,CAAA","sourcesContent":["// Rendering children into a NAMED SLOT of an object that is not their parent.\n//\n// gtkx's own `createPortal(children, container)` targets the container's\n// DEFAULT slot — \"children\", the one a widget takes another widget through.\n// Everything else an object can be given declaratively is a named slot\n// reached in JSX by an element-valued PROP: a window's `Gio.ActionMap`\n// (`actions`), the event controllers on a widget (`controllers`), an\n// `AdwApplicationWindow`'s `breakpoints`. Those slots are what the\n// reconciler routes an element-valued prop into — it wraps the prop's value\n// in an internal element that carries the slot name, and that element is\n// what actually places children into the named slot.\n//\n// So a portal whose single child is that internal element lands its children\n// in a named slot of a remote object, which is what `WindowActions` and\n// `WindowControllers` need: declare in the app tree, attach to the window.\n//\n// RC3-WORKAROUND(prop-portal): the internal element's name is spelled out\n// here because @gtkx/react exports it from neither its public entry point\n// nor its `/internal` subpath — only from a deep module path, which this\n// package does not reach into. The bridge is the one module allowed to know\n// a gtkx internal, so the knowledge is confined to this file: if the name\n// ever changes, exactly one line moves. See docs/gtkx-rc3-notes.md.\nimport type * as GObject from \"@gtkx/gi/gobject\"\nimport { createPortal } from \"@gtkx/react\"\nimport { createElement, type FunctionComponent, type ReactNode } from \"react\"\n\n// Typed as a component rather than an intrinsic tag: \"gtkx:prop\" is not in\n// the generated JSX.IntrinsicElements map (it is not a GObject type), so\n// createElement would reject the bare string.\nconst PROP_ELEMENT = \"gtkx:prop\" as unknown as FunctionComponent<{\n  propName: string\n  children?: ReactNode\n}>\n\n/**\n * A React portal that renders `children` into `target`'s named `slot`\n * instead of into the tree position where it is written — the declarative\n * equivalent of passing `<Target slot={children} />`, for a target the\n * declaring component does not render.\n *\n * The children stay part of the React tree where the portal element sits,\n * so context, state and effects behave exactly as they would in place.\n */\nexport const createSlotPortal = (\n  children: ReactNode,\n  target: GObject.Object,\n  slot: string,\n  key?: string,\n): ReactNode =>\n  createPortal(\n    createElement(PROP_ELEMENT, { propName: slot }, children),\n    target,\n    key,\n  )\n"]}
+{"version":3,"file":"slot-portal.js","sourceRoot":"","sources":["../../../src/gtkx/bridge/slot-portal.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,EAAE,aAAa,EAA0C,MAAM,OAAO,CAAA;AAE7E,2EAA2E;AAC3E,yEAAyE;AACzE,8CAA8C;AAC9C,MAAM,YAAY,GAAG,WAGnB,CAAA;AAEF;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,QAAmB,EACnB,MAAsB,EACtB,IAAY,EACZ,GAAY,EACD,EAAE,CACb,YAAY,CACV,aAAa,CAAC,YAAY,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,QAAQ,CAAC,EACzD,MAAM,EACN,GAAG,CACJ,CAAA","sourcesContent":["// Rendering children into a NAMED SLOT of an object that is not their parent.\n//\n// gtkx's own `createPortal(children, container)` targets the container's\n// DEFAULT slot — \"children\", the one a widget takes another widget through.\n// Everything else an object can be given declaratively is a named slot\n// reached in JSX by an element-valued PROP: a window's `Gio.ActionMap`\n// (`actions`), the event controllers on a widget (`controllers`), an\n// `AdwApplicationWindow`'s `breakpoints`. Those slots are what the\n// reconciler routes an element-valued prop into — it wraps the prop's value\n// in an internal element that carries the slot name, and that element is\n// what actually places children into the named slot.\n//\n// So a portal whose single child is that internal element lands its children\n// in a named slot of a remote object, which is what `WindowActions` and\n// `WindowControllers` need: declare in the app tree, attach to the window.\n//\n// RC4-WORKAROUND(prop-portal): the internal element's name is spelled out\n// here because @gtkx/react exports it from neither its public entry point\n// nor its `/internal` subpath — only from a deep module path, which this\n// package does not reach into. The bridge is the one module allowed to know\n// a gtkx internal, so the knowledge is confined to this file: if the name\n// ever changes, exactly one line moves. See docs/gtkx-rc4-notes.md.\nimport type * as GObject from \"@gtkx/gi/gobject\"\nimport { createPortal } from \"@gtkx/react\"\nimport { createElement, type FunctionComponent, type ReactNode } from \"react\"\n\n// Typed as a component rather than an intrinsic tag: \"gtkx:prop\" is not in\n// the generated JSX.IntrinsicElements map (it is not a GObject type), so\n// createElement would reject the bare string.\nconst PROP_ELEMENT = \"gtkx:prop\" as unknown as FunctionComponent<{\n  propName: string\n  children?: ReactNode\n}>\n\n/**\n * A React portal that renders `children` into `target`'s named `slot`\n * instead of into the tree position where it is written — the declarative\n * equivalent of passing `<Target slot={children} />`, for a target the\n * declaring component does not render.\n *\n * The children stay part of the React tree where the portal element sits,\n * so context, state and effects behave exactly as they would in place.\n */\nexport const createSlotPortal = (\n  children: ReactNode,\n  target: GObject.Object,\n  slot: string,\n  key?: string,\n): ReactNode =>\n  createPortal(\n    createElement(PROP_ELEMENT, { propName: slot }, children),\n    target,\n    key,\n  )\n"]}

package/dist/gtkx/bridge/use-signal.js

@@ -1,4 +1,4 @@
-// RC3-WORKAROUND(use-signal-stale-handler): see docs/gtkx-rc3-notes.md
+// RC4-WORKAROUND(use-signal-stale-handler): see docs/gtkx-rc4-notes.md
 // @gtkx/react's useSignal documents that "each emission runs the handler from
 // the latest render", and rc.1 delivered that by pinning the handler in a ref
 // of its own. rc.3 routes it through React's useEffectEvent instead, and

package/dist/gtkx/bridge/use-signal.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-signal.js","sourceRoot":"","sources":["../../../src/gtkx/bridge/use-signal.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,8EAA8E;AAC9E,8EAA8E;AAC9E,yEAAyE;AACzE,2DAA2D;AAC3D,2EAA2E;AAC3E,6EAA6E;AAC7E,4EAA4E;AAC5E,mEAAmE;AACnE,+DAA+D;AAC/D,4EAA4E;AAC5E,8EAA8E;AAC9E,uEAAuE;AACvE,yEAAyE;AACzE,wEAAwE;AACxE,0EAA0E;AAC1E,EAAE;AACF,8EAA8E;AAC9E,6EAA6E;AAC7E,8EAA8E;AAC9E,+EAA+E;AAC/E,qEAAqE;AACrE,yEAAyE;AACzE,uDAAuD;AACvD,0EAA0E;AAC1E,2EAA2E;AAC3E,uEAAuE;AACvE,0EAA0E;AAC1E,OAAO,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,aAAa,CAAA;AACxD,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,OAAO,CAAA;AAI/D,MAAM,CAAC,MAAM,SAAS,GAAyB,CAC7C,MAAM,EACN,MAAM,EACN,OAAO,EACP,OAAO,EACP,EAAE;IACF,4EAA4E;IAC5E,iEAAiE;IACjE,MAAM,MAAM,GAAG,MAAM,CAAa,GAAG,EAAE,CAAC,SAAS,CAAC,CAAA;IAClD,kBAAkB,CAAC,GAAG,EAAE;QACtB,MAAM,CAAC,OAAO,GAAG,OAAgC,CAAA;IACnD,CAAC,CAAC,CAAA;IACF,MAAM,MAAM,GAAG,WAAW,CACxB,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,EACpC,EAAE,CACH,CAAA;IACD,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,MAAmC,EAAE,OAAO,CAAC,CAAA;AAC7E,CAAC,CAAA","sourcesContent":["// RC3-WORKAROUND(use-signal-stale-handler): see docs/gtkx-rc3-notes.md\n// @gtkx/react's useSignal documents that \"each emission runs the handler from\n// the latest render\", and rc.1 delivered that by pinning the handler in a ref\n// of its own. rc.3 routes it through React's useEffectEvent instead, and\n// react-reconciler@0.33.0 only refreshes useEffectEvent in\n// commitBeforeMutationEffects for `case 0` (FunctionComponent) — `case 11`\n// (ForwardRef) and `case 15` (SimpleMemoComponent) fall through unrefreshed.\n// Any useEffectEvent inside a memo or forwardRef component is pinned to its\n// mount closure permanently; this has nothing to do with useSignal\n// specifically (confirmed upstream: gtkx-org/gtkx#467) — plain\n// useEffectEvent called from an Effect fails identically. It reproduced for\n// us because our ScrollView is a forwardRef (components/scroll-view.tsx) with\n// the useSignal calls inside it; tree depth was a coincidence, not the\n// trigger. The consequence is not subtle — the mount-time scroll handler\n// windows a VirtualizedList against the data it saw at mount, so a list\n// whose rows arrive from a fetch renders EMPTY as soon as it is scrolled.\n//\n// Restore the documented contract at the bridge: keep the latest handler in a\n// ref of our own and hand gtkx a stable wrapper (stable so the connection is\n// never re-established, which is what its useEffectEvent was for). The ref is\n// refreshed in an INSERTION effect — the earliest commit phase, ahead of every\n// layout effect, so a signal emitted from one (the list's own scroll\n// corrections) already sees the handler from the render being committed.\n// React fixed the refresh on the 19.3 line (moved into\n// commitMutationEffectsOnFiber, covering `case 0/11/14/15` ahead of child\n// traversal), but there is no stable 0.34.x gtkx release yet and the React\n// canaries pin an exact prerelease peer, so this wrapper stays until a\n// stable React 19.3 ships — not \"when useSignal is fixed\" (see gtkx#467).\nimport { useSignal as useGtkxSignal } from \"@gtkx/react\"\nimport { useCallback, useInsertionEffect, useRef } from \"react\"\n\ntype AnyHandler = (...args: unknown[]) => unknown\n\nexport const useSignal: typeof useGtkxSignal = (\n  object,\n  signal,\n  handler,\n  options,\n) => {\n  // The handler type is generic in the signal name; the wrapper only forwards\n  // arguments, so it crosses that boundary as an untyped callable.\n  const latest = useRef<AnyHandler>(() => undefined)\n  useInsertionEffect(() => {\n    latest.current = handler as unknown as AnyHandler\n  })\n  const stable = useCallback<AnyHandler>(\n    (...args) => latest.current(...args),\n    [],\n  )\n  useGtkxSignal(object, signal, stable as unknown as typeof handler, options)\n}\n"]}
+{"version":3,"file":"use-signal.js","sourceRoot":"","sources":["../../../src/gtkx/bridge/use-signal.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,8EAA8E;AAC9E,8EAA8E;AAC9E,yEAAyE;AACzE,2DAA2D;AAC3D,2EAA2E;AAC3E,6EAA6E;AAC7E,4EAA4E;AAC5E,mEAAmE;AACnE,+DAA+D;AAC/D,4EAA4E;AAC5E,8EAA8E;AAC9E,uEAAuE;AACvE,yEAAyE;AACzE,wEAAwE;AACxE,0EAA0E;AAC1E,EAAE;AACF,8EAA8E;AAC9E,6EAA6E;AAC7E,8EAA8E;AAC9E,+EAA+E;AAC/E,qEAAqE;AACrE,yEAAyE;AACzE,uDAAuD;AACvD,0EAA0E;AAC1E,2EAA2E;AAC3E,uEAAuE;AACvE,0EAA0E;AAC1E,OAAO,EAAE,SAAS,IAAI,aAAa,EAAE,MAAM,aAAa,CAAA;AACxD,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,OAAO,CAAA;AAI/D,MAAM,CAAC,MAAM,SAAS,GAAyB,CAC7C,MAAM,EACN,MAAM,EACN,OAAO,EACP,OAAO,EACP,EAAE;IACF,4EAA4E;IAC5E,iEAAiE;IACjE,MAAM,MAAM,GAAG,MAAM,CAAa,GAAG,EAAE,CAAC,SAAS,CAAC,CAAA;IAClD,kBAAkB,CAAC,GAAG,EAAE;QACtB,MAAM,CAAC,OAAO,GAAG,OAAgC,CAAA;IACnD,CAAC,CAAC,CAAA;IACF,MAAM,MAAM,GAAG,WAAW,CACxB,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC,EACpC,EAAE,CACH,CAAA;IACD,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,MAAmC,EAAE,OAAO,CAAC,CAAA;AAC7E,CAAC,CAAA","sourcesContent":["// RC4-WORKAROUND(use-signal-stale-handler): see docs/gtkx-rc4-notes.md\n// @gtkx/react's useSignal documents that \"each emission runs the handler from\n// the latest render\", and rc.1 delivered that by pinning the handler in a ref\n// of its own. rc.3 routes it through React's useEffectEvent instead, and\n// react-reconciler@0.33.0 only refreshes useEffectEvent in\n// commitBeforeMutationEffects for `case 0` (FunctionComponent) — `case 11`\n// (ForwardRef) and `case 15` (SimpleMemoComponent) fall through unrefreshed.\n// Any useEffectEvent inside a memo or forwardRef component is pinned to its\n// mount closure permanently; this has nothing to do with useSignal\n// specifically (confirmed upstream: gtkx-org/gtkx#467) — plain\n// useEffectEvent called from an Effect fails identically. It reproduced for\n// us because our ScrollView is a forwardRef (components/scroll-view.tsx) with\n// the useSignal calls inside it; tree depth was a coincidence, not the\n// trigger. The consequence is not subtle — the mount-time scroll handler\n// windows a VirtualizedList against the data it saw at mount, so a list\n// whose rows arrive from a fetch renders EMPTY as soon as it is scrolled.\n//\n// Restore the documented contract at the bridge: keep the latest handler in a\n// ref of our own and hand gtkx a stable wrapper (stable so the connection is\n// never re-established, which is what its useEffectEvent was for). The ref is\n// refreshed in an INSERTION effect — the earliest commit phase, ahead of every\n// layout effect, so a signal emitted from one (the list's own scroll\n// corrections) already sees the handler from the render being committed.\n// React fixed the refresh on the 19.3 line (moved into\n// commitMutationEffectsOnFiber, covering `case 0/11/14/15` ahead of child\n// traversal), but there is no stable 0.34.x gtkx release yet and the React\n// canaries pin an exact prerelease peer, so this wrapper stays until a\n// stable React 19.3 ships — not \"when useSignal is fixed\" (see gtkx#467).\nimport { useSignal as useGtkxSignal } from \"@gtkx/react\"\nimport { useCallback, useInsertionEffect, useRef } from \"react\"\n\ntype AnyHandler = (...args: unknown[]) => unknown\n\nexport const useSignal: typeof useGtkxSignal = (\n  object,\n  signal,\n  handler,\n  options,\n) => {\n  // The handler type is generic in the signal name; the wrapper only forwards\n  // arguments, so it crosses that boundary as an untyped callable.\n  const latest = useRef<AnyHandler>(() => undefined)\n  useInsertionEffect(() => {\n    latest.current = handler as unknown as AnyHandler\n  })\n  const stable = useCallback<AnyHandler>(\n    (...args) => latest.current(...args),\n    [],\n  )\n  useGtkxSignal(object, signal, stable as unknown as typeof handler, options)\n}\n"]}

package/dist/gtkx/bridge/view-box.d.ts

@@ -1,7 +1,63 @@
 import * as Gtk from "@gtkx/gi/gtk";
 import { createElementComponent } from "@gtkx/react/internal";
+export type HitSlop = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
 /** box-none toggle: picking consults this live, no invalidation needed. */
 export declare const setBoxPassthrough: (widget: Gtk.Widget, enabled: boolean) => void;
+/**
+ * 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 declare const setHitSlop: (widget: Gtk.Widget, slop: HitSlop | null) => void;
+/**
+ * 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 declare const setPointerTarget: (widget: Gtk.Widget, targetable: boolean) => void;
+/**
+ * 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 declare const setBoxOnly: (widget: Gtk.Widget, enabled: boolean) => void;
+/**
+ * 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 declare const cacheChildOrder: (container: Gtk.Widget, children: Gtk.Widget[]) => void;
+/**
+ * Marks a widget as painting-only for picking purposes — see above. Called
+ * once per widget by the components that own one (`Text`, `Image`).
+ */
+export declare const setPaintOnlyLeaf: (widget: Gtk.Widget) => void;
+/**
+ * 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 declare const invalidateZOrder: (container: Gtk.Widget) => void;
+/**
+ * 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 declare const setZIndex: (widget: Gtk.Widget, value: number) => void;
 type ViewBoxComponent = ReturnType<typeof createElementComponent>;
 export declare const getViewBoxComponent: () => ViewBoxComponent;
 export {};