react-native-gtkx 0.1.0-alpha.4 → 0.2.0-alpha.2

package/dist/gtk/window-actions.js

@@ -0,0 +1,193 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Window and application actions declared IN the app tree, not around it.
+//
+// `AppRegistry.runApplication`'s `windowActions`/`windowControllers`/
+// `applicationActions` options build their children as props of the window
+// AppRegistry creates — SIBLINGS of the app's own tree. Nothing inside the
+// app is above them, so no context of the app's reaches them: a `win.new`
+// action could not read a React context store, and `examples/tasks-nav` had
+// to rewrite its store as a module-level external one before Ctrl+N could
+// see any app state at all.
+//
+// These components invert that. They are portals in React's own sense: the
+// children stay where they are written — inside whatever providers,
+// navigators and screens surround them, with their own state and effects —
+// while the registration lands on the window or the application. Three
+// things follow, and all three are the point:
+//
+// - context works, because the declaration IS a descendant of its provider;
+// - registration is dynamic: an action is added when the component that
+//   needs it mounts and removed when it unmounts, so a single screen can
+//   own its own actions instead of the process owning all of them forever;
+// - it composes: two unrelated subtrees can each declare their own without
+//   meeting in one options object.
+import { createContext, useCallback, useContext, useMemo, useRef, useSyncExternalStore, } from "react";
+import { createSlotPortal, GSimpleAction as GtkxSimpleAction, useApplication, useParentWindow, } from "../gtkx/bridge/index";
+const ActionScopeContext = createContext(null);
+// Claims per action map, in mount order. A WeakMap so a closed window's
+// bookkeeping goes away with the window.
+const claimsByScope = new WeakMap();
+const queueFor = (target, name) => {
+    let names = claimsByScope.get(target);
+    if (!names) {
+        names = new Map();
+        claimsByScope.set(target, names);
+    }
+    let queue = names.get(name);
+    if (!queue) {
+        queue = [];
+        names.set(name, queue);
+    }
+    return queue;
+};
+/**
+ * Arbitrates one action name inside one scope, and answers "may I register?".
+ *
+ * FIRST DECLARATION WINS, and a second one is ignored with a development
+ * warning. That is not a coin toss between first and last: `Gio.ActionMap`
+ * is name-keyed on BOTH ends — `addAction` replaces a same-named action
+ * silently, and `removeAction` takes a NAME, not the action object. So with
+ * "last wins" the first unmount of either declaration removes whatever
+ * currently answers to that name, leaving the other one mounted but dead.
+ * First-wins is the only order in which release always happens before
+ * acquire: the loser never registers at all, and when the winner unmounts
+ * (removing its own action, correctly) the next claimant is notified and
+ * registers afterwards, in a later commit.
+ *
+ * The claim queue is an external store, so it is read as one: the claim is
+ * made when React subscribes and dropped when it unsubscribes, which is also
+ * what puts the hand-off after the departing owner's own deregistration
+ * rather than racing it.
+ *
+ * With no scope (a `GSimpleAction` handed to `<GtkApplicationWindow
+ * actions={…}>` directly, the pre-existing path) there is nothing to
+ * arbitrate and the action always renders.
+ */
+const useIsNameOwner = (scope, name) => {
+    const claimRef = useRef(null);
+    const subscribe = useCallback((notify) => {
+        if (scope === null) {
+            return () => undefined;
+        }
+        const queue = queueFor(scope.target, name);
+        const claim = { notify };
+        queue.push(claim);
+        claimRef.current = claim;
+        if (queue.length > 1 && process.env.NODE_ENV !== "production") {
+            console.warn(`[react-native-gtkx] the action "${scope.prefix}.${name}" is declared by ${queue.length} mounted components at once. ` +
+                `The first one to mount stays registered and this one is ignored — GTK removes an action by NAME, so letting the ` +
+                `newest win would let whichever declaration unmounts first take the name down with it. Give them distinct names, ` +
+                `or move the declaration to one place both can reach.`);
+        }
+        return () => {
+            const index = queue.indexOf(claim);
+            claimRef.current = null;
+            if (index === -1) {
+                return;
+            }
+            const wasOwner = index === 0;
+            queue.splice(index, 1);
+            if (wasOwner) {
+                queue[0]?.notify();
+            }
+        };
+    }, [scope, name]);
+    const getSnapshot = useCallback(() => {
+        if (scope === null) {
+            return true;
+        }
+        const claim = claimRef.current;
+        return claim !== null && queueFor(scope.target, name)[0] === claim;
+    }, [scope, name]);
+    return useSyncExternalStore(subscribe, getSnapshot);
+};
+/**
+ * A `Gio.SimpleAction`, declared as an element.
+ *
+ * Identical to gtkx's own element except for one thing: inside
+ * {@link WindowActions} or {@link ApplicationActions} it takes part in name
+ * arbitration, so two subtrees declaring the same action name produce a
+ * warning and a predictable winner instead of a name that the first unmount
+ * silently kills. Outside them it renders exactly as before.
+ */
+export const GSimpleAction = (props) => {
+    const scope = useContext(ActionScopeContext);
+    const name = typeof props.name === "string" ? props.name : "";
+    const isOwner = useIsNameOwner(scope, name);
+    return isOwner ? _jsx(GtkxSimpleAction, { ...props }) : null;
+};
+/**
+ * Registers its children as actions on the WINDOW — the `win.` prefix a
+ * HeaderBar button's `actionName`, a `GMenu` item or an `actionAccels` entry
+ * targets.
+ *
+ * Render it anywhere in the app tree; the children are registered on the
+ * window that encloses them and unregistered when this component unmounts.
+ *
+ * ```tsx
+ * const NewTaskAction = () => {
+ *   const { addTask } = useStore() // an ordinary React context store
+ *   return (
+ *     <WindowActions>
+ *       <GSimpleAction name="new" onActivate={() => addTask()} />
+ *     </WindowActions>
+ *   )
+ * }
+ * ```
+ *
+ * Inside a `Modal` the enclosing window is the MODAL's window, so the
+ * actions belong to it and go away with it — which is usually what a dialog
+ * wants, and worth knowing when it is not.
+ */
+export const WindowActions = ({ children }) => {
+    const window = useParentWindow();
+    const scope = useMemo(() => (window === null ? null : { target: window, prefix: "win" }), [window]);
+    // Null for exactly one commit: the window object reaches context through
+    // state, so the app's first render happens before it is known.
+    if (window === null || scope === null) {
+        return null;
+    }
+    return (_jsx(ActionScopeContext.Provider, { value: scope, children: createSlotPortal(children, window, "actions") }));
+};
+/**
+ * Registers its children as actions on the APPLICATION — the `app.` prefix.
+ *
+ * The same component as {@link WindowActions} against a different action
+ * map, and the two are not interchangeable: a `Gio.Notification`'s action
+ * button can only ever activate an application action, and an application
+ * action outlives any one window. Which prefix an `actionName=` has to say
+ * is decided by which of the two you write, deliberately — a prop that
+ * silently moved every child between prefixes would be a good way to spend
+ * an hour wondering why a button is insensitive.
+ */
+export const ApplicationActions = ({ children }) => {
+    const application = useApplication();
+    const scope = useMemo(() => application === null ? null : { target: application, prefix: "app" }, [application]);
+    if (application === null || scope === null) {
+        return null;
+    }
+    return (_jsx(ActionScopeContext.Provider, { value: scope, children: createSlotPortal(children, application, "actions") }));
+};
+/**
+ * Attaches its children as event controllers on the WINDOW: a
+ * `GtkShortcutController` with `scope={Gtk.ShortcutScope.GLOBAL}` is the
+ * reason this exists — window-wide keyboard shortcuts, declared by the
+ * screen they belong to and gone when it leaves.
+ *
+ * Deliberately a different component from {@link WindowActions} rather than
+ * one that sorts its children: controllers land on the window as a WIDGET
+ * (`addController`/`removeController`, keyed by the controller object)
+ * while actions land on it as a `Gio.ActionMap` (keyed by name). Different
+ * children, different GObject interfaces, and — as the name arbitration
+ * above shows — different duplicate semantics. One component sniffing each
+ * child's type to pick a slot would fail silently on a wrong child; two
+ * components fail at the type level instead.
+ */
+export const WindowControllers = ({ children }) => {
+    const window = useParentWindow();
+    if (window === null) {
+        return null;
+    }
+    return createSlotPortal(children, window, "controllers");
+};
+//# sourceMappingURL=window-actions.js.map

package/dist/gtk/window-actions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"window-actions.js","sourceRoot":"","sources":["../../src/gtk/window-actions.tsx"],"names":[],"mappings":"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","sourcesContent":["// Window and application actions declared IN the app tree, not around it.\n//\n// `AppRegistry.runApplication`'s `windowActions`/`windowControllers`/\n// `applicationActions` options build their children as props of the window\n// AppRegistry creates — SIBLINGS of the app's own tree. Nothing inside the\n// app is above them, so no context of the app's reaches them: a `win.new`\n// action could not read a React context store, and `examples/tasks-nav` had\n// to rewrite its store as a module-level external one before Ctrl+N could\n// see any app state at all.\n//\n// These components invert that. They are portals in React's own sense: the\n// children stay where they are written — inside whatever providers,\n// navigators and screens surround them, with their own state and effects —\n// while the registration lands on the window or the application. Three\n// things follow, and all three are the point:\n//\n// - context works, because the declaration IS a descendant of its provider;\n// - registration is dynamic: an action is added when the component that\n//   needs it mounts and removed when it unmounts, so a single screen can\n//   own its own actions instead of the process owning all of them forever;\n// - it composes: two unrelated subtrees can each declare their own without\n//   meeting in one options object.\nimport {\n  createContext,\n  useCallback,\n  useContext,\n  useMemo,\n  useRef,\n  useSyncExternalStore,\n  type ComponentProps,\n  type ReactNode,\n} from \"react\"\nimport {\n  createSlotPortal,\n  GSimpleAction as GtkxSimpleAction,\n  useApplication,\n  useParentWindow,\n} from \"../gtkx/bridge/index\"\n\n/**\n * The action map an enclosing {@link WindowActions} / {@link ApplicationActions}\n * registers into, plus the GTK prefix its children answer to. Carried through\n * React context, so a `GSimpleAction` nested arbitrarily deep — inside a\n * component of the app's own, not just as a direct child — still finds it.\n */\ntype ActionScope = {\n  /** The `Gio.ActionMap` (a window or the application). Registry key, too. */\n  target: object\n  /** \"win\" or \"app\": what an `actionName` has to say to reach these. */\n  prefix: string\n}\n\nconst ActionScopeContext = createContext<ActionScope | null>(null)\n\n// One live claim on one action name. `notify` is the claimant's own\n// useSyncExternalStore callback, so the registry can tell the next in line\n// that the name has come free.\ntype NameClaim = { notify: () => void }\n\n// Claims per action map, in mount order. A WeakMap so a closed window's\n// bookkeeping goes away with the window.\nconst claimsByScope: WeakMap<object, Map<string, NameClaim[]>> = new WeakMap()\n\nconst queueFor = (target: object, name: string): NameClaim[] => {\n  let names = claimsByScope.get(target)\n  if (!names) {\n    names = new Map()\n    claimsByScope.set(target, names)\n  }\n  let queue = names.get(name)\n  if (!queue) {\n    queue = []\n    names.set(name, queue)\n  }\n  return queue\n}\n\n/**\n * Arbitrates one action name inside one scope, and answers \"may I register?\".\n *\n * FIRST DECLARATION WINS, and a second one is ignored with a development\n * warning. That is not a coin toss between first and last: `Gio.ActionMap`\n * is name-keyed on BOTH ends — `addAction` replaces a same-named action\n * silently, and `removeAction` takes a NAME, not the action object. So with\n * \"last wins\" the first unmount of either declaration removes whatever\n * currently answers to that name, leaving the other one mounted but dead.\n * First-wins is the only order in which release always happens before\n * acquire: the loser never registers at all, and when the winner unmounts\n * (removing its own action, correctly) the next claimant is notified and\n * registers afterwards, in a later commit.\n *\n * The claim queue is an external store, so it is read as one: the claim is\n * made when React subscribes and dropped when it unsubscribes, which is also\n * what puts the hand-off after the departing owner's own deregistration\n * rather than racing it.\n *\n * With no scope (a `GSimpleAction` handed to `<GtkApplicationWindow\n * actions={…}>` directly, the pre-existing path) there is nothing to\n * arbitrate and the action always renders.\n */\nconst useIsNameOwner = (scope: ActionScope | null, name: string): boolean => {\n  const claimRef = useRef<NameClaim | null>(null)\n\n  const subscribe = useCallback(\n    (notify: () => void) => {\n      if (scope === null) {\n        return () => undefined\n      }\n      const queue = queueFor(scope.target, name)\n      const claim: NameClaim = { notify }\n      queue.push(claim)\n      claimRef.current = claim\n\n      if (queue.length > 1 && process.env.NODE_ENV !== \"production\") {\n        console.warn(\n          `[react-native-gtkx] the action \"${scope.prefix}.${name}\" is declared by ${queue.length} mounted components at once. ` +\n            `The first one to mount stays registered and this one is ignored — GTK removes an action by NAME, so letting the ` +\n            `newest win would let whichever declaration unmounts first take the name down with it. Give them distinct names, ` +\n            `or move the declaration to one place both can reach.`,\n        )\n      }\n\n      return () => {\n        const index = queue.indexOf(claim)\n        claimRef.current = null\n        if (index === -1) {\n          return\n        }\n        const wasOwner = index === 0\n        queue.splice(index, 1)\n        if (wasOwner) {\n          queue[0]?.notify()\n        }\n      }\n    },\n    [scope, name],\n  )\n\n  const getSnapshot = useCallback(() => {\n    if (scope === null) {\n      return true\n    }\n    const claim = claimRef.current\n    return claim !== null && queueFor(scope.target, name)[0] === claim\n  }, [scope, name])\n\n  return useSyncExternalStore(subscribe, getSnapshot)\n}\n\nexport type GSimpleActionProps = ComponentProps<typeof GtkxSimpleAction>\n\n/**\n * A `Gio.SimpleAction`, declared as an element.\n *\n * Identical to gtkx's own element except for one thing: inside\n * {@link WindowActions} or {@link ApplicationActions} it takes part in name\n * arbitration, so two subtrees declaring the same action name produce a\n * warning and a predictable winner instead of a name that the first unmount\n * silently kills. Outside them it renders exactly as before.\n */\nexport const GSimpleAction = (props: GSimpleActionProps) => {\n  const scope = useContext(ActionScopeContext)\n  const name = typeof props.name === \"string\" ? props.name : \"\"\n  const isOwner = useIsNameOwner(scope, name)\n  return isOwner ? <GtkxSimpleAction {...props} /> : null\n}\n\nexport type WindowActionsProps = {\n  /** `GSimpleAction` elements, or any components that render them. */\n  children?: ReactNode\n}\n\n/**\n * Registers its children as actions on the WINDOW — the `win.` prefix a\n * HeaderBar button's `actionName`, a `GMenu` item or an `actionAccels` entry\n * targets.\n *\n * Render it anywhere in the app tree; the children are registered on the\n * window that encloses them and unregistered when this component unmounts.\n *\n * ```tsx\n * const NewTaskAction = () => {\n *   const { addTask } = useStore() // an ordinary React context store\n *   return (\n *     <WindowActions>\n *       <GSimpleAction name=\"new\" onActivate={() => addTask()} />\n *     </WindowActions>\n *   )\n * }\n * ```\n *\n * Inside a `Modal` the enclosing window is the MODAL's window, so the\n * actions belong to it and go away with it — which is usually what a dialog\n * wants, and worth knowing when it is not.\n */\nexport const WindowActions = ({ children }: WindowActionsProps) => {\n  const window = useParentWindow()\n  const scope = useMemo(\n    () => (window === null ? null : { target: window, prefix: \"win\" }),\n    [window],\n  )\n  // Null for exactly one commit: the window object reaches context through\n  // state, so the app's first render happens before it is known.\n  if (window === null || scope === null) {\n    return null\n  }\n  return (\n    <ActionScopeContext.Provider value={scope}>\n      {createSlotPortal(children, window, \"actions\")}\n    </ActionScopeContext.Provider>\n  )\n}\n\nexport type ApplicationActionsProps = {\n  /** `GSimpleAction` elements, or any components that render them. */\n  children?: ReactNode\n}\n\n/**\n * Registers its children as actions on the APPLICATION — the `app.` prefix.\n *\n * The same component as {@link WindowActions} against a different action\n * map, and the two are not interchangeable: a `Gio.Notification`'s action\n * button can only ever activate an application action, and an application\n * action outlives any one window. Which prefix an `actionName=` has to say\n * is decided by which of the two you write, deliberately — a prop that\n * silently moved every child between prefixes would be a good way to spend\n * an hour wondering why a button is insensitive.\n */\nexport const ApplicationActions = ({ children }: ApplicationActionsProps) => {\n  const application = useApplication()\n  const scope = useMemo(\n    () =>\n      application === null ? null : { target: application, prefix: \"app\" },\n    [application],\n  )\n  if (application === null || scope === null) {\n    return null\n  }\n  return (\n    <ActionScopeContext.Provider value={scope}>\n      {createSlotPortal(children, application, \"actions\")}\n    </ActionScopeContext.Provider>\n  )\n}\n\nexport type WindowControllersProps = {\n  /** `Gtk.EventController` elements — `GtkShortcutController` above all. */\n  children?: ReactNode\n}\n\n/**\n * Attaches its children as event controllers on the WINDOW: a\n * `GtkShortcutController` with `scope={Gtk.ShortcutScope.GLOBAL}` is the\n * reason this exists — window-wide keyboard shortcuts, declared by the\n * screen they belong to and gone when it leaves.\n *\n * Deliberately a different component from {@link WindowActions} rather than\n * one that sorts its children: controllers land on the window as a WIDGET\n * (`addController`/`removeController`, keyed by the controller object)\n * while actions land on it as a `Gio.ActionMap` (keyed by name). Different\n * children, different GObject interfaces, and — as the name arbitration\n * above shows — different duplicate semantics. One component sniffing each\n * child's type to pick a slot would fail silently on a wrong child; two\n * components fail at the type level instead.\n */\nexport const WindowControllers = ({ children }: WindowControllersProps) => {\n  const window = useParentWindow()\n  if (window === null) {\n    return null\n  }\n  return createSlotPortal(children, window, \"controllers\")\n}\n"]}

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

@@ -0,0 +1,15 @@
+import type * as Gtk from "@gtkx/gi/gtk";
+export type Point = {
+    x: number;
+    y: number;
+};
+/**
+ * Translates a point from `widget`'s coordinates into `target`'s.
+ * Returns null when the two are not in the same widget hierarchy.
+ */
+export declare const computePointIn: (widget: Gtk.Widget, target: Gtk.Widget, x: number, y: number) => Point | null;
+/**
+ * Translates a point from `widget`'s coordinates into its toplevel's — RN's
+ * "page" space. Returns null for a widget that is not in a window yet.
+ */
+export declare const computePointInWindow: (widget: Gtk.Widget, x: number, y: number) => Point | null;

package/dist/gtkx/bridge/geometry.js

@@ -0,0 +1,38 @@
+// Widget geometry in foreign coordinate spaces — what RN's measure()/
+// measureInWindow()/measureLayout() and an event's pageX/pageY need.
+//
+// GTK4 folds a widget's allocated position into its transform relative to
+// its parent, so there is no globally meaningful x/y to read off a widget:
+// the position only exists as an answer to "in whose coordinates?".
+// gtk_widget_compute_point() walks that transform chain, which is also why
+// it comes out right inside a scrolled viewport — GtkViewport allocates its
+// child at -adjustment.value, so the scroll offset IS the child's transform.
+//
+// gtk_widget_translate_coordinates() and gtk_widget_get_allocation() do the
+// same job and are deprecated since GTK 4.12; compute_point/compute_bounds
+// are the replacements. Both can legitimately fail (no common ancestor, an
+// 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.
+const point = (x, y) => Graphene.Point.alloc().init(x, y);
+/**
+ * Translates a point from `widget`'s coordinates into `target`'s.
+ * Returns null when the two are not in the same widget hierarchy.
+ */
+export const computePointIn = (widget, target, x, y) => {
+    const [ok, translated] = widget.computePoint(target, point(x, y));
+    return ok ? { x: translated.x, y: translated.y } : null;
+};
+/**
+ * Translates a point from `widget`'s coordinates into its toplevel's — RN's
+ * "page" space. Returns null for a widget that is not in a window yet.
+ */
+export const computePointInWindow = (widget, x, y) => {
+    const root = widget.getRoot();
+    return root ? computePointIn(widget, root, x, y) : null;
+};
+//# sourceMappingURL=geometry.js.map

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

@@ -0,0 +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"]}

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

@@ -2,17 +2,24 @@ import * as Adw from "@gtkx/gi/adw";
 import * as Gdk from "@gtkx/gi/gdk";
 import * as Gio from "@gtkx/gi/gio";
 import * as GLib from "@gtkx/gi/glib";
+import * as GObject from "@gtkx/gi/gobject";
 import * as Graphene from "@gtkx/gi/graphene";
 import * as Gsk from "@gtkx/gi/gsk";
 import * as Gtk from "@gtkx/gi/gtk";
 import * as Pango from "@gtkx/gi/pango";
-export { Adw, Gdk, Gio, GLib, Graphene, Gsk, Gtk, Pango };
-export { AdwApplicationWindow, AdwHeaderBar, AdwNavigationPage, AdwNavigationSplitView, AdwNavigationView, AdwToolbarView, } from "@gtkx/jsx/adw";
-export { GtkApplication, GtkApplicationWindow, GtkBox, GtkButton, GtkEntry, GtkGestureClick, GtkLabel, GtkListBox, GtkListBoxRow, GtkPicture, GtkScrolledWindow, GtkSpinner, GtkSwitch, GtkTextView, GtkWindow, } from "@gtkx/jsx/gtk";
-export { createPortal, createRoot, quit, useApplication, useParentWindow, useProperty, type Root, } from "@gtkx/react";
+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 * 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 { useSignal } from "./use-signal";
 export { css, cx, injectGlobal } from "@gtkx/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 { 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-rc2-notes.md):
+// Caveats baked into this surface (catalogued in docs/gtkx-rc3-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
@@ -10,20 +10,61 @@ import * as Adw from "@gtkx/gi/adw";
 import * as Gdk from "@gtkx/gi/gdk";
 import * as Gio from "@gtkx/gi/gio";
 import * as GLib from "@gtkx/gi/glib";
+import * as GObject from "@gtkx/gi/gobject";
 import * as Graphene from "@gtkx/gi/graphene";
 import * as Gsk from "@gtkx/gi/gsk";
 import * as Gtk from "@gtkx/gi/gtk";
 import * as Pango from "@gtkx/gi/pango";
-export { Adw, Gdk, Gio, GLib, Graphene, Gsk, Gtk, Pango };
-export { AdwApplicationWindow, AdwHeaderBar, AdwNavigationPage, AdwNavigationSplitView, AdwNavigationView, AdwToolbarView, } from "@gtkx/jsx/adw";
-export { GtkApplication, GtkApplicationWindow, GtkBox, GtkButton, GtkEntry, GtkGestureClick, GtkLabel, GtkListBox, GtkListBoxRow, GtkPicture, GtkScrolledWindow, GtkSpinner, GtkSwitch, GtkTextView, GtkWindow, } from "@gtkx/jsx/gtk";
-export { createPortal, createRoot, quit, useApplication, useParentWindow, useProperty, } from "@gtkx/react";
+export { Adw, Gdk, Gio, GLib, GObject, Graphene, Gsk, Gtk, Pango };
+// GtkApplication and GtkGestureClick are not Gtk.Widget subclasses (an
+// application object and an event controller, respectively), so the widget
+// surface generator never sees them — kept here by hand, same as before it
+// existed.
+export { GtkApplication, GtkGestureClick } from "@gtkx/jsx/gtk";
+// Auxiliary gtkx JSX elements that are not Gtk.Widget/Adw.Widget subclasses
+// either, same reason as the pair above — scripts/generate-widget-surface.ts
+// only classifies widgets, so these fall into its "notAWidget" bucket
+// (see scripts/widget-surface/classification.json) and are otherwise
+// unreachable through react-native-gtkx/gtk or /adw. Every one of these is a
+// real, necessary building block for a real app: actions and menus (Gio),
+// a responsive breakpoint (Adw), a text buffer and an adjustment (the model
+// objects GtkTextView/GtkSpinRow etc. bind to), keyboard shortcuts, and the
+// two drag-and-drop controllers.
+//
+// Adw.Breakpoint specifically: independently verified
+// (`Adw.Breakpoint.prototype instanceof Gtk.Widget === false`, prototype
+// chain bottoms out at plain GObject.Object) — it draws nothing and has no
+// size, it is a declaration (a condition plus a set of property setters)
+// attached to a Window/ApplicationWindow/Dialog/BreakpointBin. Running it
+// through wrapReactNative would give it a Yoga node for a widget that
+// occupies no space: a layout bug, not a convenience. Adw.BreakpointBin (a
+// real widget, the container that scopes breakpoints to a subtree) is
+// wrapped normally in ./widgets.generated instead, and is what
+// createSidebarNavigator's own collapse pairs AdwBreakpoint with (see
+// 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";
+// 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
+// still allowed to be imported directly (see the eslint carve-out for
+// src/gtkx/bridge/**), so they pull the raw widgets from here rather than
+// from @gtkx/jsx themselves.
+export * from "./widgets.generated";
+export { createPortal, createRoot, quit, rootElement, useApplication, useBindSetting, useParentWindow, useProperty, useSetting, } from "@gtkx/react";
 // useSignal comes from ./use-signal, not @gtkx/react — see the workaround note
-// there (rc.2 delivers a stale handler).
+// there (rc.3 delivers a stale handler).
 export { useSignal } from "./use-signal";
 export { css, cx, injectGlobal } from "@gtkx/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 { getSvgNodeComponent, getSvgNodeDescriptor, queueSvgRedraw, resolveSvgColor, resolveSvgPaint, setSvgNodeDescriptor, } from "./svg-node";
 export { allocateChild, attachRnLayout, detachRnLayout, queueAllocate, queueResize, } from "./layout-manager";
 export { colorScheme, styleManager } from "./theme";
 //# sourceMappingURL=index.js.map

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,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,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,CAAA;AAEzD,OAAO,EACL,oBAAoB,EACpB,YAAY,EACZ,iBAAiB,EACjB,sBAAsB,EACtB,iBAAiB,EACjB,cAAc,GACf,MAAM,eAAe,CAAA;AAEtB,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,MAAM,EACN,SAAS,EACT,QAAQ,EACR,eAAe,EACf,QAAQ,EACR,UAAU,EACV,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,UAAU,EACV,SAAS,EACT,WAAW,EACX,SAAS,GACV,MAAM,eAAe,CAAA;AAEtB,OAAO,EACL,YAAY,EACZ,UAAU,EACV,IAAI,EACJ,cAAc,EACd,eAAe,EACf,WAAW,GAEZ,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,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnE,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-rc2-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 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, Graphene, Gsk, Gtk, Pango }\n\nexport {\n  AdwApplicationWindow,\n  AdwHeaderBar,\n  AdwNavigationPage,\n  AdwNavigationSplitView,\n  AdwNavigationView,\n  AdwToolbarView,\n} from \"@gtkx/jsx/adw\"\n\nexport {\n  GtkApplication,\n  GtkApplicationWindow,\n  GtkBox,\n  GtkButton,\n  GtkEntry,\n  GtkGestureClick,\n  GtkLabel,\n  GtkListBox,\n  GtkListBoxRow,\n  GtkPicture,\n  GtkScrolledWindow,\n  GtkSpinner,\n  GtkSwitch,\n  GtkTextView,\n  GtkWindow,\n} from \"@gtkx/jsx/gtk\"\n\nexport {\n  createPortal,\n  createRoot,\n  quit,\n  useApplication,\n  useParentWindow,\n  useProperty,\n  type Root,\n} from \"@gtkx/react\"\n\n// useSignal comes from ./use-signal, not @gtkx/react — see the workaround note\n// there (rc.2 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 { getViewBoxComponent, setBoxPassthrough } from \"./view-box\"\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,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"]}

package/dist/gtkx/bridge/layout-manager.d.ts

@@ -1,4 +1,5 @@
 import * as Gtk from "@gtkx/gi/gtk";
+import type { Transform2D } from "../../contracts";
 export type RnLayoutOrientation = "horizontal" | "vertical";
 export type RnLayoutHooks = {
     measure(orientation: RnLayoutOrientation, forSize: number): number;
@@ -6,6 +7,6 @@ export type RnLayoutHooks = {
 };
 export declare const attachRnLayout: (widget: Gtk.Widget, hooks: RnLayoutHooks) => void;
 export declare const detachRnLayout: (widget: Gtk.Widget) => void;
-export declare const allocateChild: (child: Gtk.Widget, x: number, y: number, width: number, height: number) => void;
+export declare const allocateChild: (child: Gtk.Widget, x: number, y: number, width: number, height: number, matrix?: Transform2D | null) => void;
 export declare const queueAllocate: (widget: Gtk.Widget) => void;
 export declare const queueResize: (widget: Gtk.Widget) => void;

package/dist/gtkx/bridge/layout-manager.js

@@ -7,6 +7,7 @@
 // minimum ratchet, overflow children inflating ancestors, and widget minimums
 // pushing rects.
 import * as Gdk from "@gtkx/gi/gdk";
+import * as Gsk from "@gtkx/gi/gsk";
 import * as Gtk from "@gtkx/gi/gtk";
 import { registerClass } from "@gtkx/runtime";
 // The class must exist before any instance is created, but registration needs
@@ -66,15 +67,36 @@ export const detachRnLayout = (widget) => {
     hooksByManager.delete(manager);
     widget.setLayoutManager(null);
 };
-// Places one child at an exact rect. Only meaningful from inside an allocate()
-// hook — GTK forbids size-allocating outside the layout phase.
-export const allocateChild = (child, x, y, width, height) => {
-    child.sizeAllocate(new Gdk.Rectangle({
-        x: Math.round(x),
-        y: Math.round(y),
-        width: Math.max(0, Math.round(width)),
-        height: Math.max(0, Math.round(height)),
-    }), -1);
+// Places one child at an exact rect, optionally under a visual transform.
+// Only meaningful from inside an allocate() hook — GTK forbids
+// size-allocating outside the layout phase.
+//
+// The transform path is gtk_widget_allocate(), which is what
+// gtk_widget_size_allocate() itself calls with a plain translate — the child
+// keeps the width/height Yoga gave it and only its placement matrix changes,
+// which is exactly RN's "transforms are visual only". GTK4 inverts that
+// matrix in gtk_widget_pick(), so input follows the rotated/scaled shape for
+// free (measured: docs/research/transforms.md).
+export const allocateChild = (child, x, y, width, height, matrix = null) => {
+    const left = Math.round(x);
+    const top = Math.round(y);
+    const w = Math.max(0, Math.round(width));
+    const h = Math.max(0, Math.round(height));
+    if (!matrix) {
+        child.sizeAllocate(new Gdk.Rectangle({ x: left, y: top, width: w, height: h }), -1);
+        return;
+    }
+    // RN's transform origin is the centre of the view, so the matrix GTK gets
+    // is T(left + cx, top + cy) · matrix · T(-cx, -cy) — folded into the six
+    // components here rather than chained through GskTransform, which would
+    // cost five FFI hops instead of one.
+    const cx = w / 2;
+    const cy = h / 2;
+    const transform = Gsk.Transform.new().matrix2d(matrix.xx, matrix.yx, matrix.xy, matrix.yy, left + cx - (matrix.xx * cx + matrix.xy * cy) + matrix.dx, top + cy - (matrix.yx * cx + matrix.yy * cy) + matrix.dy);
+    // gtk_widget_allocate consumes the transform (transfer full) and gtkx
+    // hands ownership over with it — never unref it here (that aborts on
+    // GLib's rc-box magic assertion).
+    child.allocate(w, h, -1, transform);
 };
 // Engine flush → new rects for the same container size: schedule allocation
 // only. A measure-affecting change must use queueResize instead.

package/dist/gtkx/bridge/layout-manager.js.map

@@ -1 +1 @@
-{"version":3,"file":"layout-manager.js","sourceRoot":"","sources":["../../../src/gtkx/bridge/layout-manager.ts"],"names":[],"mappings":"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","sourcesContent":["// RnGtkxLayout — a GObject subclass of GtkLayoutManager registered entirely\n// from JS (docs/research/layout-manager.md, \"B0\"). The manager obeys ONLY the\n// layout engine: measure() reports the engine-provided size (minimum ==\n// natural, children are never queried) and allocate() delegates to the engine,\n// which places every child at exactly its computed rect via allocateChild().\n// This is what removes the GTK-vs-RN layout conflicts at the root: window\n// minimum ratchet, overflow children inflating ancestors, and widget minimums\n// pushing rects.\nimport * as Gdk from \"@gtkx/gi/gdk\"\nimport * as Gtk from \"@gtkx/gi/gtk\"\nimport { registerClass } from \"@gtkx/runtime\"\n\nexport type RnLayoutOrientation = \"horizontal\" | \"vertical\"\n\nexport type RnLayoutHooks = {\n  // Engine-provided size for the given axis; minimum == natural == this value.\n  measure(orientation: RnLayoutOrientation, forSize: number): number\n  // Called during GTK's allocation phase with the container's final size.\n  // The engine must size-allocate every child (allocateChild) synchronously.\n  allocate(width: number, height: number): void\n}\n\n// The class must exist before any instance is created, but registration needs\n// GObject to be initialized — both hold after the bridge is imported, so the\n// class is registered lazily on first attach (also keeps the module safe to\n// import in environments without a display).\nlet RnGtkxLayoutClass: (new () => Gtk.LayoutManager) | null = null\n\nconst hooksByManager = new WeakMap<Gtk.LayoutManager, RnLayoutHooks>()\n\nconst ensureRegistered = (): new () => Gtk.LayoutManager => {\n  if (RnGtkxLayoutClass) {\n    return RnGtkxLayoutClass\n  }\n\n  class RnGtkxLayout extends Gtk.LayoutManager {\n    override measure(\n      _widget: Gtk.Widget,\n      orientation: Gtk.Orientation,\n      forSize: number,\n    ): [number, number, number, number] {\n      const hooks = hooksByManager.get(this)\n      if (!hooks) {\n        return [0, 0, -1, -1]\n      }\n      const size = hooks.measure(\n        orientation === Gtk.Orientation.HORIZONTAL ? \"horizontal\" : \"vertical\",\n        forSize,\n      )\n      return [size, size, -1, -1]\n    }\n\n    // Trailing vfunc params (baseline; widget) are dropped — JS tolerates the\n    // arity mismatch and the linter rejects unused trailing args.\n    override allocate(\n      _widget: Gtk.Widget,\n      width: number,\n      height: number,\n    ): void {\n      hooksByManager.get(this)?.allocate(width, height)\n    }\n\n    override getRequestMode(): Gtk.SizeRequestMode {\n      return Gtk.SizeRequestMode.CONSTANT_SIZE\n    }\n  }\n\n  // Explicit typeName: bundlers minify class names and registerClass derives\n  // the GType name from klass.name by default (FINDINGS §1).\n  registerClass(RnGtkxLayout, { typeName: \"RnGtkxLayout\" })\n  RnGtkxLayoutClass = RnGtkxLayout\n  return RnGtkxLayout\n}\n\n// Replaces the widget's layout manager with an RnGtkxLayout driven by `hooks`.\n// The container must attach its children in a layout-child-free way (GtkBox\n// append / set_parent) — GtkFixed.put demands a GtkFixedLayoutChild from the\n// current manager and is incompatible (FINDINGS §2).\nexport const attachRnLayout = (\n  widget: Gtk.Widget,\n  hooks: RnLayoutHooks,\n): void => {\n  const Klass = ensureRegistered()\n  if (hooksByManager.has(widget.getLayoutManager() as Gtk.LayoutManager)) {\n    throw new Error(\"attachRnLayout: widget already has an RnGtkxLayout\")\n  }\n  const manager = new Klass()\n  hooksByManager.set(manager, hooks)\n  widget.setLayoutManager(manager)\n}\n\n// Drops the hooks and hands layout back to a fresh manager of the widget's\n// own class default. Safe to call on widgets that were never attached.\nexport const detachRnLayout = (widget: Gtk.Widget): void => {\n  const manager = widget.getLayoutManager() as Gtk.LayoutManager | null\n  if (!manager || !hooksByManager.has(manager)) {\n    return\n  }\n  hooksByManager.delete(manager)\n  widget.setLayoutManager(null as unknown as Gtk.LayoutManager)\n}\n\n// Places one child at an exact rect. Only meaningful from inside an allocate()\n// hook — GTK forbids size-allocating outside the layout phase.\nexport const allocateChild = (\n  child: Gtk.Widget,\n  x: number,\n  y: number,\n  width: number,\n  height: number,\n): void => {\n  child.sizeAllocate(\n    new Gdk.Rectangle({\n      x: Math.round(x),\n      y: Math.round(y),\n      width: Math.max(0, Math.round(width)),\n      height: Math.max(0, Math.round(height)),\n    }),\n    -1,\n  )\n}\n\n// Engine flush → new rects for the same container size: schedule allocation\n// only. A measure-affecting change must use queueResize instead.\nexport const queueAllocate = (widget: Gtk.Widget): void => {\n  widget.queueAllocate()\n}\n\nexport const queueResize = (widget: Gtk.Widget): void => {\n  widget.queueResize()\n}\n"]}
+{"version":3,"file":"layout-manager.js","sourceRoot":"","sources":["../../../src/gtkx/bridge/layout-manager.ts"],"names":[],"mappings":"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","sourcesContent":["// RnGtkxLayout — a GObject subclass of GtkLayoutManager registered entirely\n// from JS (docs/research/layout-manager.md, \"B0\"). The manager obeys ONLY the\n// layout engine: measure() reports the engine-provided size (minimum ==\n// natural, children are never queried) and allocate() delegates to the engine,\n// which places every child at exactly its computed rect via allocateChild().\n// This is what removes the GTK-vs-RN layout conflicts at the root: window\n// minimum ratchet, overflow children inflating ancestors, and widget minimums\n// pushing rects.\nimport * as Gdk from \"@gtkx/gi/gdk\"\nimport * as Gsk from \"@gtkx/gi/gsk\"\nimport * as Gtk from \"@gtkx/gi/gtk\"\nimport { registerClass } from \"@gtkx/runtime\"\nimport type { Transform2D } from \"../../contracts\"\n\nexport type RnLayoutOrientation = \"horizontal\" | \"vertical\"\n\nexport type RnLayoutHooks = {\n  // Engine-provided size for the given axis; minimum == natural == this value.\n  measure(orientation: RnLayoutOrientation, forSize: number): number\n  // Called during GTK's allocation phase with the container's final size.\n  // The engine must size-allocate every child (allocateChild) synchronously.\n  allocate(width: number, height: number): void\n}\n\n// The class must exist before any instance is created, but registration needs\n// GObject to be initialized — both hold after the bridge is imported, so the\n// class is registered lazily on first attach (also keeps the module safe to\n// import in environments without a display).\nlet RnGtkxLayoutClass: (new () => Gtk.LayoutManager) | null = null\n\nconst hooksByManager = new WeakMap<Gtk.LayoutManager, RnLayoutHooks>()\n\nconst ensureRegistered = (): new () => Gtk.LayoutManager => {\n  if (RnGtkxLayoutClass) {\n    return RnGtkxLayoutClass\n  }\n\n  class RnGtkxLayout extends Gtk.LayoutManager {\n    override measure(\n      _widget: Gtk.Widget,\n      orientation: Gtk.Orientation,\n      forSize: number,\n    ): [number, number, number, number] {\n      const hooks = hooksByManager.get(this)\n      if (!hooks) {\n        return [0, 0, -1, -1]\n      }\n      const size = hooks.measure(\n        orientation === Gtk.Orientation.HORIZONTAL ? \"horizontal\" : \"vertical\",\n        forSize,\n      )\n      return [size, size, -1, -1]\n    }\n\n    // Trailing vfunc params (baseline; widget) are dropped — JS tolerates the\n    // arity mismatch and the linter rejects unused trailing args.\n    override allocate(\n      _widget: Gtk.Widget,\n      width: number,\n      height: number,\n    ): void {\n      hooksByManager.get(this)?.allocate(width, height)\n    }\n\n    override getRequestMode(): Gtk.SizeRequestMode {\n      return Gtk.SizeRequestMode.CONSTANT_SIZE\n    }\n  }\n\n  // Explicit typeName: bundlers minify class names and registerClass derives\n  // the GType name from klass.name by default (FINDINGS §1).\n  registerClass(RnGtkxLayout, { typeName: \"RnGtkxLayout\" })\n  RnGtkxLayoutClass = RnGtkxLayout\n  return RnGtkxLayout\n}\n\n// Replaces the widget's layout manager with an RnGtkxLayout driven by `hooks`.\n// The container must attach its children in a layout-child-free way (GtkBox\n// append / set_parent) — GtkFixed.put demands a GtkFixedLayoutChild from the\n// current manager and is incompatible (FINDINGS §2).\nexport const attachRnLayout = (\n  widget: Gtk.Widget,\n  hooks: RnLayoutHooks,\n): void => {\n  const Klass = ensureRegistered()\n  if (hooksByManager.has(widget.getLayoutManager() as Gtk.LayoutManager)) {\n    throw new Error(\"attachRnLayout: widget already has an RnGtkxLayout\")\n  }\n  const manager = new Klass()\n  hooksByManager.set(manager, hooks)\n  widget.setLayoutManager(manager)\n}\n\n// Drops the hooks and hands layout back to a fresh manager of the widget's\n// own class default. Safe to call on widgets that were never attached.\nexport const detachRnLayout = (widget: Gtk.Widget): void => {\n  const manager = widget.getLayoutManager() as Gtk.LayoutManager | null\n  if (!manager || !hooksByManager.has(manager)) {\n    return\n  }\n  hooksByManager.delete(manager)\n  widget.setLayoutManager(null as unknown as Gtk.LayoutManager)\n}\n\n// Places one child at an exact rect, optionally under a visual transform.\n// Only meaningful from inside an allocate() hook — GTK forbids\n// size-allocating outside the layout phase.\n//\n// The transform path is gtk_widget_allocate(), which is what\n// gtk_widget_size_allocate() itself calls with a plain translate — the child\n// keeps the width/height Yoga gave it and only its placement matrix changes,\n// which is exactly RN's \"transforms are visual only\". GTK4 inverts that\n// matrix in gtk_widget_pick(), so input follows the rotated/scaled shape for\n// free (measured: docs/research/transforms.md).\nexport const allocateChild = (\n  child: Gtk.Widget,\n  x: number,\n  y: number,\n  width: number,\n  height: number,\n  matrix: Transform2D | null = null,\n): void => {\n  const left = Math.round(x)\n  const top = Math.round(y)\n  const w = Math.max(0, Math.round(width))\n  const h = Math.max(0, Math.round(height))\n\n  if (!matrix) {\n    child.sizeAllocate(\n      new Gdk.Rectangle({ x: left, y: top, width: w, height: h }),\n      -1,\n    )\n    return\n  }\n\n  // RN's transform origin is the centre of the view, so the matrix GTK gets\n  // is T(left + cx, top + cy) · matrix · T(-cx, -cy) — folded into the six\n  // components here rather than chained through GskTransform, which would\n  // cost five FFI hops instead of one.\n  const cx = w / 2\n  const cy = h / 2\n  const transform = Gsk.Transform.new().matrix2d(\n    matrix.xx,\n    matrix.yx,\n    matrix.xy,\n    matrix.yy,\n    left + cx - (matrix.xx * cx + matrix.xy * cy) + matrix.dx,\n    top + cy - (matrix.yx * cx + matrix.yy * cy) + matrix.dy,\n  )\n  // gtk_widget_allocate consumes the transform (transfer full) and gtkx\n  // hands ownership over with it — never unref it here (that aborts on\n  // GLib's rc-box magic assertion).\n  child.allocate(w, h, -1, transform)\n}\n\n// Engine flush → new rects for the same container size: schedule allocation\n// only. A measure-affecting change must use queueResize instead.\nexport const queueAllocate = (widget: Gtk.Widget): void => {\n  widget.queueAllocate()\n}\n\nexport const queueResize = (widget: Gtk.Widget): void => {\n  widget.queueResize()\n}\n"]}

package/dist/gtkx/bridge/slot-portal.d.ts

@@ -0,0 +1,12 @@
+import type * as GObject from "@gtkx/gi/gobject";
+import { type ReactNode } from "react";
+/**
+ * A React portal that renders `children` into `target`'s named `slot`
+ * instead of into the tree position where it is written — the declarative
+ * equivalent of passing `<Target slot={children} />`, for a target the
+ * declaring component does not render.
+ *
+ * The children stay part of the React tree where the portal element sits,
+ * so context, state and effects behave exactly as they would in place.
+ */
+export declare const createSlotPortal: (children: ReactNode, target: GObject.Object, slot: string, key?: string) => ReactNode;

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

@@ -0,0 +1,17 @@
+import { createPortal } from "@gtkx/react";
+import { createElement } from "react";
+// Typed as a component rather than an intrinsic tag: "gtkx:prop" is not in
+// the generated JSX.IntrinsicElements map (it is not a GObject type), so
+// createElement would reject the bare string.
+const PROP_ELEMENT = "gtkx:prop";
+/**
+ * A React portal that renders `children` into `target`'s named `slot`
+ * instead of into the tree position where it is written — the declarative
+ * equivalent of passing `<Target slot={children} />`, for a target the
+ * declaring component does not render.
+ *
+ * The children stay part of the React tree where the portal element sits,
+ * so context, state and effects behave exactly as they would in place.
+ */
+export const createSlotPortal = (children, target, slot, key) => createPortal(createElement(PROP_ELEMENT, { propName: slot }, children), target, key);
+//# sourceMappingURL=slot-portal.js.map

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

@@ -0,0 +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"]}