@gjsify/adwaita-react-native 0.44.0

package/README.md

@@ -0,0 +1,136 @@
+# @gjsify/adwaita-react-native
+
+Adwaita widgets with **one API surface and two implementations**: the real `Adw.*`
+widget on GTK4, React Native primitives on a phone.
+
+```tsx
+import { AdwClamp } from '@gjsify/adwaita-react-native';
+
+<AdwClamp maximumSize={400}>{content}</AdwClamp>;
+```
+
+On GTK that is `Adw.Clamp` through [`@gjsify/gtk-host`](../gtk-host). On Android and
+iOS it is a `View` whose width and offset come from
+[`@gjsify/adwaita-core`](../../web/adwaita-core)'s port of
+`adw_clamp_layout_allocate` — libadwaita's own easing curve, not a `maxWidth`
+approximation.
+
+## What this is, honestly
+
+**A walking skeleton, not a widget set.** Two widgets — `AdwBin` and `AdwClamp` —
+carrying the whole vertical: both platform halves, the resolution mechanism, the
+manifest declaration, a gate, suites on both sides, and a photograph of the GTK half.
+The remaining widgets are repetition against a boundary that has been measured.
+
+**The promise is the Adwaita design language on React Native, not "your app runs".**
+Unlike [`@gjsify/react-native`](../react-native) — the opposite direction, which was
+measured against a real production Expo application — this package has no third-party
+codebase behind it. What it has is a shared arithmetic core and two renderers held to
+the same numbers.
+
+## Install
+
+Not on npm yet: this is a new name, and the first publish plus its Trusted Publisher
+bootstrap is a maintainer action deliberately not attempted from CI or a feature branch
+([the procedure](../../../docs/publishing.md)). Until then it is consumable from a
+workspace checkout.
+
+```sh
+npm install @gjsify/adwaita-react-native
+```
+
+`react` (>= 19.2) is a peer dependency. `react-native` (>= 0.87) is an **optional** peer:
+a GTK-only consumer does not need it installed.
+
+## Widgets
+
+| widget | props | notes |
+|---|---|---|
+| `AdwBin` | `children` | One child, no layout of its own |
+| `AdwClamp` | `children`, `maximumSize` (600), `tighteningThreshold` (400) | Constrain a child's width and centre it, on libadwaita's easing curve |
+
+Props are libadwaita's own names, camelCased — `maximumSize` is `AdwClamp:maximum-size`,
+not a React Native `maxWidth` — so the property you look up in libadwaita's documentation
+is the property you write. Defaults are libadwaita's.
+
+## How the two halves are selected
+
+Through the package's `exports` map and the `react-native` condition:
+
+| condition | entry |
+|---|---|
+| `react-native` | `lib/esm/index.native.js` |
+| `default` | `lib/esm/index.gtk.js` |
+| `exports` ignored, `module` read | `lib/esm/index.js` — refuses, by name |
+
+**A stock React Native 0.87 application needs no configuration.** `metro-config` enables
+package exports and `@react-native/metro-config` supplies the `react-native` condition.
+
+Two things follow that are easy to undo by accident, so both are held by
+`scripts/check-adwaita-rn-platform-split.mjs` rather than by convention — its header
+carries the resolver measurements behind them:
+
+- **The condition ORDER is part of the map.** `exports` answers with the first match and
+  `default` matches everything, so moving `default` ahead of `react-native` hands the GTK
+  build to every phone.
+- **Every barrel names its platform files literally.** Nothing relies on a resolver
+  picking a `.native` sibling: that mechanism is real, and right for an *application*,
+  but it does not carry a published library whose shipped imports carry a `.js` extension.
+
+### Consuming it on GTK
+
+Nothing to configure on the phone. On GTK, point JSX at the host that has a GTK element
+list, so a stray `<div>` is a type error instead of a tag that type-checks and renders
+nothing:
+
+```json
+{
+    "compilerOptions": {
+        "jsx": "react-jsx",
+        "jsxImportSource": "@gjsify/gtk-host/react"
+    }
+}
+```
+
+## What is proven, and what is not
+
+| claim | held by |
+|---|---|
+| both halves satisfy one declared surface | `tsc` — a platform module that renames, drops or invents a prop, or changes an arity, is a compile error |
+| the `.native` half type-checks against **real** React Native | the `react-native` package's own types, never a subset |
+| GTK: the widget is the real `Adw.*`, and it **renders** | the live GTK tree plus a GSK rasterisation, because GTK's failure mode is an empty window at exit 0 |
+| React Native: which primitives, which props, which nesting | React's own reconciler over `react-test-renderer` |
+| both halves agree on the number | two frames, one of them ON the easing curve: 1000 points at `maximumSize` 400 gives width 400 at offset 300, and 700 points at the default 600/400 gives **575 at offset 62**, where a `min()` would give 600 |
+| both halves answer the same for a property value GObject cannot store | `normalizeClampSize` from `@gjsify/adwaita-core`, run by **both** halves — the same call `@gjsify/adwaita-web` and `@gjsify/adwaita-nativescript` make. `400.7` &rarr; 400, `NaN` &rarr; the default 600, `-5` &rarr; the range floor 0, asserted on both sides |
+
+**Not proven: Yoga, and the device.** A `width` in a style object is an instruction to a
+layout engine that no test here runs. The React Native half is type-checked and
+tree-checked and has never been on a phone. That gap closes with an app on a real device,
+and until then it is a gap, not a formality.
+
+## Named divergences
+
+These are places where the two halves cannot be made identical, written down rather
+than smoothed over.
+
+- **`AdwClamp` ignores the child's intrinsic minimum on React Native.** libadwaita's
+  clamp is a two-pass measure-then-allocate, and a child minimum wider than the clamp
+  RAISES all three thresholds — which is how such a child still gets its minimum
+  instead of being cut off. React Native has no such pass: `onLayout` reports a size
+  after layout and never the child's intrinsic minimum. So `childMin`/`childNat` are
+  passed as 0, and a child wider than the clamp is compressed here and is not on GTK.
+- **`AdwClamp`'s `small`/`medium`/`large` size class is not carried.** libadwaita stamps
+  it on the child as a style class; React Native has no class system to stamp it into,
+  and inventing a styling seam is a decision this slice does not make.
+- **One unclamped frame.** Before the first `onLayout` there is no available width, so
+  the child renders full-width for one frame.
+- **A second child is kept on React Native and dropped on GTK, silently.** `Adw.Bin` and
+  `Adw.Clamp` are one-child widgets, and gtk-host's `single` child policy fills that slot
+  with `set_child`, so a second child EVICTS the first — with no throw, no host error and
+  no GLib message. A `View` has no such limit and renders both. Both behaviours are pinned
+  by a test on each side, so neither can move alone. Refusing more than one child on both
+  halves would close it and is a surface decision this slice does not make.
+- **`Adw.ClampScrollable` has no counterpart and will not get one.** It binds its four
+  scroll properties onto its child, which is a GTK adoption concern; on React Native
+  scrolling belongs to the `ScrollView`, not to the clamp. This is an asymmetry, not a
+  missing widget.

package/lib/esm/_virtual/_rolldown/runtime.js

@@ -0,0 +1 @@
+var e=Object.defineProperty,__name=(t,n)=>e(t,`name`,{value:n,configurable:!0});export{__name};

package/lib/esm/index.gtk.js

@@ -0,0 +1 @@
+import{AdwBin as e}from"./widgets/bin.gtk.js";import{AdwClamp as t}from"./widgets/clamp.gtk.js";export{e as AdwBin,t as AdwClamp};

package/lib/esm/index.js

@@ -0,0 +1 @@
+import{AdwBin as e}from"./widgets/bin.js";import{AdwClamp as t}from"./widgets/clamp.js";export{e as AdwBin,t as AdwClamp};

package/lib/esm/index.native.js

@@ -0,0 +1 @@
+import{AdwBin as e}from"./widgets/bin.native.js";import{AdwClamp as t}from"./widgets/clamp.native.js";export{e as AdwBin,t as AdwClamp};

package/lib/esm/refuse.js

@@ -0,0 +1 @@
+import"./_virtual/_rolldown/runtime.js";const e=`@gjsify/adwaita-react-native`;function refuseBaseModule(t){throw Error(`${e}: <${t}> was loaded from the BASE module, which has no implementation. The two real ones are selected by the package's \`exports\` map — the \`react-native\` condition picks the React Native build, anything else picks the GTK build. Reaching this module means the tool that resolved ${e} ignored export conditions. For Metro, that is \`unstable_enablePackageExports\` (on by default since metro-config 0.83) plus \`unstable_conditionNames: ['react-native']\` (set by @react-native/metro-config); for anything else, import the platform module directly.`)}export{refuseBaseModule};

package/lib/esm/testing/react-native.js

@@ -0,0 +1 @@
+import"../_virtual/_rolldown/runtime.js";import{createElement as e}from"react";const t=`RCTView`,View=n=>e(t,n);export{t as RCT_VIEW,View};

package/lib/esm/widgets/bin.gtk.js

@@ -0,0 +1 @@
+import"../_virtual/_rolldown/runtime.js";import{jsx as e}from"@gjsify/gtk-host/react/jsx-runtime";function AdwBin({children:t}){return e(`adw-bin`,{children:t})}export{AdwBin};

package/lib/esm/widgets/bin.js

@@ -0,0 +1 @@
+import"../_virtual/_rolldown/runtime.js";import{refuseBaseModule as e}from"../refuse.js";function AdwBin(t){return e(`AdwBin`)}export{AdwBin};

package/lib/esm/widgets/bin.native.js

@@ -0,0 +1 @@
+import"../_virtual/_rolldown/runtime.js";import{View as e}from"react-native";import{jsx as t}from"react/jsx-runtime";function AdwBin({children:n}){return t(e,{children:n})}export{AdwBin};

package/lib/esm/widgets/clamp.gtk.js

@@ -0,0 +1 @@
+import"../_virtual/_rolldown/runtime.js";import{jsx as e}from"@gjsify/gtk-host/react/jsx-runtime";import{ADW_CLAMP_DEFAULTS as t,normalizeClampSize as n}from"@gjsify/adwaita-core";const authoredSize=(e,t)=>e===void 0?void 0:n(e,t);function AdwClamp({children:n,maximumSize:r,tighteningThreshold:i}){return e(`adw-clamp`,{"maximum-size":authoredSize(r,t.maximumSize),"tightening-threshold":authoredSize(i,t.tighteningThreshold),children:n})}export{AdwClamp};

package/lib/esm/widgets/clamp.js

@@ -0,0 +1 @@
+import"../_virtual/_rolldown/runtime.js";import{refuseBaseModule as e}from"../refuse.js";function AdwClamp(t){return e(`AdwClamp`)}export{AdwClamp};

package/lib/esm/widgets/clamp.native.js

@@ -0,0 +1 @@
+import"../_virtual/_rolldown/runtime.js";import{ADW_CLAMP_DEFAULTS as e,clampAllocate as t,normalizeClampSize as n}from"@gjsify/adwaita-core";import{View as r}from"react-native";import{jsx as i}from"react/jsx-runtime";import{useCallback as a,useState as o}from"react";function AdwClamp({children:s,maximumSize:c,tighteningThreshold:l}){let[u,d]=o(null),f=a(e=>{d(e.nativeEvent.layout.width)},[]),p=u===null?null:t(u,{maximumSize:n(c,e.maximumSize),tighteningThreshold:n(l,e.tighteningThreshold),childMin:0,childNat:0});return i(r,{onLayout:f,style:{alignSelf:`stretch`},children:i(r,{style:p===null?void 0:{width:p.childSize,marginStart:p.offset},children:s})})}export{AdwClamp};

package/lib/types/index.d.ts

@@ -0,0 +1,3 @@
+export type { AdwBinProps, AdwClampProps, AdwWidgetProps } from './props.js';
+export { AdwBin } from './widgets/bin.js';
+export { AdwClamp } from './widgets/clamp.js';

package/lib/types/index.gtk.d.ts

@@ -0,0 +1,3 @@
+export type { AdwBinProps, AdwClampProps, AdwWidgetProps } from './props.js';
+export { AdwBin } from './widgets/bin.gtk.js';
+export { AdwClamp } from './widgets/clamp.gtk.js';

package/lib/types/index.native.d.ts

@@ -0,0 +1,3 @@
+export type { AdwBinProps, AdwClampProps, AdwWidgetProps } from './props.js';
+export { AdwBin } from './widgets/bin.native.js';
+export { AdwClamp } from './widgets/clamp.native.js';

package/lib/types/parity.spec.d.ts

@@ -0,0 +1,71 @@
+import type * as BinBase from './widgets/bin.js';
+import type * as BinGtk from './widgets/bin.gtk.js';
+import type * as BinNative from './widgets/bin.native.js';
+import type * as ClampBase from './widgets/clamp.js';
+import type * as ClampGtk from './widgets/clamp.gtk.js';
+import type * as ClampNative from './widgets/clamp.native.js';
+/**
+ * `Assert<false>` is a constraint violation, and that is the whole trick.
+ *
+ * THE FIRST VERSION OF THIS FILE WAS INERT, and it failed in the way this repository
+ * pays for most often: a conditional type resolved to `never` exactly as designed, and
+ * the witness that was supposed to reject `never` used an `as` cast, which TypeScript
+ * permits from `{}`. Measured — making `AdwBin`'s React Native props require a field
+ * the base does not declare left the whole package at exit 0. So the assertion is a
+ * CONSTRAINT now: `Assert<T extends true>` cannot be satisfied by `false`, there is no
+ * cast in the expression, and the diagnostic names the alias, which names the widget
+ * and the platform.
+ *
+ * Exported: `testing/react-native.spec.ts` holds the double against React Native's own
+ * surface with the same trick, and a second copy of a one-line type is a second copy.
+ */
+export type Assert<T extends true> = T;
+/**
+ * Are `A` and `B` the same type, without a union distributing on the way in?
+ *
+ * The tuple wrappers are load-bearing: a bare `A extends B` distributes over a union,
+ * and the two things this file compares — key sets — are unions.
+ */
+export type Identical<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;
+/**
+ * Do `A` and `B` accept exactly the same property NAMES?
+ *
+ * The half of a props contract that structural assignability cannot express when every
+ * property is optional. Used here per widget, and by `testing/react-native.spec.ts`
+ * against React Native's own `View`.
+ */
+export type SameKeys<A, B> = Identical<keyof A, keyof B>;
+/** The props a component accepts, or `never` for anything that is not one. */
+type PropsOf<Component> = Component extends (props: infer P) => unknown ? P : never;
+/**
+ * Does `Platform` provide everything `Base` declares — the whole module surface by
+ * assignability, AND `Name`'s prop names exactly?
+ *
+ * The component is named rather than derived because a mapped type over `keyof Base`
+ * stays deferred when `Base` is a type parameter, and two deferred mapped types compare
+ * EQUAL: written that way the key-set half was inert, and the rename it was added for
+ * went on passing. A named component is also the better diagnostic, and `Name` is
+ * constrained to both modules, so a wrong one is an error here rather than a silent
+ * `never`.
+ *
+ * The assignability half stays: it is what catches a REQUIRED prop the base does not
+ * declare, a changed arity and a widened return, none of which a key set can see. A
+ * platform-only export beyond `Name` is deliberately fine — the surface promise is about
+ * the widgets, not about a helper one half happens to need.
+ */
+type SatisfiesBase<Platform, Base, Name extends keyof Base & keyof Platform> = Platform extends Base ? SameKeys<PropsOf<Platform[Name]>, PropsOf<Base[Name]>> : false;
+export type BinGtkSatisfiesBase = Assert<SatisfiesBase<typeof BinGtk, typeof BinBase, 'AdwBin'>>;
+export type BinNativeSatisfiesBase = Assert<SatisfiesBase<typeof BinNative, typeof BinBase, 'AdwBin'>>;
+export type ClampGtkSatisfiesBase = Assert<SatisfiesBase<typeof ClampGtk, typeof ClampBase, 'AdwClamp'>>;
+export type ClampNativeSatisfiesBase = Assert<SatisfiesBase<typeof ClampNative, typeof ClampBase, 'AdwClamp'>>;
+/**
+ * The names above, as data, so the RUNTIME half can assert the set is complete.
+ *
+ * A type alias that is deleted takes its check with it and leaves no trace; this list
+ * is what a test can count, and `check-adwaita-rn-platform-split.mjs` holds it against
+ * the widgets on disk. Two derivations of one fact, and the weaker one is the one that
+ * would otherwise wave a missing widget through.
+ */
+export declare const PARITY_ASSERTIONS: readonly ["BinGtkSatisfiesBase", "BinNativeSatisfiesBase", "ClampGtkSatisfiesBase", "ClampNativeSatisfiesBase"];
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/props.d.ts

@@ -0,0 +1,19 @@
+import type { ReactNode } from 'react';
+/** What every widget in this package accepts. */
+export interface AdwWidgetProps {
+    children?: ReactNode;
+}
+/** `Adw.Bin` — a widget with one child and no layout of its own. */
+export type AdwBinProps = AdwWidgetProps;
+/**
+ * `Adw.Clamp` — constrain a child's size and centre it.
+ *
+ * The defaults named below are libadwaita's own; in code both halves read them from
+ * `@gjsify/adwaita-core`'s `ADW_CLAMP_DEFAULTS` rather than repeating them.
+ */
+export interface AdwClampProps extends AdwWidgetProps {
+    /** `maximum-size` — how wide the child may get. Default 600. */
+    maximumSize?: number;
+    /** `tightening-threshold` — where the eased tightening starts. Default 400. */
+    tighteningThreshold?: number;
+}

package/lib/types/refuse.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Refuse, naming the component and how to reach a real one.
+ *
+ * Called from the component body rather than at module scope so that a bundler which
+ * merely REACHES the base module — a type-only import that survived, a barrel walked for
+ * its declarations — does not die at load. The failure is at the first render, which is
+ * still long before anything ships.
+ */
+export declare function refuseBaseModule(component: string): never;

package/lib/types/testing/react-native.d.ts

@@ -0,0 +1,18 @@
+import type { View as RealView } from 'react-native';
+/**
+ * The host element name `View` renders as.
+ *
+ * `RCTView` is React Native's own name for the platform view — the type a real
+ * `react-test-renderer` tree carries under the real runtime — so a test asserting on it
+ * reads the same as one written against the real thing.
+ */
+export declare const RCT_VIEW = "RCTView";
+/**
+ * `react-native`'s `View`, as a host component.
+ *
+ * The `typeof RealView` annotation IS the contract: a double that grew a prop React
+ * Native does not have, or lost one it does, is a compile error here rather than a green
+ * test against a private fiction. `props` is widened because `createElement` is typed
+ * against React's intrinsic elements and knows nothing about React Native's.
+ */
+export declare const View: typeof RealView;

package/lib/types/testing/react-native.spec.d.ts

@@ -0,0 +1,33 @@
+import type { View as RealView } from 'react-native';
+import type { Assert, SameKeys } from '../parity.spec.js';
+import { View } from './react-native.js';
+/**
+ * The double accepts EXACTLY React Native's `View` props — same names, no more, no
+ * fewer.
+ *
+ * ON KEY SETS, AND WHY THE OBVIOUS VERSION DOES NOT WORK. The first attempt was
+ * `const CONTRACT: typeof RealView = View`, which reads like the whole contract and
+ * catches almost nothing: `ViewProps` is entirely OPTIONAL properties, and under
+ * structural typing any two all-optional object types are assignable to each other in
+ * both directions. Measured with that assertion ALONE in the file — replacing the
+ * annotation in `react-native.ts` with a hand-written interface carrying an invented
+ * `notOnTheRealOne?: number` produced no complaint from the contract at all. Comparing
+ * `keyof` is what bites, because a key set is a union of string literals and a union
+ * with an extra member is not assignable to one without it. Both directions were run
+ * against the version below: an invented prop and a dropped `onLayout` each fail on
+ * `DoublePropsMatchReactNative` and nowhere else. A third, added since: a prop whose
+ * TYPE changes while the key set does not (`onLayout?: string`) is invisible here and
+ * falls on `CONTRACT` below — the two assertions cover different halves and both are
+ * needed.
+ *
+ * The check is deliberately TAUTOLOGICAL while `react-native.ts` annotates `View` as
+ * `typeof RealView` — that is the point. It is the annotation this holds in place, and
+ * removing the annotation is the only way for the double to acquire a surface of its
+ * own.
+ *
+ * `SameKeys` comes from `parity.spec.ts`, which needs the same instrument for the same
+ * reason one level up: the package's own props are all-optional too.
+ */
+export type DoublePropsMatchReactNative = Assert<SameKeys<Parameters<typeof View>[0], Parameters<typeof RealView>[0]>>;
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/widgets/bin.d.ts

@@ -0,0 +1,10 @@
+import type { ReactElement } from 'react';
+import type { AdwBinProps } from '../props.js';
+/**
+ * A widget with one child.
+ *
+ * The declaration here is the CONTRACT both platform modules are held to by
+ * `parity.spec.ts`, so a platform module that renames a prop or changes an arity is a
+ * type error rather than a divergence somebody finds on one of the two devices.
+ */
+export declare function AdwBin(_props: AdwBinProps): ReactElement | null;

package/lib/types/widgets/bin.gtk.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type { ReactElement } from 'react';
+import type { AdwBinProps } from '../props.js';
+/** {@link import('./bin.js').AdwBin} on GTK. */
+export declare function AdwBin({ children }: AdwBinProps): ReactElement | null;

package/lib/types/widgets/bin.native.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource react */
+import type { ReactElement } from 'react';
+import type { AdwBinProps } from '../props.js';
+/** {@link import('./bin.js').AdwBin} on React Native. */
+export declare function AdwBin({ children }: AdwBinProps): ReactElement | null;

package/lib/types/widgets/bin.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/widgets/clamp.d.ts

@@ -0,0 +1,12 @@
+import type { ReactElement } from 'react';
+import type { AdwClampProps } from '../props.js';
+/**
+ * Constrain a child's size and centre it.
+ *
+ * THE TWO IMPLEMENTATIONS SHARE THEIR ARITHMETIC AND NOTHING ELSE. On GTK the real
+ * `Adw.Clamp` computes the allocation in C; on React Native `@gjsify/adwaita-core`'s
+ * `clampAllocate` — a port of `adw_clamp_layout_allocate` — computes it in TypeScript.
+ * Both are libadwaita's easing curve, so the suites assert the same child size and the
+ * same centring offset on both sides rather than each side's own idea of "clamped".
+ */
+export declare function AdwClamp(_props: AdwClampProps): ReactElement | null;

package/lib/types/widgets/clamp.gtk.d.ts

@@ -0,0 +1,5 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+import type { ReactElement } from 'react';
+import type { AdwClampProps } from '../props.js';
+/** {@link import('./clamp.js').AdwClamp} on GTK. */
+export declare function AdwClamp({ children, maximumSize, tighteningThreshold }: AdwClampProps): ReactElement | null;

package/lib/types/widgets/clamp.gtk.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource @gjsify/gtk-host/react */
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/widgets/clamp.native.d.ts

@@ -0,0 +1,12 @@
+/** @jsxImportSource react */
+import { type ReactElement } from 'react';
+import type { AdwClampProps } from '../props.js';
+/**
+ * {@link import('./clamp.js').AdwClamp} on React Native.
+ *
+ * BEFORE THE FIRST LAYOUT there is no available width, so the child is rendered unclamped
+ * for exactly one frame. Rendering nothing instead would be worse than it sounds: the
+ * outer `View` is what `onLayout` fires on, so an empty first pass still costs the frame
+ * AND makes the child's own mount effects run a frame later than they do on GTK.
+ */
+export declare function AdwClamp({ children, maximumSize, tighteningThreshold }: AdwClampProps): ReactElement | null;

package/lib/types/widgets/clamp.native.spec.d.ts

@@ -0,0 +1,3 @@
+/** @jsxImportSource react */
+declare const _default: () => Promise<void>;
+export default _default;

package/package.json

@@ -0,0 +1,101 @@
+{
+    "name": "@gjsify/adwaita-react-native",
+    "version": "0.44.0",
+    "description": "Adwaita widgets with one API surface and two implementations — the real Adw.* widget on GTK4, React Native primitives on a phone",
+    "type": "module",
+    "module": "lib/esm/index.js",
+    "types": "lib/types/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./lib/types/index.d.ts",
+            "react-native": "./lib/esm/index.native.js",
+            "default": "./lib/esm/index.gtk.js"
+        },
+        "./widgets/bin": {
+            "types": "./lib/types/widgets/bin.d.ts",
+            "react-native": "./lib/esm/widgets/bin.native.js",
+            "default": "./lib/esm/widgets/bin.gtk.js"
+        },
+        "./widgets/clamp": {
+            "types": "./lib/types/widgets/clamp.d.ts",
+            "react-native": "./lib/esm/widgets/clamp.native.js",
+            "default": "./lib/esm/widgets/clamp.gtk.js"
+        },
+        "./testing/react-native": {
+            "types": "./lib/types/testing/react-native.d.ts",
+            "default": "./lib/esm/testing/react-native.js"
+        }
+    },
+    "files": [
+        "lib",
+        "!lib/types/**/*.spec.d.ts"
+    ],
+    "scripts": {
+        "clear": "gjsify clear lib tmp tsconfig.tsbuildinfo test.gjs.mjs dist",
+        "check": "gjsify tsc --noEmit",
+        "build": "gjsify run build:gjsify && gjsify run build:types",
+        "build:gjsify": "gjsify build --library 'src/**/*.{ts,tsx,js}' --exclude 'src/**/*.spec.{mts,ts,tsx}' 'src/test.{mts,ts}' 'src/test.node.mts'",
+        "build:types": "gjsify tsc",
+        "build:test": "gjsify run build:test:gjs && gjsify run build:test:node",
+        "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs --define 'process.env.NODE_ENV=\"production\"' --exclude-globals navigator",
+        "build:test:node": "gjsify build src/test.node.mts --app node --outfile dist/test.node.mjs --exclude-globals navigator --alias react-native=@gjsify/adwaita-react-native/testing/react-native",
+        "test": "gjsify run build:gjsify && gjsify run build:test && gjsify run test:node && gjsify run test:gjs",
+        "test:gjs": "gjsify run test.gjs.mjs",
+        "test:node": "node dist/test.node.mjs"
+    },
+    "keywords": [
+        "gjs",
+        "gtk",
+        "adwaita",
+        "react",
+        "react-native",
+        "design-system"
+    ],
+    "dependencies": {
+        "@gjsify/adwaita-core": "^0.44.0",
+        "@gjsify/gtk-host": "^0.44.0"
+    },
+    "peerDependencies": {
+        "react": "^19.2.0",
+        "react-native": ">=0.87 <1"
+    },
+    "peerDependenciesMeta": {
+        "react-native": {
+            "optional": true
+        }
+    },
+    "devDependencies": {
+        "@girs/adw-1": "^4.1.0",
+        "@girs/gjs": "^4.1.0",
+        "@girs/gtk-4.0": "^4.1.0",
+        "@gjsify/cli": "^0.44.0",
+        "@gjsify/unit": "^0.44.0",
+        "@types/node": "^25.9.2",
+        "@types/react": "^19.2.2",
+        "@types/react-test-renderer": "^19.1.0",
+        "react": "^19.2.0",
+        "react-native": ">=0.87 <1",
+        "react-test-renderer": "^19.2.8",
+        "typescript": "^6.0.3"
+    },
+    "gjsify": {
+        "runtimes": {
+            "gjs": "polyfill",
+            "node": "polyfill",
+            "browser": "none",
+            "nativescript": "none",
+            "react-native": "native"
+        },
+        "tier": 3
+    },
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/gjsify/gjsify.git",
+        "directory": "packages/framework/adwaita-react-native"
+    },
+    "bugs": {
+        "url": "https://github.com/gjsify/gjsify/issues"
+    },
+    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/framework/adwaita-react-native#readme"
+}