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

package/dist/apis/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/apis/index.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,8EAA8E;AAC9E,0EAA0E;AAE1E,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AACrC,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAA;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAE3C,MAAM,CAAC,MAAM,QAAQ,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAA;AAChD,MAAM,CAAC,MAAM,UAAU,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAA;AACpD,MAAM,CAAC,MAAM,UAAU,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAA;AACpD,MAAM,CAAC,MAAM,QAAQ,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAA;AAChD,MAAM,CAAC,MAAM,KAAK,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAA;AAC1C,MAAM,CAAC,MAAM,OAAO,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAA;AAC9C,MAAM,CAAC,MAAM,WAAW,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAA;AACtD,MAAM,CAAC,MAAM,WAAW,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAA;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,EACL,kBAAkB,GAEnB,MAAM,uBAAuB,CAAA;AAE9B,MAAM,CAAC,MAAM,mBAAmB,GAAG,yBAAyB,CAAC,UAAU,CAAC,CAAA;AACxE,MAAM,CAAC,MAAM,cAAc,GAAG,oBAAoB,CAAC,UAAU,CAAC,CAAA","sourcesContent":["// Production wiring: singleton API modules bound to the gtkx host, exported\n// under their react-native names. Unit tests use the create* factories with a\n// mock host instead of importing this file (it pulls in the gtkx bridge).\n\nimport { createAlert } from \"./alert\"\nimport { createAppState } from \"./app-state\"\nimport { createAppearance } from \"./appearance\"\nimport { createBackHandler } from \"./back-handler\"\nimport { createDimensions } from \"./dimensions\"\nimport { createUseColorScheme, createUseWindowDimensions } from \"./hooks\"\nimport { gtkxHost } from \"./host.gtkx\"\nimport { createI18nManager } from \"./i18n-manager\"\nimport { createLinking } from \"./linking\"\nimport { createPlatform } from \"./platform\"\n\nexport const Platform = createPlatform(gtkxHost)\nexport const Dimensions = createDimensions(gtkxHost)\nexport const Appearance = createAppearance(gtkxHost)\nexport const AppState = createAppState(gtkxHost)\nexport const Alert = createAlert(gtkxHost)\nexport const Linking = createLinking(gtkxHost)\nexport const I18nManager = createI18nManager(gtkxHost)\nexport const BackHandler = createBackHandler(gtkxHost)\nexport { DevSettings } from \"./dev-settings\"\nexport {\n  InteractionManager,\n  type InteractionPromise,\n} from \"./interaction-manager\"\n\nexport const useWindowDimensions = createUseWindowDimensions(Dimensions)\nexport const useColorScheme = createUseColorScheme(Appearance)\n\nexport type { AlertButton, AlertOptions } from \"./alert\"\nexport type { AppStateEvent, AppStateStatus } from \"./app-state\"\nexport type { AppearancePreferences } from \"./appearance\"\nexport type { DimensionKey, DimensionsPayload } from \"./dimensions\"\nexport type { AlertButtonStyle, ColorSchemeName, ScaledSize } from \"./host\"\nexport type { PlatformSelectSpec } from \"./platform\"\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/apis/index.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,8EAA8E;AAC9E,0EAA0E;AAE1E,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AACrC,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAA;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAE3C,MAAM,CAAC,MAAM,QAAQ,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAA;AAChD,MAAM,CAAC,MAAM,UAAU,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAA;AACpD,MAAM,CAAC,MAAM,UAAU,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAA;AACpD,MAAM,CAAC,MAAM,QAAQ,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAA;AAChD,MAAM,CAAC,MAAM,KAAK,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAA;AAC1C,MAAM,CAAC,MAAM,OAAO,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAA;AAC9C,MAAM,CAAC,MAAM,WAAW,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAA;AACtD,MAAM,CAAC,MAAM,WAAW,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAA;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,EACL,QAAQ,GAGT,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,MAAM,EAA4B,MAAM,WAAW,CAAA;AAC5D,OAAO,EACL,kBAAkB,GAEnB,MAAM,uBAAuB,CAAA;AAE9B,MAAM,CAAC,MAAM,mBAAmB,GAAG,yBAAyB,CAAC,UAAU,CAAC,CAAA;AACxE,MAAM,CAAC,MAAM,cAAc,GAAG,oBAAoB,CAAC,UAAU,CAAC,CAAA","sourcesContent":["// Production wiring: singleton API modules bound to the gtkx host, exported\n// under their react-native names. Unit tests use the create* factories with a\n// mock host instead of importing this file (it pulls in the gtkx bridge).\n\nimport { createAlert } from \"./alert\"\nimport { createAppState } from \"./app-state\"\nimport { createAppearance } from \"./appearance\"\nimport { createBackHandler } from \"./back-handler\"\nimport { createDimensions } from \"./dimensions\"\nimport { createUseColorScheme, createUseWindowDimensions } from \"./hooks\"\nimport { gtkxHost } from \"./host.gtkx\"\nimport { createI18nManager } from \"./i18n-manager\"\nimport { createLinking } from \"./linking\"\nimport { createPlatform } from \"./platform\"\n\nexport const Platform = createPlatform(gtkxHost)\nexport const Dimensions = createDimensions(gtkxHost)\nexport const Appearance = createAppearance(gtkxHost)\nexport const AppState = createAppState(gtkxHost)\nexport const Alert = createAlert(gtkxHost)\nexport const Linking = createLinking(gtkxHost)\nexport const I18nManager = createI18nManager(gtkxHost)\nexport const BackHandler = createBackHandler(gtkxHost)\nexport { DevSettings } from \"./dev-settings\"\nexport {\n  Keyboard,\n  type KeyboardEvent,\n  type KeyboardEventName,\n} from \"./keyboard\"\nexport { LogBox, type LogBoxIgnorePattern } from \"./log-box\"\nexport {\n  InteractionManager,\n  type InteractionPromise,\n} from \"./interaction-manager\"\n\nexport const useWindowDimensions = createUseWindowDimensions(Dimensions)\nexport const useColorScheme = createUseColorScheme(Appearance)\n\nexport type { AlertButton, AlertOptions } from \"./alert\"\nexport type { AppStateEvent, AppStateStatus } from \"./app-state\"\nexport type { AppearancePreferences } from \"./appearance\"\nexport type { DimensionKey, DimensionsPayload } from \"./dimensions\"\nexport type { AlertButtonStyle, ColorSchemeName, ScaledSize } from \"./host\"\nexport type { PlatformOSType, PlatformSelectSpec } from \"./platform\"\n"]}

package/dist/apis/keyboard.d.ts

@@ -0,0 +1,60 @@
+import type { SubscriptionHandle } from "../contracts";
+/** RN's keyboard event names. None of them can fire on this platform. */
+export type KeyboardEventName = "keyboardWillShow" | "keyboardDidShow" | "keyboardWillHide" | "keyboardDidHide" | "keyboardWillChangeFrame" | "keyboardDidChangeFrame";
+export type KeyboardEventEasing = "easeIn" | "easeInEaseOut" | "easeOut";
+export type KeyboardEvent = {
+    duration: number;
+    easing: KeyboardEventEasing;
+    endCoordinates: {
+        width: number;
+        height: number;
+        screenX: number;
+        screenY: number;
+    };
+    startCoordinates?: KeyboardEvent["endCoordinates"];
+    isEventFromThisApp: boolean;
+};
+export declare const Keyboard: {
+    /**
+     * Honoured and never called. The subscription is real — `remove()` pairs
+     * with it and is idempotent — because the code that adds a listener also
+     * removes one on unmount, and a fake subscription object would turn a
+     * cleanup into a crash. What cannot happen is the callback running: see
+     * the note at the top of this file.
+     */
+    addListener(_eventName: KeyboardEventName | string, handler: (event: KeyboardEvent) => void): SubscriptionHandle;
+    /** Drops every subscription for an event name. Nothing was going to fire. */
+    removeAllListeners(eventName?: KeyboardEventName | string): void;
+    /**
+     * A no-op, and deliberately not RN's implementation.
+     *
+     * RN's `dismiss()` blurs the focused text input, and it does that as the
+     * MEANS to an end: retracting the software keyboard is only possible by
+     * taking focus away from what summoned it. On a desktop the end does not
+     * exist and the means is a visible behaviour of its own — a caret
+     * disappearing out of the entry the user was typing in. Libraries call
+     * this on gestures (`@gorhom/bottom-sheet` does, from a pan, behind
+     * `enableBlurKeyboardOnGesture`), so implementing it as a blur would make
+     * dragging a sheet steal focus from a form on a platform where nothing
+     * asked for that.
+     *
+     * An app that wants a widget to lose focus has GTK's own focus model for
+     * it (`focusable`, `onFocus`/`onBlur` — see use-focus.ts).
+     */
+    dismiss(): void;
+    /**
+     * RN's `isVisible()`: always false. There is no software keyboard, so it
+     * is never visible — this is a fact about the platform rather than a
+     * placeholder for state nobody wired up.
+     */
+    isVisible(): boolean;
+    /** The occluded rectangle, which is always empty here. */
+    metrics(): undefined;
+    /**
+     * iOS-only upstream, and a no-op there on every other platform too:
+     * `scheduleLayoutAnimation` replays the keyboard's own show/hide easing
+     * into a LayoutAnimation. There is no keyboard event to take an easing
+     * from.
+     */
+    scheduleLayoutAnimation(event: KeyboardEvent): void;
+};

package/dist/apis/keyboard.js

@@ -0,0 +1,63 @@
+const listeners = new Set();
+export const Keyboard = {
+    /**
+     * Honoured and never called. The subscription is real — `remove()` pairs
+     * with it and is idempotent — because the code that adds a listener also
+     * removes one on unmount, and a fake subscription object would turn a
+     * cleanup into a crash. What cannot happen is the callback running: see
+     * the note at the top of this file.
+     */
+    addListener(_eventName, handler) {
+        const entry = { handler };
+        listeners.add(entry);
+        return {
+            remove: () => {
+                listeners.delete(entry);
+            },
+        };
+    },
+    /** Drops every subscription for an event name. Nothing was going to fire. */
+    removeAllListeners(eventName) {
+        void eventName;
+        listeners.clear();
+    },
+    /**
+     * A no-op, and deliberately not RN's implementation.
+     *
+     * RN's `dismiss()` blurs the focused text input, and it does that as the
+     * MEANS to an end: retracting the software keyboard is only possible by
+     * taking focus away from what summoned it. On a desktop the end does not
+     * exist and the means is a visible behaviour of its own — a caret
+     * disappearing out of the entry the user was typing in. Libraries call
+     * this on gestures (`@gorhom/bottom-sheet` does, from a pan, behind
+     * `enableBlurKeyboardOnGesture`), so implementing it as a blur would make
+     * dragging a sheet steal focus from a form on a platform where nothing
+     * asked for that.
+     *
+     * An app that wants a widget to lose focus has GTK's own focus model for
+     * it (`focusable`, `onFocus`/`onBlur` — see use-focus.ts).
+     */
+    dismiss() { },
+    /**
+     * RN's `isVisible()`: always false. There is no software keyboard, so it
+     * is never visible — this is a fact about the platform rather than a
+     * placeholder for state nobody wired up.
+     */
+    isVisible() {
+        return false;
+    },
+    /** The occluded rectangle, which is always empty here. */
+    metrics() {
+        return undefined;
+    },
+    /**
+     * iOS-only upstream, and a no-op there on every other platform too:
+     * `scheduleLayoutAnimation` replays the keyboard's own show/hide easing
+     * into a LayoutAnimation. There is no keyboard event to take an easing
+     * from.
+     */
+    scheduleLayoutAnimation(event) {
+        void event;
+    },
+};
+//# sourceMappingURL=keyboard.js.map

package/dist/apis/keyboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard.js","sourceRoot":"","sources":["../../src/apis/keyboard.ts"],"names":[],"mappings":"AAqDA,MAAM,SAAS,GAAG,IAAI,GAAG,EAAU,CAAA;AAEnC,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB;;;;;;OAMG;IACH,WAAW,CACT,UAAsC,EACtC,OAAuC;QAEvC,MAAM,KAAK,GAAG,EAAE,OAAO,EAAE,CAAA;QACzB,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;QACpB,OAAO;YACL,MAAM,EAAE,GAAG,EAAE;gBACX,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;YACzB,CAAC;SACF,CAAA;IACH,CAAC;IAED,6EAA6E;IAC7E,kBAAkB,CAAC,SAAsC;QACvD,KAAK,SAAS,CAAA;QACd,SAAS,CAAC,KAAK,EAAE,CAAA;IACnB,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,OAAO,KAAU,CAAC;IAElB;;;;OAIG;IACH,SAAS;QACP,OAAO,KAAK,CAAA;IACd,CAAC;IAED,0DAA0D;IAC1D,OAAO;QACL,OAAO,SAAS,CAAA;IAClB,CAAC;IAED;;;;;OAKG;IACH,uBAAuB,CAAC,KAAoB;QAC1C,KAAK,KAAK,CAAA;IACZ,CAAC;CACF,CAAA","sourcesContent":["// react-native Keyboard — the SOFTWARE keyboard, not the hardware one.\n//\n// Every event it carries describes a panel sliding over the app and taking\n// screen space away from it: `keyboardDidShow` reports the height of the\n// rectangle the app just lost, and `keyboardWillChangeFrame` reports it\n// moving. A desktop has no such panel — the keyboard is a device, it occludes\n// nothing, and there is no rectangle to report. So the events cannot fire,\n// and a subscription that is honoured and never called is the truthful\n// answer rather than a shortcut.\n//\n// This is the same shape as BackHandler two files over (\"desktop has no\n// hardware back key, so no event fires today\"), and it is what the two\n// desktop-ish RN platforms do. react-native-windows ships RN core's own\n// `Keyboard`, whose emitter is constructed over `NativeKeyboardObserver`\n// only on iOS and Android — on Windows nothing ever emits into it, and the\n// module is left in place so that `addListener`/`remove` still pair up.\n// react-native-web is explicit about the same thing: its `Keyboard` is an\n// object of no-ops with a comment saying there is no keyboard to observe.\n//\n// The measured caller: `@gorhom/bottom-sheet` subscribes in its own\n// `useAnimatedKeyboard` and maps the event names through\n// `Platform.select({ios: …, android: …, default: ''})` — so on this platform\n// it subscribes to the empty string, which nothing could ever emit even if\n// something did. Its keyboard state stays `UNDETERMINED`, which is what the\n// sheet's own code paths already treat as \"no keyboard involved\".\n//\n// `dismiss()` is the one method with a decision in it — see below.\nimport type { SubscriptionHandle } from \"../contracts\"\n\n/** RN's keyboard event names. None of them can fire on this platform. */\nexport type KeyboardEventName =\n  | \"keyboardWillShow\"\n  | \"keyboardDidShow\"\n  | \"keyboardWillHide\"\n  | \"keyboardDidHide\"\n  | \"keyboardWillChangeFrame\"\n  | \"keyboardDidChangeFrame\"\n\nexport type KeyboardEventEasing = \"easeIn\" | \"easeInEaseOut\" | \"easeOut\"\n\nexport type KeyboardEvent = {\n  duration: number\n  easing: KeyboardEventEasing\n  endCoordinates: {\n    width: number\n    height: number\n    screenX: number\n    screenY: number\n  }\n  startCoordinates?: KeyboardEvent[\"endCoordinates\"]\n  isEventFromThisApp: boolean\n}\n\nconst listeners = new Set<object>()\n\nexport const Keyboard = {\n  /**\n   * Honoured and never called. The subscription is real — `remove()` pairs\n   * with it and is idempotent — because the code that adds a listener also\n   * removes one on unmount, and a fake subscription object would turn a\n   * cleanup into a crash. What cannot happen is the callback running: see\n   * the note at the top of this file.\n   */\n  addListener(\n    _eventName: KeyboardEventName | string,\n    handler: (event: KeyboardEvent) => void,\n  ): SubscriptionHandle {\n    const entry = { handler }\n    listeners.add(entry)\n    return {\n      remove: () => {\n        listeners.delete(entry)\n      },\n    }\n  },\n\n  /** Drops every subscription for an event name. Nothing was going to fire. */\n  removeAllListeners(eventName?: KeyboardEventName | string): void {\n    void eventName\n    listeners.clear()\n  },\n\n  /**\n   * A no-op, and deliberately not RN's implementation.\n   *\n   * RN's `dismiss()` blurs the focused text input, and it does that as the\n   * MEANS to an end: retracting the software keyboard is only possible by\n   * taking focus away from what summoned it. On a desktop the end does not\n   * exist and the means is a visible behaviour of its own — a caret\n   * disappearing out of the entry the user was typing in. Libraries call\n   * this on gestures (`@gorhom/bottom-sheet` does, from a pan, behind\n   * `enableBlurKeyboardOnGesture`), so implementing it as a blur would make\n   * dragging a sheet steal focus from a form on a platform where nothing\n   * asked for that.\n   *\n   * An app that wants a widget to lose focus has GTK's own focus model for\n   * it (`focusable`, `onFocus`/`onBlur` — see use-focus.ts).\n   */\n  dismiss(): void {},\n\n  /**\n   * RN's `isVisible()`: always false. There is no software keyboard, so it\n   * is never visible — this is a fact about the platform rather than a\n   * placeholder for state nobody wired up.\n   */\n  isVisible(): boolean {\n    return false\n  },\n\n  /** The occluded rectangle, which is always empty here. */\n  metrics(): undefined {\n    return undefined\n  },\n\n  /**\n   * iOS-only upstream, and a no-op there on every other platform too:\n   * `scheduleLayoutAnimation` replays the keyboard's own show/hide easing\n   * into a LayoutAnimation. There is no keyboard event to take an easing\n   * from.\n   */\n  scheduleLayoutAnimation(event: KeyboardEvent): void {\n    void event\n  },\n}\n"]}

package/dist/apis/log-box.d.ts

@@ -0,0 +1,15 @@
+/** RN's ignore pattern: a substring, or a regular expression. */
+export type LogBoxIgnorePattern = string | RegExp;
+export declare const LogBox: {
+    /**
+     * Accepted and ignored — there is no overlay to keep these out of, and
+     * this call never filtered the console on RN either.
+     */
+    ignoreLogs(patterns: readonly LogBoxIgnorePattern[]): void;
+    /** Accepted and ignored, for the same reason as {@link LogBox.ignoreLogs}. */
+    ignoreAllLogs(ignore?: boolean): void;
+    /** Accepted and ignored: there is no LogBox to install. */
+    install(): void;
+    /** Accepted and ignored: there is no LogBox to uninstall. */
+    uninstall(): void;
+};

package/dist/apis/log-box.js

@@ -0,0 +1,46 @@
+// RN's LogBox — the full-screen dev overlay that shows warnings and errors
+// on top of a running app, and the API for telling it which ones to skip.
+//
+// ACCEPTED AND IGNORED, and the reason is not "there was nothing better to
+// do": it is that `ignoreLogs` never affected the console on RN either. RN's
+// LogBox installs a *view*; ignoring a pattern keeps the yellow box from
+// appearing and leaves `console.warn` output exactly where it was. A GTK app
+// has no such overlay — a warning goes to stderr and stays there — so the
+// console output after `LogBox.ignoreLogs([...])` here is already the console
+// output RN would have. There is no behaviour to suppress, and no behaviour
+// silently lost.
+//
+// That distinction is what separates this from the stand-ins in
+// src/unsupported-export.ts. Those refuse because accepting would make
+// something that visibly does work stop working — a `PanGestureHandler` that
+// renders children with no gestures. Here the call is a request to hide
+// something this platform never showed.
+//
+// The measured caller: `react-native-draggable-flatlist` calls
+// `LogBox.ignoreLogs([...])` during the first render of every
+// `NestableDraggableFlatList`, to silence RN's "VirtualizedLists should never
+// be nested inside plain ScrollViews" warning. That warning does not exist on
+// this platform either, which is the same fact from the other side.
+//
+// Not implemented, and the reason to build an overlay if one is ever wanted:
+// RN's LogBox is also a UI. `install()`/`uninstall()` are how RN's own
+// AppContainer turns it on and off, so they are accepted for source parity;
+// there is nothing to turn on yet.
+export const LogBox = {
+    /**
+     * Accepted and ignored — there is no overlay to keep these out of, and
+     * this call never filtered the console on RN either.
+     */
+    ignoreLogs(patterns) {
+        void patterns;
+    },
+    /** Accepted and ignored, for the same reason as {@link LogBox.ignoreLogs}. */
+    ignoreAllLogs(ignore) {
+        void ignore;
+    },
+    /** Accepted and ignored: there is no LogBox to install. */
+    install() { },
+    /** Accepted and ignored: there is no LogBox to uninstall. */
+    uninstall() { },
+};
+//# sourceMappingURL=log-box.js.map

package/dist/apis/log-box.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-box.js","sourceRoot":"","sources":["../../src/apis/log-box.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,0EAA0E;AAC1E,EAAE;AACF,2EAA2E;AAC3E,6EAA6E;AAC7E,yEAAyE;AACzE,6EAA6E;AAC7E,0EAA0E;AAC1E,8EAA8E;AAC9E,4EAA4E;AAC5E,iBAAiB;AACjB,EAAE;AACF,gEAAgE;AAChE,uEAAuE;AACvE,6EAA6E;AAC7E,wEAAwE;AACxE,wCAAwC;AACxC,EAAE;AACF,+DAA+D;AAC/D,8DAA8D;AAC9D,8EAA8E;AAC9E,8EAA8E;AAC9E,oEAAoE;AACpE,EAAE;AACF,6EAA6E;AAC7E,uEAAuE;AACvE,4EAA4E;AAC5E,mCAAmC;AAKnC,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB;;;OAGG;IACH,UAAU,CAAC,QAAwC;QACjD,KAAK,QAAQ,CAAA;IACf,CAAC;IAED,8EAA8E;IAC9E,aAAa,CAAC,MAAgB;QAC5B,KAAK,MAAM,CAAA;IACb,CAAC;IAED,2DAA2D;IAC3D,OAAO,KAAU,CAAC;IAElB,6DAA6D;IAC7D,SAAS,KAAU,CAAC;CACrB,CAAA","sourcesContent":["// RN's LogBox — the full-screen dev overlay that shows warnings and errors\n// on top of a running app, and the API for telling it which ones to skip.\n//\n// ACCEPTED AND IGNORED, and the reason is not \"there was nothing better to\n// do\": it is that `ignoreLogs` never affected the console on RN either. RN's\n// LogBox installs a *view*; ignoring a pattern keeps the yellow box from\n// appearing and leaves `console.warn` output exactly where it was. A GTK app\n// has no such overlay — a warning goes to stderr and stays there — so the\n// console output after `LogBox.ignoreLogs([...])` here is already the console\n// output RN would have. There is no behaviour to suppress, and no behaviour\n// silently lost.\n//\n// That distinction is what separates this from the stand-ins in\n// src/unsupported-export.ts. Those refuse because accepting would make\n// something that visibly does work stop working — a `PanGestureHandler` that\n// renders children with no gestures. Here the call is a request to hide\n// something this platform never showed.\n//\n// The measured caller: `react-native-draggable-flatlist` calls\n// `LogBox.ignoreLogs([...])` during the first render of every\n// `NestableDraggableFlatList`, to silence RN's \"VirtualizedLists should never\n// be nested inside plain ScrollViews\" warning. That warning does not exist on\n// this platform either, which is the same fact from the other side.\n//\n// Not implemented, and the reason to build an overlay if one is ever wanted:\n// RN's LogBox is also a UI. `install()`/`uninstall()` are how RN's own\n// AppContainer turns it on and off, so they are accepted for source parity;\n// there is nothing to turn on yet.\n\n/** RN's ignore pattern: a substring, or a regular expression. */\nexport type LogBoxIgnorePattern = string | RegExp\n\nexport const LogBox = {\n  /**\n   * Accepted and ignored — there is no overlay to keep these out of, and\n   * this call never filtered the console on RN either.\n   */\n  ignoreLogs(patterns: readonly LogBoxIgnorePattern[]): void {\n    void patterns\n  },\n\n  /** Accepted and ignored, for the same reason as {@link LogBox.ignoreLogs}. */\n  ignoreAllLogs(ignore?: boolean): void {\n    void ignore\n  },\n\n  /** Accepted and ignored: there is no LogBox to install. */\n  install(): void {},\n\n  /** Accepted and ignored: there is no LogBox to uninstall. */\n  uninstall(): void {},\n}\n"]}

package/dist/apis/platform.d.ts

@@ -1,11 +1,28 @@
 import type { PlatformHost } from "./host";
+/**
+ * RN's own `PlatformOSType`, plus `"linux"`.
+ *
+ * `OS` below is declared as this union rather than the literal `"linux"`,
+ * and the reason is RN's contract rather than ours: the whole purpose of
+ * `Platform.OS` is source shared across platforms, and every stock RN type
+ * declares it wide enough for `Platform.OS === "android"` to COMPILE on
+ * every target — it is a runtime question, not a type error. Narrowing it
+ * to `"linux"` made an ordinary cross-platform line
+ * (`paddingTop: Platform.OS === "android" ? 8 : 6`) fail to build on
+ * exactly the platform that most needs shared source, which
+ * `react-native-reanimated-dnd`'s example app hit eight times.
+ *
+ * The runtime value is unchanged and `Platform.OS === "linux"` still
+ * narrows, so nothing that reads it loses anything.
+ */
+export type PlatformOSType = "android" | "ios" | "linux" | "macos" | "native" | "web" | "windows";
 export type PlatformSelectSpec<T> = {
     linux?: T;
     native?: T;
     default?: T;
 } & Record<string, T | undefined>;
 export declare const createPlatform: (host: PlatformHost) => {
-    OS: "linux";
+    OS: PlatformOSType;
     isTV: false;
     isTesting: boolean;
     readonly Version: string;

package/dist/apis/platform.js.map

@@ -1 +1 @@
-{"version":3,"file":"platform.js","sourceRoot":"","sources":["../../src/apis/platform.ts"],"names":[],"mappings":"AAUA,MAAM,aAAa,GAAG,GAAY,EAAE,CAClC,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,MAAM,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,KAAK,SAAS,CAAA;AAErE,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,IAAkB,EAAE,EAAE,CAAC,CAAC;IACrD,EAAE,EAAE,OAAgB;IACpB,IAAI,EAAE,KAAc;IACpB,SAAS,EAAE,aAAa,EAAE;IAC1B,kEAAkE;IAClE,qDAAqD;IACrD,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,UAAU,EAAE,CAAA;IAC1B,CAAC;IACD,mEAAmE;IACnE,sEAAsE;IACtE,MAAM,CAAI,IAA2B;QACnC,IAAI,OAAO,IAAI,IAAI,EAAE,CAAC;YACpB,OAAO,IAAI,CAAC,KAAK,CAAA;QACnB,CAAC;QACD,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;YACrB,OAAO,IAAI,CAAC,MAAM,CAAA;QACpB,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,CAAA;IACrB,CAAC;CACF,CAAC,CAAA","sourcesContent":["import type { PlatformHost } from \"./host\"\n\n// Cross-platform code may pass ios/android/... keys too; they are ignored on\n// linux, mirroring react-native's Platform.select fallback contract.\nexport type PlatformSelectSpec<T> = {\n  linux?: T\n  native?: T\n  default?: T\n} & Record<string, T | undefined>\n\nconst detectTesting = (): boolean =>\n  process.env.NODE_ENV === \"test\" || process.env.VITEST !== undefined\n\nexport const createPlatform = (host: PlatformHost) => ({\n  OS: \"linux\" as const,\n  isTV: false as const,\n  isTesting: detectTesting(),\n  // GTK runtime version, e.g. \"4.22.4\". Lazy getter: GTK may not be\n  // initialized yet when the module graph is imported.\n  get Version(): string {\n    return host.gtkVersion()\n  },\n  // Same key-presence semantics as react-native: an explicit `linux:\n  // undefined` wins over `default` (checked with `in`, not truthiness).\n  select<T>(spec: PlatformSelectSpec<T>): T | undefined {\n    if (\"linux\" in spec) {\n      return spec.linux\n    }\n    if (\"native\" in spec) {\n      return spec.native\n    }\n    return spec.default\n  },\n})\n\nexport type PlatformModule = ReturnType<typeof createPlatform>\n"]}
+{"version":3,"file":"platform.js","sourceRoot":"","sources":["../../src/apis/platform.ts"],"names":[],"mappings":"AA6BA,MAAM,aAAa,GAAG,GAAY,EAAE,CAClC,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,MAAM,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,KAAK,SAAS,CAAA;AAErE,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,IAAkB,EAAE,EAAE,CAAC,CAAC;IACrD,EAAE,EAAE,OAAyB;IAC7B,IAAI,EAAE,KAAc;IACpB,SAAS,EAAE,aAAa,EAAE;IAC1B,kEAAkE;IAClE,qDAAqD;IACrD,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,UAAU,EAAE,CAAA;IAC1B,CAAC;IACD,mEAAmE;IACnE,sEAAsE;IACtE,MAAM,CAAI,IAA2B;QACnC,IAAI,OAAO,IAAI,IAAI,EAAE,CAAC;YACpB,OAAO,IAAI,CAAC,KAAK,CAAA;QACnB,CAAC;QACD,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;YACrB,OAAO,IAAI,CAAC,MAAM,CAAA;QACpB,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,CAAA;IACrB,CAAC;CACF,CAAC,CAAA","sourcesContent":["import type { PlatformHost } from \"./host\"\n\n/**\n * RN's own `PlatformOSType`, plus `\"linux\"`.\n *\n * `OS` below is declared as this union rather than the literal `\"linux\"`,\n * and the reason is RN's contract rather than ours: the whole purpose of\n * `Platform.OS` is source shared across platforms, and every stock RN type\n * declares it wide enough for `Platform.OS === \"android\"` to COMPILE on\n * every target — it is a runtime question, not a type error. Narrowing it\n * to `\"linux\"` made an ordinary cross-platform line\n * (`paddingTop: Platform.OS === \"android\" ? 8 : 6`) fail to build on\n * exactly the platform that most needs shared source, which\n * `react-native-reanimated-dnd`'s example app hit eight times.\n *\n * The runtime value is unchanged and `Platform.OS === \"linux\"` still\n * narrows, so nothing that reads it loses anything.\n */\nexport type PlatformOSType =\n  \"android\" | \"ios\" | \"linux\" | \"macos\" | \"native\" | \"web\" | \"windows\"\n\n// Cross-platform code may pass ios/android/... keys too; they are ignored on\n// linux, mirroring react-native's Platform.select fallback contract.\nexport type PlatformSelectSpec<T> = {\n  linux?: T\n  native?: T\n  default?: T\n} & Record<string, T | undefined>\n\nconst detectTesting = (): boolean =>\n  process.env.NODE_ENV === \"test\" || process.env.VITEST !== undefined\n\nexport const createPlatform = (host: PlatformHost) => ({\n  OS: \"linux\" as PlatformOSType,\n  isTV: false as const,\n  isTesting: detectTesting(),\n  // GTK runtime version, e.g. \"4.22.4\". Lazy getter: GTK may not be\n  // initialized yet when the module graph is imported.\n  get Version(): string {\n    return host.gtkVersion()\n  },\n  // Same key-presence semantics as react-native: an explicit `linux:\n  // undefined` wins over `default` (checked with `in`, not truthiness).\n  select<T>(spec: PlatformSelectSpec<T>): T | undefined {\n    if (\"linux\" in spec) {\n      return spec.linux\n    }\n    if (\"native\" in spec) {\n      return spec.native\n    }\n    return spec.default\n  },\n})\n\nexport type PlatformModule = ReturnType<typeof createPlatform>\n"]}

package/dist/common/icon.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from "react";
+import type { StyleProp } from "../contracts";
+export type IconProps = {
+    /** Icon-theme name, e.g. `"starred-symbolic"`. Symbolic icons take their
+     *  colour from the surrounding label colour. */
+    name: string;
+    /** Square size in RN units. Defaults to 16, the size Adwaita uses for icons
+     *  inside list rows and flat buttons. */
+    size?: number;
+    /** React Native style. Sizing here wins over `size`. */
+    style?: StyleProp;
+    testID?: string;
+};
+/**
+ * ```tsx
+ * <Icon name="starred-symbolic" size={16} />
+ * ```
+ *
+ * Sized through `pixel-size` as well as through Yoga: GTK would otherwise pick
+ * the nearest theme size and paint at that, so a 16-unit box could hold a
+ * 24px icon scaled down.
+ */
+export declare const Icon: ({ name, size, style, testID, }: IconProps) => ReactNode;

package/dist/common/icon.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { GtkImage } from "../gtkx/bridge/index";
+import { Widget } from "./widget";
+/**
+ * ```tsx
+ * <Icon name="starred-symbolic" size={16} />
+ * ```
+ *
+ * Sized through `pixel-size` as well as through Yoga: GTK would otherwise pick
+ * the nearest theme size and paint at that, so a 16-unit box could hold a
+ * 24px icon scaled down.
+ */
+export const Icon = ({ name, size = 16, style, testID, }) => (_jsx(Widget, { testID: testID, style: [{ width: size, height: size }, style], children: _jsx(GtkImage, { iconName: name, pixelSize: size }) }));
+//# sourceMappingURL=icon.js.map

package/dist/common/icon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"icon.js","sourceRoot":"","sources":["../../src/common/icon.tsx"],"names":[],"mappings":";AAeA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAcjC;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAAC,EACnB,IAAI,EACJ,IAAI,GAAG,EAAE,EACT,KAAK,EACL,MAAM,GACI,EAAa,EAAE,CAAC,CAC1B,KAAC,MAAM,IACL,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,KAAK,CAAC,YAE7C,KAAC,QAAQ,IACP,QAAQ,EAAE,IAAI,EACd,SAAS,EAAE,IAAI,GACf,GACK,CACV,CAAA","sourcesContent":["// A named icon from the desktop icon theme, in React Native layout.\n//\n// WHY this is not `Image`. RN's `Image` takes a file path or a URI, because on\n// iOS and Android an icon is an asset the app ships. On the Linux desktop an\n// icon is a NAME resolved against the current icon theme at paint time —\n// `user-trash-symbolic` recolours itself with the label colour, follows the\n// user's theme, and has no file the app could point at. There is nothing in\n// RN's `Image` contract that can express that, and pretending a name is a URI\n// would break `onError`, `resizeMode` and the loading states along with it.\n//\n// So this is the same shape RN apps already reach for on every platform —\n// react-native-vector-icons' `<Icon name size color />` — with the desktop\n// icon theme behind it instead of a bundled font.\nimport type { ReactNode } from \"react\"\nimport type { StyleProp } from \"../contracts\"\nimport { GtkImage } from \"../gtkx/bridge/index\"\nimport { Widget } from \"./widget\"\n\nexport type IconProps = {\n  /** Icon-theme name, e.g. `\"starred-symbolic\"`. Symbolic icons take their\n   *  colour from the surrounding label colour. */\n  name: string\n  /** Square size in RN units. Defaults to 16, the size Adwaita uses for icons\n   *  inside list rows and flat buttons. */\n  size?: number\n  /** React Native style. Sizing here wins over `size`. */\n  style?: StyleProp\n  testID?: string\n}\n\n/**\n * ```tsx\n * <Icon name=\"starred-symbolic\" size={16} />\n * ```\n *\n * Sized through `pixel-size` as well as through Yoga: GTK would otherwise pick\n * the nearest theme size and paint at that, so a 16-unit box could hold a\n * 24px icon scaled down.\n */\nexport const Icon = ({\n  name,\n  size = 16,\n  style,\n  testID,\n}: IconProps): ReactNode => (\n  <Widget\n    testID={testID}\n    style={[{ width: size, height: size }, style]}\n  >\n    <GtkImage\n      iconName={name}\n      pixelSize={size}\n    />\n  </Widget>\n)\n"]}

package/dist/common/index.d.ts

@@ -1,3 +1,4 @@
 export { NavigationStack, NavigationStackPage, type NavigationStackPageProps, type NavigationStackProps, } from "./navigation-stack";
 export { HeaderSlotContent, IntrinsicContent, SlotContent, WidgetContent, type IntrinsicContentProps, type SlotContentProps, } from "./content";
 export { useWidgetLayout, Widget, wrapReactNative, type ReactNativeLayoutProps, type UseWidgetLayoutOptions, type WidgetProps, } from "./widget";
+export { Icon, type IconProps } from "./icon";

package/dist/common/index.js

@@ -16,4 +16,29 @@
 export { NavigationStack, NavigationStackPage, } from "./navigation-stack";
 export { HeaderSlotContent, IntrinsicContent, SlotContent, WidgetContent, } from "./content";
 export { useWidgetLayout, Widget, wrapReactNative, } from "./widget";
+export { Icon } from "./icon";
+// REMOVED: `List`, `ListRow`, `ListSeparator`, `rowPosition`.
+//
+// They were Adwaita's boxed list re-implemented in React Native, and the
+// argument for shipping them was that a screen shared with iOS and Android
+// could not import `react-native-gtkx/adw`. That argument does not hold —
+// **this subpath does not resolve on iOS or Android either.** Either import
+// needs a `.linux.tsx` split or a `Platform` check, so `List` bought a
+// consumer nothing over `AdwActionRow`, while costing a hand-maintained copy
+// of libadwaita's metrics that drifts with every release of it. And
+// `AdwActionRow` is better where it works: real keynav, focus and
+// accessibility, with the metrics coming from the system theme instead of
+// numbers baked into our source. They had exactly one consumer.
+//
+// Want a native list → `react-native-gtkx/adw`. Want that LOOK written in
+// React Native → `examples/tasks-nav/src/components/list.tsx`, which is the
+// same file, to copy.
+//
+// What stays public is the part of #47 that mattered: `boxShadow`,
+// `outline*` and `textDecorationLine` in the style layer, which are what
+// made an Adwaita-looking list expressible in `StyleSheet` at all.
+//
+// Reorder went with them, and separately: `onReorder`/`reorderId` was a
+// second, id-keyed entry point into the same module `Draggable` and
+// `Sortable` come from. One way to drag now — `react-native-gtkx/dnd`.
 //# sourceMappingURL=index.js.map

package/dist/common/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/common/index.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,EAAE;AACF,wEAAwE;AACxE,2EAA2E;AAC3E,wEAAwE;AACxE,mCAAmC;AACnC,EAAE;AACF,mEAAmE;AACnE,uEAAuE;AACvE,iEAAiE;AACjE,uEAAuE;AACvE,kEAAkE;AAClE,wEAAwE;AACxE,EAAE;AACF,yCAAyC;AAEzC,OAAO,EACL,eAAe,EACf,mBAAmB,GAGpB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,EACX,aAAa,GAGd,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,eAAe,EACf,MAAM,EACN,eAAe,GAIhB,MAAM,UAAU,CAAA","sourcesContent":["// react-native-gtkx/common — the parts of the platform layer we wrote.\n//\n// The other two subpaths are widget bindings: react-native-gtkx/gtk and\n// react-native-gtkx/adw re-export what gtkx generates, name for name. This\n// one holds what has no upstream counterpart, which is why nothing here\n// carries a `Gtk` or `Adw` prefix.\n//\n// Two jobs live here. Getting React Native content INTO a GTK slot\n// (SlotContent, IntrinsicContent), and getting a GTK widget INTO React\n// Native layout (Widget, wrapReactNative, useWidgetLayout). Plus\n// NavigationStack, which is a declarative component over an imperative\n// widget rather than a binding of one — a different contract from\n// Adw.NavigationView, which is why it has its own name and lives apart.\n//\n// Nothing here imports react-navigation.\n\nexport {\n  NavigationStack,\n  NavigationStackPage,\n  type NavigationStackPageProps,\n  type NavigationStackProps,\n} from \"./navigation-stack\"\n\nexport {\n  HeaderSlotContent,\n  IntrinsicContent,\n  SlotContent,\n  WidgetContent,\n  type IntrinsicContentProps,\n  type SlotContentProps,\n} from \"./content\"\n\nexport {\n  useWidgetLayout,\n  Widget,\n  wrapReactNative,\n  type ReactNativeLayoutProps,\n  type UseWidgetLayoutOptions,\n  type WidgetProps,\n} from \"./widget\"\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/common/index.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,EAAE;AACF,wEAAwE;AACxE,2EAA2E;AAC3E,wEAAwE;AACxE,mCAAmC;AACnC,EAAE;AACF,mEAAmE;AACnE,uEAAuE;AACvE,iEAAiE;AACjE,uEAAuE;AACvE,kEAAkE;AAClE,wEAAwE;AACxE,EAAE;AACF,yCAAyC;AAEzC,OAAO,EACL,eAAe,EACf,mBAAmB,GAGpB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,EACX,aAAa,GAGd,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,eAAe,EACf,MAAM,EACN,eAAe,GAIhB,MAAM,UAAU,CAAA;AAEjB,OAAO,EAAE,IAAI,EAAkB,MAAM,QAAQ,CAAA;AAE7C,8DAA8D;AAC9D,EAAE;AACF,yEAAyE;AACzE,2EAA2E;AAC3E,0EAA0E;AAC1E,4EAA4E;AAC5E,uEAAuE;AACvE,6EAA6E;AAC7E,oEAAoE;AACpE,kEAAkE;AAClE,0EAA0E;AAC1E,gEAAgE;AAChE,EAAE;AACF,0EAA0E;AAC1E,4EAA4E;AAC5E,sBAAsB;AACtB,EAAE;AACF,mEAAmE;AACnE,yEAAyE;AACzE,mEAAmE;AACnE,EAAE;AACF,wEAAwE;AACxE,oEAAoE;AACpE,uEAAuE","sourcesContent":["// react-native-gtkx/common — the parts of the platform layer we wrote.\n//\n// The other two subpaths are widget bindings: react-native-gtkx/gtk and\n// react-native-gtkx/adw re-export what gtkx generates, name for name. This\n// one holds what has no upstream counterpart, which is why nothing here\n// carries a `Gtk` or `Adw` prefix.\n//\n// Two jobs live here. Getting React Native content INTO a GTK slot\n// (SlotContent, IntrinsicContent), and getting a GTK widget INTO React\n// Native layout (Widget, wrapReactNative, useWidgetLayout). Plus\n// NavigationStack, which is a declarative component over an imperative\n// widget rather than a binding of one — a different contract from\n// Adw.NavigationView, which is why it has its own name and lives apart.\n//\n// Nothing here imports react-navigation.\n\nexport {\n  NavigationStack,\n  NavigationStackPage,\n  type NavigationStackPageProps,\n  type NavigationStackProps,\n} from \"./navigation-stack\"\n\nexport {\n  HeaderSlotContent,\n  IntrinsicContent,\n  SlotContent,\n  WidgetContent,\n  type IntrinsicContentProps,\n  type SlotContentProps,\n} from \"./content\"\n\nexport {\n  useWidgetLayout,\n  Widget,\n  wrapReactNative,\n  type ReactNativeLayoutProps,\n  type UseWidgetLayoutOptions,\n  type WidgetProps,\n} from \"./widget\"\n\nexport { Icon, type IconProps } from \"./icon\"\n\n// REMOVED: `List`, `ListRow`, `ListSeparator`, `rowPosition`.\n//\n// They were Adwaita's boxed list re-implemented in React Native, and the\n// argument for shipping them was that a screen shared with iOS and Android\n// could not import `react-native-gtkx/adw`. That argument does not hold —\n// **this subpath does not resolve on iOS or Android either.** Either import\n// needs a `.linux.tsx` split or a `Platform` check, so `List` bought a\n// consumer nothing over `AdwActionRow`, while costing a hand-maintained copy\n// of libadwaita's metrics that drifts with every release of it. And\n// `AdwActionRow` is better where it works: real keynav, focus and\n// accessibility, with the metrics coming from the system theme instead of\n// numbers baked into our source. They had exactly one consumer.\n//\n// Want a native list → `react-native-gtkx/adw`. Want that LOOK written in\n// React Native → `examples/tasks-nav/src/components/list.tsx`, which is the\n// same file, to copy.\n//\n// What stays public is the part of #47 that mattered: `boxShadow`,\n// `outline*` and `textDecorationLine` in the style layer, which are what\n// made an Adwaita-looking list expressible in `StyleSheet` at all.\n//\n// Reorder went with them, and separately: `onReorder`/`reorderId` was a\n// second, id-keyed entry point into the same module `Draggable` and\n// `Sortable` come from. One way to drag now — `react-native-gtkx/dnd`.\n"]}

package/dist/common/widget.d.ts

@@ -59,25 +59,4 @@ export type ReactNativeLayoutProps = {
     style?: StyleProp;
     onLayout?: (event: LayoutEvent) => void;
 };
-/**
- * Give a GTK component React Native layout, keeping every prop it already
- * has.
- *
- * ```tsx
- * const Button = wrapReactNative(GtkButton)
- *
- * <View style={{ flexDirection: "row", gap: 8 }}>
- *   <Button style={{ flex: 1 }} label="Save" onClicked={save} />
- * </View>
- * ```
- *
- * The result is generic in the wrapped component's props, so `label`,
- * `onClicked` and everything else gtkx binds keep their types; `style` and
- * `onLayout` are added on top.
- *
- * **Outside React Native layout it steps aside.** The same widget is often
- * used in a pure GTK slot — a HeaderBar's `start`, a ToolbarView's `topBar` —
- * where there is no Yoga tree to join. The wrapper detects that and renders
- * the bare component, so one exported symbol works in both worlds.
- */
-export declare const wrapReactNative: <P extends object>(Component: ComponentType<P>) => ComponentType<P & ReactNativeLayoutProps>;
+export declare const wrapReactNative: <P extends object>(Component: ComponentType<P>, widgetName?: string) => ComponentType<P & ReactNativeLayoutProps>;

package/dist/common/widget.js

@@ -11,8 +11,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
 //
 // The visual half of the style (background, border, radius) is applied as a
 // GTK CSS class, the same mechanism View uses.
-import { useContext, useRef } from "react";
-import { HostNodeContext } from "../components/host-node";
+import { isValidElement, useContext, useRef, } from "react";
+import { HostNodeContext, SlotContext, } from "../components/host-node";
 import { useLayoutChild, } from "../components/use-layout-child";
 import { GtkBox } from "../gtkx/bridge/index";
 /**
@@ -92,7 +92,73 @@ export const useWidgetLayout = (ref, options = {}) => {
  * where there is no Yoga tree to join. The wrapper detects that and renders
  * the bare component, so one exported symbol works in both worlds.
  */
-export const wrapReactNative = (Component) => {
+// A wrapped widget is a Yoga LEAF, so everything INSIDE it is GTK's
+// territory — its children and its slots alike.
+//
+// A widget SLOT is a property that takes a widget (`titleWidget`, `sheet`,
+// `sidebar`, `startChild`); a widget's content area is an ordinary child.
+// The distinction is gtkx's, it moves between releases — rc.3 took the
+// `content`/`child` props off single-child widgets and made that content a
+// child — and it has never had anything to do with layout. Both keep
+// rendering where they were written, so both keep seeing the enclosing React
+// Native layout root even though GTK has parented them somewhere else
+// entirely. Content then joins a Yoga tree whose viewport is the WINDOW
+// while GTK gives it the widget's own rectangle: laid out against one box,
+// drawn in another, and silently stealing space from a tree it was never
+// meant to be in.
+//
+// So the boundary clears the layout root on the way in. The widgets a slot
+// or a child usually holds want exactly that (it is what `WidgetContent`
+// does by hand), and React Native content entering has to bring its own root
+// — `SlotContent` to fill the area, `IntrinsicContent` to size the area to
+// itself. Which of the two is right cannot be inferred, and measurement says
+// so louder than argument: `AdwBottomSheet` alone FILLS in its content child
+// but HUGS in both `sheet` (a bottom sheet rises to the height of its own
+// contents) and `bottomBar`. One widget, three content areas, two answers,
+// with nothing in the name or the GIR type to tell them apart — the answer
+// lives in the widget's own layout code. The boundary is what makes NOT
+// saying a readable error instead of a silent mislayout — see useHostNode.
+const SlotBoundary = ({ location, children, }) => (
+// Two providers, no widget: a context provider is invisible to the gtkx
+// reconciler, so this is safe even on slots whose value is NOT a widget
+// (`breakpoints`, `menuModel`, `buffer`, `adjustment` — the majority of
+// element-valued props, in fact) — wrapping those in a real box would put
+// a GtkBox where an AdwBreakpoint belongs.
+_jsx(SlotContext.Provider, { value: location, children: _jsx(HostNodeContext.Provider, { value: null, children: children }) }));
+const holdsElement = (value) => isValidElement(value) || (Array.isArray(value) && value.some(holdsElement));
+// Puts every element-valued prop, and the children, behind a boundary.
+// `ref` is never content; anything that holds no element (a string child, a
+// number, an already-constructed GObject) is left exactly as it was, so the
+// common widget pays nothing.
+const withSlotBoundaries = (props, widget) => {
+    let bounded;
+    for (const key in props) {
+        if (key === "ref") {
+            continue;
+        }
+        const value = props[key];
+        if (!holdsElement(value)) {
+            continue;
+        }
+        bounded ??= {};
+        bounded[key] = (
+        // Children are not a named slot: the error says "inside AdwBottomSheet"
+        // rather than naming a property that does not exist.
+        _jsx(SlotBoundary, { location: { widget, slot: key === "children" ? null : key }, children: value }));
+    }
+    // The common case is a widget with no element-valued prop at all: return the
+    // props object untouched rather than allocate a copy per render.
+    return bounded ? { ...props, ...bounded } : props;
+};
+export const wrapReactNative = (Component, 
+// The widget's name, for error messages and React devtools. gtkx builds its
+// components from a factory, so they carry no name of their own — the
+// generated widget surface passes the class name it already knows.
+widgetName) => {
+    const name = widgetName ||
+        Component.displayName ||
+        Component.name ||
+        "Widget";
     const InLayout = (props) => {
         const { style, onLayout, ...rest } = props;
         const boxRef = useRef(null);
@@ -117,6 +183,10 @@ export const wrapReactNative = (Component) => {
                 hexpand: inner.hexpand ?? true, vexpand: inner.vexpand ?? true }) }));
     };
     const Wrapped = (props) => {
+        // Every slot this widget is given becomes GTK territory, in both branches
+        // below: whether the widget itself joined React Native layout has nothing
+        // to do with what its slots hold.
+        const withSlots = withSlotBoundaries(props, name);
         // Read the context directly rather than through useHostNode, which throws
         // by design: here its absence is a supported case, not a mistake. The
         // same widget is often used in a pure GTK slot (a HeaderBar's `start`, a
@@ -125,16 +195,13 @@ export const wrapReactNative = (Component) => {
         if (!host) {
             // style/onLayout are meaningless without a Yoga tree — drop them rather
             // than forward them onto a GObject that has no such properties.
-            const rest = { ...props };
+            const rest = { ...withSlots };
             delete rest.style;
             delete rest.onLayout;
             return _jsx(Component, { ...rest });
         }
-        return _jsx(InLayout, { ...props });
+        return _jsx(InLayout, { ...withSlots });
     };
-    const name = Component.displayName ??
-        Component.name ??
-        "Widget";
     InLayout.displayName = `wrapReactNative(${name}).InLayout`;
     Wrapped.displayName = `wrapReactNative(${name})`;
     return Wrapped;

package/dist/common/widget.js.map

@@ -1 +1 @@
-{"version":3,"file":"widget.js","sourceRoot":"","sources":["../../src/common/widget.tsx"],"names":[],"mappings":"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","sourcesContent":["// Making a raw GTK widget a first-class citizen of React Native layout.\n//\n// The widgets this subpath re-exports are real GTK widgets, and GTK widgets\n// know nothing about Yoga. Dropped into a <View> as-is they would never be\n// measured or positioned, which would make \"we export everything\" a hollow\n// promise. `Widget` closes that gap: it gives the widget a Yoga node, applies\n// the layout half of a React Native style to it, and — this is the part that\n// matters — measures the widget itself, so it lands at the size the GTK theme\n// actually wants instead of collapsing to zero.\n//\n// The visual half of the style (background, border, radius) is applied as a\n// GTK CSS class, the same mechanism View uses.\nimport { useContext, useRef, type ComponentType, type ReactNode } from \"react\"\nimport { HostNodeContext } from \"../components/host-node\"\nimport {\n  useLayoutChild,\n  type LayoutEvent,\n} from \"../components/use-layout-child\"\nimport type { StyleProp } from \"../contracts\"\nimport { GtkBox, type Gtk } from \"../gtkx/bridge/index\"\n\nexport type WidgetProps = {\n  /** React Native style. The layout half drives Yoga, the visual half becomes\n   *  a GTK CSS class. Omit sizing and the widget's own natural size wins. */\n  style?: StyleProp\n  onLayout?: (event: LayoutEvent) => void\n  /** The GTK widget(s) to lay out. Your own `ref` on them is untouched. */\n  children: ReactNode\n  testID?: string\n}\n\n/**\n * Put any GTK widget into React Native layout.\n *\n * ```tsx\n * <View style={{ flexDirection: \"row\", gap: 8, padding: 12 }}>\n *   <Widget style={{ flex: 1 }}>\n *     <GtkEntry placeholderText=\"Search\" />\n *   </Widget>\n *   <Widget>\n *     <GtkButton iconName=\"edit-find-symbolic\" />\n *   </Widget>\n * </View>\n * ```\n *\n * The entry flexes, the button takes its natural size, both sit in the row\n * exactly like React Native children — because to Yoga they now are.\n *\n * For the reverse direction (React Native content inside a GTK slot) see\n * `SlotContent` and `IntrinsicContent`.\n */\nexport const Widget = ({ style, onLayout, children, testID }: WidgetProps) => {\n  // The wrapper box IS the Yoga leaf, and it is measured through GTK, so the\n  // widget inside reports its natural size up to Yoga. Wrapping rather than\n  // cloning keeps the child's own ref and props untouched.\n  const boxRef = useRef<Gtk.Box | null>(null)\n  const { cssClass } = useLayoutChild(boxRef, {\n    style,\n    onLayout,\n    // Without this a widget with no explicit size would measure as zero —\n    // the whole reason a naked GtkButton in a View looks broken.\n    measureFromWidget: true,\n  })\n\n  return (\n    <GtkBox\n      ref={boxRef}\n      name={testID}\n      cssClasses={cssClass ? [cssClass] : undefined}\n    >\n      {children}\n    </GtkBox>\n  )\n}\n\nexport type UseWidgetLayoutOptions = {\n  style?: StyleProp\n  onLayout?: (event: LayoutEvent) => void\n}\n\n/**\n * The same thing as {@link Widget}, without the extra component — attach the\n * ref yourself when you already hold one.\n *\n * ```tsx\n * const ref = useRef<Gtk.Button | null>(null)\n * useWidgetLayout(ref, { style: { width: 40, height: 40 } })\n * return <GtkButton ref={ref} iconName=\"open-menu-symbolic\" />\n * ```\n *\n * Returns the GTK CSS class produced by the visual half of the style, or\n * null — pass it to the widget's `cssClasses` if you want backgrounds and\n * borders from the style to apply.\n */\nexport const useWidgetLayout = (\n  ref: { current: Gtk.Widget | null },\n  options: UseWidgetLayoutOptions = {},\n): string | null => {\n  const { cssClass } = useLayoutChild(ref, {\n    style: options.style,\n    onLayout: options.onLayout,\n    measureFromWidget: true,\n  })\n  return cssClass\n}\n\nexport type ReactNativeLayoutProps = {\n  /** React Native style. The layout half drives Yoga, the visual half becomes\n   *  a GTK CSS class. Omit sizing and the widget's natural size wins. */\n  style?: StyleProp\n  onLayout?: (event: LayoutEvent) => void\n}\n\n/**\n * Give a GTK component React Native layout, keeping every prop it already\n * has.\n *\n * ```tsx\n * const Button = wrapReactNative(GtkButton)\n *\n * <View style={{ flexDirection: \"row\", gap: 8 }}>\n *   <Button style={{ flex: 1 }} label=\"Save\" onClicked={save} />\n * </View>\n * ```\n *\n * The result is generic in the wrapped component's props, so `label`,\n * `onClicked` and everything else gtkx binds keep their types; `style` and\n * `onLayout` are added on top.\n *\n * **Outside React Native layout it steps aside.** The same widget is often\n * used in a pure GTK slot — a HeaderBar's `start`, a ToolbarView's `topBar` —\n * where there is no Yoga tree to join. The wrapper detects that and renders\n * the bare component, so one exported symbol works in both worlds.\n */\nexport const wrapReactNative = <P extends object>(\n  Component: ComponentType<P>,\n): ComponentType<P & ReactNativeLayoutProps> => {\n  const InLayout = (props: P & ReactNativeLayoutProps) => {\n    const { style, onLayout, ...rest } = props\n    const boxRef = useRef<Gtk.Box | null>(null)\n    const { cssClass } = useLayoutChild(boxRef, {\n      style,\n      onLayout,\n      // Without this a widget with no explicit size measures as zero — the\n      // whole reason a naked GtkButton in a View looks broken.\n      measureFromWidget: true,\n    })\n    const inner = rest as P & { cssClasses?: string[] } & {\n      hexpand?: boolean\n      vexpand?: boolean\n    }\n    return (\n      <GtkBox ref={boxRef}>\n        <Component\n          {...inner}\n          // The style's visual half lands on the WIDGET, not on the wrapper,\n          // so backgrounds and borders colour the button itself. This is the\n          // point: on this platform React Native style drives GTK.\n          cssClasses={\n            cssClass\n              ? [...(inner.cssClasses ?? []), cssClass]\n              : inner.cssClasses\n          }\n          // Fill the rect Yoga computed, so `flex: 1` and explicit sizes mean\n          // what they mean everywhere else in React Native. An explicit\n          // hexpand/vexpand from the caller still wins.\n          hexpand={inner.hexpand ?? true}\n          vexpand={inner.vexpand ?? true}\n        />\n      </GtkBox>\n    )\n  }\n\n  const Wrapped = (props: P & ReactNativeLayoutProps) => {\n    // Read the context directly rather than through useHostNode, which throws\n    // by design: here its absence is a supported case, not a mistake. The\n    // same widget is often used in a pure GTK slot (a HeaderBar's `start`, a\n    // ToolbarView's `topBar`) where there is no Yoga tree to join.\n    const host = useContext(HostNodeContext)\n    if (!host) {\n      // style/onLayout are meaningless without a Yoga tree — drop them rather\n      // than forward them onto a GObject that has no such properties.\n      const rest = { ...props } as Partial<ReactNativeLayoutProps>\n      delete rest.style\n      delete rest.onLayout\n      return <Component {...(rest as P)} />\n    }\n    return <InLayout {...props} />\n  }\n\n  const name =\n    (Component as { displayName?: string; name?: string }).displayName ??\n    (Component as { name?: string }).name ??\n    \"Widget\"\n  InLayout.displayName = `wrapReactNative(${name}).InLayout`\n  Wrapped.displayName = `wrapReactNative(${name})`\n  return Wrapped\n}\n"]}
+{"version":3,"file":"widget.js","sourceRoot":"","sources":["../../src/common/widget.tsx"],"names":[],"mappings":"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","sourcesContent":["// Making a raw GTK widget a first-class citizen of React Native layout.\n//\n// The widgets this subpath re-exports are real GTK widgets, and GTK widgets\n// know nothing about Yoga. Dropped into a <View> as-is they would never be\n// measured or positioned, which would make \"we export everything\" a hollow\n// promise. `Widget` closes that gap: it gives the widget a Yoga node, applies\n// the layout half of a React Native style to it, and — this is the part that\n// matters — measures the widget itself, so it lands at the size the GTK theme\n// actually wants instead of collapsing to zero.\n//\n// The visual half of the style (background, border, radius) is applied as a\n// GTK CSS class, the same mechanism View uses.\nimport {\n  isValidElement,\n  useContext,\n  useRef,\n  type ComponentType,\n  type ReactNode,\n} from \"react\"\nimport {\n  HostNodeContext,\n  SlotContext,\n  type SlotLocation,\n} from \"../components/host-node\"\nimport {\n  useLayoutChild,\n  type LayoutEvent,\n} from \"../components/use-layout-child\"\nimport type { StyleProp } from \"../contracts\"\nimport { GtkBox, type Gtk } from \"../gtkx/bridge/index\"\n\nexport type WidgetProps = {\n  /** React Native style. The layout half drives Yoga, the visual half becomes\n   *  a GTK CSS class. Omit sizing and the widget's own natural size wins. */\n  style?: StyleProp\n  onLayout?: (event: LayoutEvent) => void\n  /** The GTK widget(s) to lay out. Your own `ref` on them is untouched. */\n  children: ReactNode\n  testID?: string\n}\n\n/**\n * Put any GTK widget into React Native layout.\n *\n * ```tsx\n * <View style={{ flexDirection: \"row\", gap: 8, padding: 12 }}>\n *   <Widget style={{ flex: 1 }}>\n *     <GtkEntry placeholderText=\"Search\" />\n *   </Widget>\n *   <Widget>\n *     <GtkButton iconName=\"edit-find-symbolic\" />\n *   </Widget>\n * </View>\n * ```\n *\n * The entry flexes, the button takes its natural size, both sit in the row\n * exactly like React Native children — because to Yoga they now are.\n *\n * For the reverse direction (React Native content inside a GTK slot) see\n * `SlotContent` and `IntrinsicContent`.\n */\nexport const Widget = ({ style, onLayout, children, testID }: WidgetProps) => {\n  // The wrapper box IS the Yoga leaf, and it is measured through GTK, so the\n  // widget inside reports its natural size up to Yoga. Wrapping rather than\n  // cloning keeps the child's own ref and props untouched.\n  const boxRef = useRef<Gtk.Box | null>(null)\n  const { cssClass } = useLayoutChild(boxRef, {\n    style,\n    onLayout,\n    // Without this a widget with no explicit size would measure as zero —\n    // the whole reason a naked GtkButton in a View looks broken.\n    measureFromWidget: true,\n  })\n\n  return (\n    <GtkBox\n      ref={boxRef}\n      name={testID}\n      cssClasses={cssClass ? [cssClass] : undefined}\n    >\n      {children}\n    </GtkBox>\n  )\n}\n\nexport type UseWidgetLayoutOptions = {\n  style?: StyleProp\n  onLayout?: (event: LayoutEvent) => void\n}\n\n/**\n * The same thing as {@link Widget}, without the extra component — attach the\n * ref yourself when you already hold one.\n *\n * ```tsx\n * const ref = useRef<Gtk.Button | null>(null)\n * useWidgetLayout(ref, { style: { width: 40, height: 40 } })\n * return <GtkButton ref={ref} iconName=\"open-menu-symbolic\" />\n * ```\n *\n * Returns the GTK CSS class produced by the visual half of the style, or\n * null — pass it to the widget's `cssClasses` if you want backgrounds and\n * borders from the style to apply.\n */\nexport const useWidgetLayout = (\n  ref: { current: Gtk.Widget | null },\n  options: UseWidgetLayoutOptions = {},\n): string | null => {\n  const { cssClass } = useLayoutChild(ref, {\n    style: options.style,\n    onLayout: options.onLayout,\n    measureFromWidget: true,\n  })\n  return cssClass\n}\n\nexport type ReactNativeLayoutProps = {\n  /** React Native style. The layout half drives Yoga, the visual half becomes\n   *  a GTK CSS class. Omit sizing and the widget's natural size wins. */\n  style?: StyleProp\n  onLayout?: (event: LayoutEvent) => void\n}\n\n/**\n * Give a GTK component React Native layout, keeping every prop it already\n * has.\n *\n * ```tsx\n * const Button = wrapReactNative(GtkButton)\n *\n * <View style={{ flexDirection: \"row\", gap: 8 }}>\n *   <Button style={{ flex: 1 }} label=\"Save\" onClicked={save} />\n * </View>\n * ```\n *\n * The result is generic in the wrapped component's props, so `label`,\n * `onClicked` and everything else gtkx binds keep their types; `style` and\n * `onLayout` are added on top.\n *\n * **Outside React Native layout it steps aside.** The same widget is often\n * used in a pure GTK slot — a HeaderBar's `start`, a ToolbarView's `topBar` —\n * where there is no Yoga tree to join. The wrapper detects that and renders\n * the bare component, so one exported symbol works in both worlds.\n */\n// A wrapped widget is a Yoga LEAF, so everything INSIDE it is GTK's\n// territory — its children and its slots alike.\n//\n// A widget SLOT is a property that takes a widget (`titleWidget`, `sheet`,\n// `sidebar`, `startChild`); a widget's content area is an ordinary child.\n// The distinction is gtkx's, it moves between releases — rc.3 took the\n// `content`/`child` props off single-child widgets and made that content a\n// child — and it has never had anything to do with layout. Both keep\n// rendering where they were written, so both keep seeing the enclosing React\n// Native layout root even though GTK has parented them somewhere else\n// entirely. Content then joins a Yoga tree whose viewport is the WINDOW\n// while GTK gives it the widget's own rectangle: laid out against one box,\n// drawn in another, and silently stealing space from a tree it was never\n// meant to be in.\n//\n// So the boundary clears the layout root on the way in. The widgets a slot\n// or a child usually holds want exactly that (it is what `WidgetContent`\n// does by hand), and React Native content entering has to bring its own root\n// — `SlotContent` to fill the area, `IntrinsicContent` to size the area to\n// itself. Which of the two is right cannot be inferred, and measurement says\n// so louder than argument: `AdwBottomSheet` alone FILLS in its content child\n// but HUGS in both `sheet` (a bottom sheet rises to the height of its own\n// contents) and `bottomBar`. One widget, three content areas, two answers,\n// with nothing in the name or the GIR type to tell them apart — the answer\n// lives in the widget's own layout code. The boundary is what makes NOT\n// saying a readable error instead of a silent mislayout — see useHostNode.\nconst SlotBoundary = ({\n  location,\n  children,\n}: {\n  location: SlotLocation\n  children: ReactNode\n}) => (\n  // Two providers, no widget: a context provider is invisible to the gtkx\n  // reconciler, so this is safe even on slots whose value is NOT a widget\n  // (`breakpoints`, `menuModel`, `buffer`, `adjustment` — the majority of\n  // element-valued props, in fact) — wrapping those in a real box would put\n  // a GtkBox where an AdwBreakpoint belongs.\n  <SlotContext.Provider value={location}>\n    <HostNodeContext.Provider value={null}>{children}</HostNodeContext.Provider>\n  </SlotContext.Provider>\n)\n\nconst holdsElement = (value: unknown): boolean =>\n  isValidElement(value) || (Array.isArray(value) && value.some(holdsElement))\n\n// Puts every element-valued prop, and the children, behind a boundary.\n// `ref` is never content; anything that holds no element (a string child, a\n// number, an already-constructed GObject) is left exactly as it was, so the\n// common widget pays nothing.\nconst withSlotBoundaries = <P extends object>(props: P, widget: string): P => {\n  let bounded: Record<string, unknown> | undefined\n  for (const key in props) {\n    if (key === \"ref\") {\n      continue\n    }\n    const value = (props as Record<string, unknown>)[key]\n    if (!holdsElement(value)) {\n      continue\n    }\n    bounded ??= {}\n    bounded[key] = (\n      // Children are not a named slot: the error says \"inside AdwBottomSheet\"\n      // rather than naming a property that does not exist.\n      <SlotBoundary\n        location={{ widget, slot: key === \"children\" ? null : key }}\n      >\n        {value as ReactNode}\n      </SlotBoundary>\n    )\n  }\n  // The common case is a widget with no element-valued prop at all: return the\n  // props object untouched rather than allocate a copy per render.\n  return bounded ? ({ ...props, ...bounded } as P) : props\n}\n\nexport const wrapReactNative = <P extends object>(\n  Component: ComponentType<P>,\n  // The widget's name, for error messages and React devtools. gtkx builds its\n  // components from a factory, so they carry no name of their own — the\n  // generated widget surface passes the class name it already knows.\n  widgetName?: string,\n): ComponentType<P & ReactNativeLayoutProps> => {\n  const name =\n    widgetName ||\n    (Component as { displayName?: string; name?: string }).displayName ||\n    (Component as { name?: string }).name ||\n    \"Widget\"\n\n  const InLayout = (props: P & ReactNativeLayoutProps) => {\n    const { style, onLayout, ...rest } = props\n    const boxRef = useRef<Gtk.Box | null>(null)\n    const { cssClass } = useLayoutChild(boxRef, {\n      style,\n      onLayout,\n      // Without this a widget with no explicit size measures as zero — the\n      // whole reason a naked GtkButton in a View looks broken.\n      measureFromWidget: true,\n    })\n    const inner = rest as P & { cssClasses?: string[] } & {\n      hexpand?: boolean\n      vexpand?: boolean\n    }\n    return (\n      <GtkBox ref={boxRef}>\n        <Component\n          {...inner}\n          // The style's visual half lands on the WIDGET, not on the wrapper,\n          // so backgrounds and borders colour the button itself. This is the\n          // point: on this platform React Native style drives GTK.\n          cssClasses={\n            cssClass\n              ? [...(inner.cssClasses ?? []), cssClass]\n              : inner.cssClasses\n          }\n          // Fill the rect Yoga computed, so `flex: 1` and explicit sizes mean\n          // what they mean everywhere else in React Native. An explicit\n          // hexpand/vexpand from the caller still wins.\n          hexpand={inner.hexpand ?? true}\n          vexpand={inner.vexpand ?? true}\n        />\n      </GtkBox>\n    )\n  }\n\n  const Wrapped = (props: P & ReactNativeLayoutProps) => {\n    // Every slot this widget is given becomes GTK territory, in both branches\n    // below: whether the widget itself joined React Native layout has nothing\n    // to do with what its slots hold.\n    const withSlots = withSlotBoundaries(props, name)\n    // Read the context directly rather than through useHostNode, which throws\n    // by design: here its absence is a supported case, not a mistake. The\n    // same widget is often used in a pure GTK slot (a HeaderBar's `start`, a\n    // ToolbarView's `topBar`) where there is no Yoga tree to join.\n    const host = useContext(HostNodeContext)\n    if (!host) {\n      // style/onLayout are meaningless without a Yoga tree — drop them rather\n      // than forward them onto a GObject that has no such properties.\n      const rest = { ...withSlots } as Partial<ReactNativeLayoutProps>\n      delete rest.style\n      delete rest.onLayout\n      return <Component {...(rest as P)} />\n    }\n    return <InLayout {...withSlots} />\n  }\n\n  InLayout.displayName = `wrapReactNative(${name}).InLayout`\n  Wrapped.displayName = `wrapReactNative(${name})`\n  return Wrapped\n}\n"]}