@gjsify/react-native 0.43.0

package/lib/types/primitives/table.d.ts

@@ -0,0 +1,122 @@
+import type { Orientation, WidgetFacts } from './intents.js';
+/** How a prop's value becomes a GTK value. */
+export type Coercion = 
+/** Straight through, as a string. */
+'string'
+/** Straight through, as a boolean. */
+ | 'boolean'
+/** Inverted — `secureTextEntry` is `Gtk.Entry:visibility` turned around. */
+ | 'not'
+/** Truncated to the `gint` a GTK property stores. */
+ | 'int'
+/** Looked up in {@link PropertyRoute.map}; anything else is a named refusal. */
+ | 'map'
+/** A number is a pixel count; a string is looked up in the map. */
+ | 'pixels-or-map';
+export interface PropertyRoute {
+    readonly to: 'property';
+    /** Which node it lands on. `content` is the implicit inner box, where there is one. */
+    readonly on?: 'outer' | 'content';
+    /** The GTK properties this one prop fills — plural for `size`, which is two requests. */
+    readonly names: readonly string[];
+    readonly as: Coercion;
+    readonly map?: Readonly<Record<string, string | number | boolean>>;
+    /** Properties that come with this prop being SET at all, whatever its value. */
+    readonly also?: Readonly<Record<string, unknown>>;
+}
+/** A prop that joins the normalised style record instead of going straight to a widget. */
+export interface StylePropertyRoute {
+    readonly to: 'style-property';
+    /** Its name in `StyleProps` — `ActivityIndicator`'s `color` is the paint half's `color`. */
+    readonly name: string;
+}
+export interface EventRoute {
+    readonly to: 'event';
+    /** The GObject signal, in GObject's own spelling. `notify::active` is a real signal name. */
+    readonly signal: string;
+    /**
+     * The widget property whose value becomes the callback's argument.
+     *
+     * The host strips the emitter before calling a handler (`next(...args.slice(1))`
+     * in `signals.ts`), and `Gtk.Editable::changed` carries no payload of its own —
+     * so `onChangeText(text)` cannot be built from the signal arguments at all. The
+     * framework layer reads this property off its own ref instead, which is why the
+     * NAME is data here and the reading is L3's.
+     */
+    readonly read?: string;
+}
+export interface RefusedRoute {
+    readonly to: 'refused';
+    /** One line: why GTK cannot answer it, and what to do instead. */
+    readonly why: string;
+}
+/**
+ * A prop that is a DECLARED no-op.
+ *
+ * Not the same thing as an unknown prop and not the same thing as a refusal: the
+ * name is recognised, the answer is "a desktop window already behaves this way".
+ * `flex-nowrap` in `@gjsify/gtk-host/style` is the same shape for the same reason —
+ * declared here, asserted empty in the spec, so "means nothing on GTK" stays
+ * distinguishable from "was never recognised".
+ */
+export interface IgnoredRoute {
+    readonly to: 'ignored';
+    readonly why: string;
+}
+export type PropRoute = PropertyRoute | StylePropertyRoute | EventRoute | RefusedRoute | IgnoredRoute;
+/** A second styleable node inside the element, which the children go into. */
+export interface ContentSpec {
+    readonly tag: string;
+    readonly widgetProps: Readonly<Record<string, unknown>>;
+    readonly orientation: Orientation;
+    readonly widget: WidgetFacts;
+    /** The prop that styles it — `ScrollView`'s `contentContainerStyle`. */
+    readonly styleProp: string | null;
+    /**
+     * Its class-list prop.
+     *
+     * `contentContainerClassName` is NativeWind's spelling, not React Native's, and
+     * it is carried because ADR 0032 § 12 replaces NativeWind rather than supporting
+     * it: the class VOCABULARY is consumed, so the prop that carries it for the
+     * inner node has to be too. Without it the one node a class list cannot reach is
+     * the one that holds every child.
+     */
+    readonly classNameProp: string | null;
+}
+export interface PrimitiveSpec {
+    /** GType name, which is the tag the host takes. */
+    readonly tag: string;
+    /** Properties every instance carries before a single prop is read. */
+    readonly widgetProps: Readonly<Record<string, unknown>>;
+    /** GTK CSS classes every instance carries — `flat` on a `Pressable`. */
+    readonly cssClasses: readonly string[];
+    /** The element's own orientation, for the intents that need it. */
+    readonly orientation: Orientation;
+    readonly widget: WidgetFacts;
+    /** Where a text child goes, or null when text under this primitive is refused. */
+    readonly textSink: string | null;
+    /** Prop name → destination. One or more routes; several is `horizontal`'s shape. */
+    readonly props: Readonly<Record<string, PropRoute | readonly PropRoute[]>>;
+    readonly content?: ContentSpec;
+    /**
+     * The element becomes THIS widget when one of its children is absolutely
+     * positioned, and its own children move into `content`.
+     *
+     * Triggered by the CHILD, never by the element (ADR 0032 § 3: `absolute` occurs
+     * five times in the measured application and always on the child).
+     */
+    readonly overlayOnAbsoluteChild?: {
+        readonly tag: string;
+        readonly slot: string;
+    };
+    /** One React Native prop, two GTK widgets. `TextInput`'s `multiline`. */
+    readonly switchOn?: {
+        readonly prop: string;
+        readonly whenTrue: PrimitiveSpec;
+    };
+}
+export declare const PRIMITIVES: Readonly<Record<string, PrimitiveSpec>>;
+/** The primitives this layer answers for. Derived, so it cannot disagree with the table. */
+export declare const PRIMITIVE_NAMES: readonly string[];
+/** Props the framework owns; they never reach a widget and are never refused. */
+export declare const FRAMEWORK_PROPS: ReadonlySet<string>;

package/lib/types/primitives/widgets.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

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

@@ -0,0 +1,101 @@
+import { createElement, mount } from '@gjsify/gtk-host/solid';
+import type { ClassNameInput } from '../primitives/classes.js';
+import type { StyleInput } from '../primitives/style.js';
+/**
+ * The host's node type, named through the adapter rather than imported.
+ *
+ * `@gjsify/gtk-host` publishes no `./types` subpath (its exports map is curated), so
+ * `HostNode` has no importable name — but `createElement`'s return type is the same
+ * type, and `ReturnType` reaches it without widening anything to `unknown`.
+ */
+type HostNode = ReturnType<typeof createElement>;
+/** What a child of one of these components can be. */
+export type PrimitiveChild = HostNode | string | number | boolean | null | undefined;
+export type PrimitiveChildren = PrimitiveChild | readonly PrimitiveChildren[];
+/** What every primitive accepts on top of its own props. */
+export interface CommonProps {
+    className?: ClassNameInput;
+    style?: StyleInput;
+    children?: PrimitiveChildren;
+    /**
+     * The `Gtk.Widget` itself, once it exists.
+     *
+     * Called from `onMount` rather than during the body, and the reason is the
+     * host's deferred materialisation: a node has no widget until something needs
+     * one, and what needs one is being placed. Solid's own `spread` calls
+     * `props.ref(node)` with the NODE for the same reason — it has nothing else at
+     * that moment — so handing the widget is a deliberate difference from the
+     * renderer's convention and the same value React's `ref` receives here.
+     */
+    ref?: (widget: unknown) => void;
+    testID?: string;
+}
+export interface ViewProps extends CommonProps {
+    /** `auto` and `none` only — GTK's `can-target` covers the widget AND its subtree. */
+    pointerEvents?: 'auto' | 'none';
+}
+export declare function View(props: ViewProps): HostNode;
+export interface TextProps extends CommonProps {
+    numberOfLines?: number;
+    ellipsizeMode?: 'head' | 'middle' | 'tail';
+    selectable?: boolean;
+}
+export declare function Text(props: TextProps): HostNode;
+export interface PressableProps extends CommonProps {
+    onPress?: () => void;
+    disabled?: boolean;
+    pointerEvents?: 'auto' | 'none';
+    /**
+     * Never a function of `{ pressed }`.
+     *
+     * `PrimitiveChildren` excludes functions, which is the build-time half of ADR
+     * 0032 § 7's refusal — the same half `components.ts` gets from `ReactNode`. The
+     * runtime half is in `factsOf`, and it is generic rather than per-primitive here
+     * because Solid resolves children before any primitive sees them.
+     */
+    children?: PrimitiveChildren;
+}
+export declare function Pressable(props: PressableProps): HostNode;
+export interface ScrollViewProps extends CommonProps {
+    horizontal?: boolean;
+    showsVerticalScrollIndicator?: boolean;
+    showsHorizontalScrollIndicator?: boolean;
+    contentContainerStyle?: StyleInput;
+    /** NativeWind's spelling for the inner node's class list. See `ContentSpec.classNameProp`. */
+    contentContainerClassName?: ClassNameInput;
+}
+export declare function ScrollView(props: ScrollViewProps): HostNode;
+export interface ActivityIndicatorProps extends CommonProps {
+    animating?: boolean;
+    size?: 'small' | 'large' | number;
+    color?: string;
+    hidesWhenStopped?: boolean;
+}
+export declare function ActivityIndicator(props: ActivityIndicatorProps): HostNode;
+export interface TextInputProps extends CommonProps {
+    value?: string;
+    defaultValue?: string;
+    placeholder?: string;
+    onChangeText?: (text: string) => void;
+    onSubmitEditing?: () => void;
+    /** One prop, two widgets: `Gtk.Entry` without it, `Gtk.TextView` with it. */
+    multiline?: boolean;
+    editable?: boolean;
+    maxLength?: number;
+    secureTextEntry?: boolean;
+    keyboardType?: 'default' | 'email-address' | 'phone-pad' | 'number-pad' | 'numeric' | 'decimal-pad' | 'url';
+}
+export declare function TextInput(props: TextInputProps): HostNode;
+export interface SwitchProps extends CommonProps {
+    value?: boolean;
+    onValueChange?: (value: boolean) => void;
+    disabled?: boolean;
+}
+export declare function Switch(props: SwitchProps): HostNode;
+/**
+ * Re-exported, not re-implemented: mounting a Solid tree into a widget the
+ * application owns is the host adapter's op, and it is the same one whether the tree
+ * is written in GTK's vocabulary or React Native's. Having it here means a consumer
+ * of this subpath needs one import to render, and there is still exactly one `mount`.
+ */
+export { mount };

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

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/style-config.d.ts

@@ -0,0 +1,28 @@
+import { type StyleTokens } from '@gjsify/gtk-host/style';
+import type { ClassNameSink } from './primitives/style.js';
+export interface StyleConfig {
+    readonly tokens: StyleTokens;
+    /** Where a declaration set becomes a class name. Defaults to one generated sheet. */
+    readonly sheet: ClassNameSink;
+}
+/**
+ * Install the project's token scales, and optionally its own sheet.
+ *
+ * Call it once, before the first render — `AppRegistry.runApplication`'s
+ * `createWindow` runs after it, so module scope in the entry file is early enough.
+ */
+export declare function configureStyle(config: {
+    readonly tokens?: StyleTokens;
+    readonly sheet?: ClassNameSink;
+}): void;
+/**
+ * The active configuration, building the default sheet on first use.
+ *
+ * LAZY because `StyleSheet` constructs a `Gtk.CssProvider` and installs it on the
+ * default `Gdk.Display`. Building it at module scope would need a display at IMPORT
+ * time, which is before `Gtk.init()` in every application — and the failure would
+ * be an import that throws rather than a render that does.
+ */
+export declare function styleConfig(): StyleConfig;
+/** Test seam: back to `MINIMAL_TOKENS` and no sheet. */
+export declare function resetStyleConfig(): void;

package/lib/types/support-table.d.ts

@@ -0,0 +1,38 @@
+/** What this layer does about a React Native export. */
+export type SupportStatus = 
+/** Implemented. */
+'supported'
+/** Implemented with named limits — `limits` lists them. */
+ | 'partial'
+/** On the map, not built yet. `tier` says how soon. */
+ | 'planned'
+/** Will not be built, and there is a decision behind it. */
+ | 'refused'
+/** Exists so an import resolves; does nothing, because a desktop window has no such concept. */
+ | 'no-desktop-meaning'
+/** Cannot be built in this toolchain at all — not a scheduling statement. */
+ | 'not-reachable';
+/** Priority tiers, as ADR 0032 records them. */
+export type SupportTier = 'P1' | 'P2' | 'P3';
+export interface SupportEntry {
+    readonly status: SupportStatus;
+    /** Absent for `refused` / `not-reachable`, which are not scheduled at all. */
+    readonly tier?: SupportTier;
+    /** The GTK or Adwaita counterpart, where there is one. */
+    readonly gtk?: string;
+    /** One line. It is what the build error and the README both print. */
+    readonly reason: string;
+    /** For `partial`: what it does not do. */
+    readonly limits?: readonly string[];
+}
+export declare const SUPPORT_TABLE: Readonly<Record<string, SupportEntry>>;
+/** Every name `react-native` publicly exports, as this table claims to cover it. */
+export declare const SUPPORTED_NAMES: readonly string[];
+export declare const isImportable: (name: string) => boolean;
+/**
+ * The sentence a build error and a runtime throw both print.
+ *
+ * One function so the two cannot drift into describing the same gap differently —
+ * which is the whole reason the table is data rather than prose in two places.
+ */
+export declare function explainUnsupported(name: string): string;

package/lib/types/support-table.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/unsupported.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The error an unimplemented export raises.
+ *
+ * A named class so a consumer can distinguish "this layer does not do that yet"
+ * from a genuine bug in their own code, which a bare `Error` makes impossible.
+ */
+export declare class UnsupportedError extends Error {
+    readonly name = "UnsupportedError";
+    /** The React Native export that was reached for. */
+    readonly export: string;
+    constructor(exportName: string);
+}
+/**
+ * A stand-in for `name` that refuses every use with the table's own sentence.
+ *
+ * Callable, constructible, and property-readable — all three throw. It is typed
+ * `never`-ish on purpose at the call sites that re-export it: the declared type
+ * comes from React Native's own, so a consumer's code still type-checks and the
+ * refusal is a runtime fact rather than a type error they cannot act on.
+ */
+export declare function unsupported(name: string): never;

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

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/package.json

@@ -0,0 +1,111 @@
+{
+    "name": "@gjsify/react-native",
+    "version": "0.43.0",
+    "description": "The React Native view vocabulary rendered onto GTK4/Adwaita, over @gjsify/gtk-host",
+    "type": "module",
+    "module": "lib/esm/index.js",
+    "types": "lib/types/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./lib/types/index.d.ts",
+            "default": "./lib/esm/index.js"
+        },
+        "./solid": {
+            "types": "./lib/types/solid/index.d.ts",
+            "default": "./lib/esm/solid/index.js"
+        },
+        "./support-table": {
+            "types": "./lib/types/support-table.d.ts",
+            "default": "./lib/esm/support-table.js"
+        }
+    },
+    "files": [
+        "lib",
+        "react-native-surface.json",
+        "!lib/types/**/*.spec.d.ts"
+    ],
+    "scripts": {
+        "clear": "gjsify clear lib tmp tsconfig.tsbuildinfo test.gjs.mjs",
+        "check": "gjsify tsc --noEmit",
+        "build": "gjsify run build:gjsify && gjsify run build:types",
+        "build:gjsify": "gjsify build --library 'src/**/*.{ts,js}' --exclude 'src/**/*.spec.{mts,ts}' 'src/test.{mts,ts}'",
+        "build:types": "gjsify tsc",
+        "build:test": "gjsify run build:test:gjs",
+        "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.mts --app node --outfile dist/test.node.mjs --define 'process.env.NODE_ENV=\"production\"' --exclude-globals navigator",
+        "test": "gjsify run build:gjsify && gjsify run build:test && gjsify run test:gjs",
+        "test:gjs": "gjsify run test.gjs.mjs",
+        "test:gjs-on-node": "gjsify run build:gjsify && gjsify run build:test:node && NODE_GI_NATIVE=${NODE_GI_NATIVE:-prebuild} node dist/test.node.mjs",
+        "generate": "node scripts/generate-exports.mjs && gjsify format src/generated"
+    },
+    "keywords": [
+        "gjs",
+        "gtk",
+        "adwaita",
+        "react",
+        "react-native"
+    ],
+    "dependencies": {
+        "@gjsify/adwaita-app": "^0.43.0",
+        "@gjsify/gtk-host": "^0.43.0"
+    },
+    "peerDependencies": {
+        "react": "^19.2.0",
+        "react-reconciler": "^0.33.0",
+        "solid-js": "^1.9.0"
+    },
+    "peerDependenciesMeta": {
+        "react": {
+            "optional": true
+        },
+        "react-reconciler": {
+            "optional": true
+        },
+        "solid-js": {
+            "optional": true
+        }
+    },
+    "devDependencies": {
+        "@gjsify/cli": "^0.43.0",
+        "@gjsify/unit": "^0.43.0",
+        "@girs/adw-1": "^4.1.0",
+        "@girs/gdk-4.0": "^4.1.0",
+        "@girs/gjs": "^4.1.0",
+        "@girs/gtk-4.0": "^4.1.0",
+        "@types/node": "^25.9.2",
+        "@types/react": "^19.2.2",
+        "@types/react-reconciler": "^0.33.0",
+        "react": "^19.2.0",
+        "react-reconciler": "^0.33.0",
+        "solid-js": "^1.9.0",
+        "typescript": "^6.0.3"
+    },
+    "gjsify": {
+        "os": {
+            "linux": "supported",
+            "darwin": "partial",
+            "win32": "partial"
+        },
+        "osNotes": {
+            "darwin": "Platform.OS reads the host OS, so this package owes an OS claim (ADR 0018). Nothing in it is Linux-specific — the widgets are GTK4/Adwaita and the style partition is pure TS — but no leg of its suite has been run on darwin, and ADR 0032's own Consequences put macOS on Node + @gjsify/node-gi + @gjsify/gtk-runtime-darwin-*, whose installable artifact is ADR 0024 stage 4 and does not exist yet.",
+            "win32": "As darwin, and one step further: there is no GJS host on Windows at all (ADR 0024 § 4), so the only route is node-gi, and ADR 0024 stage 5 is unbuilt. Platform.OS reports 'windows' correctly; nothing else here has been exercised there."
+        },
+        "runtimes": {
+            "gjs": "polyfill",
+            "node": "polyfill",
+            "browser": "none",
+            "nativescript": "none"
+        },
+        "tier": 3
+    },
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/gjsify/gjsify.git",
+        "directory": "packages/framework/react-native"
+    },
+    "bugs": {
+        "url": "https://github.com/gjsify/gjsify/issues"
+    },
+    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/framework/react-native#readme"
+}

package/react-native-surface.json

@@ -0,0 +1,108 @@
+{
+    "$comment": [
+        "The public export names of react-native, read from the installed package's index.js",
+        "rather than from documentation. src/support-table.ts must have exactly these keys.",
+        "Committed rather than derived at check time because react-native pulls ~170 MB of",
+        "dependencies (hermes-compiler alone is 47 MB) and every workspace install would pay it",
+        "for one list of strings. scripts/check-rn-surface.mjs compares the table against this",
+        "file always, and additionally re-derives this file from a real react-native install",
+        "when one is resolvable -- so the gate is stronger where the package is present and says",
+        "so where it is not."
+    ],
+    "reactNativeVersion": "0.85.3",
+    "readOn": "2026-08-26",
+    "exports": [
+        "AccessibilityInfo",
+        "ActionSheetIOS",
+        "ActivityIndicator",
+        "Alert",
+        "Animated",
+        "AppRegistry",
+        "AppState",
+        "Appearance",
+        "BackHandler",
+        "Button",
+        "Clipboard",
+        "DevMenu",
+        "DevSettings",
+        "DeviceEventEmitter",
+        "DeviceInfo",
+        "Dimensions",
+        "DrawerLayoutAndroid",
+        "DynamicColorIOS",
+        "Easing",
+        "EventEmitter",
+        "FlatList",
+        "I18nManager",
+        "Image",
+        "ImageBackground",
+        "InputAccessoryView",
+        "InteractionManager",
+        "Keyboard",
+        "KeyboardAvoidingView",
+        "LayoutAnimation",
+        "Linking",
+        "LogBox",
+        "Modal",
+        "NativeAppEventEmitter",
+        "NativeComponentRegistry",
+        "NativeDialogManagerAndroid",
+        "NativeEventEmitter",
+        "NativeModules",
+        "Networking",
+        "PanResponder",
+        "PermissionsAndroid",
+        "PixelRatio",
+        "Platform",
+        "PlatformColor",
+        "Pressable",
+        "ProgressBarAndroid",
+        "PushNotificationIOS",
+        "ReactNativeVersion",
+        "RefreshControl",
+        "RootTagContext",
+        "SafeAreaView",
+        "ScrollView",
+        "SectionList",
+        "Settings",
+        "Share",
+        "StatusBar",
+        "StyleSheet",
+        "Switch",
+        "Systrace",
+        "Text",
+        "TextInput",
+        "ToastAndroid",
+        "Touchable",
+        "TouchableHighlight",
+        "TouchableNativeFeedback",
+        "TouchableOpacity",
+        "TouchableWithoutFeedback",
+        "TurboModuleRegistry",
+        "UIManager",
+        "UTFSequence",
+        "Vibration",
+        "View",
+        "VirtualViewMode",
+        "VirtualizedList",
+        "VirtualizedSectionList",
+        "codegenNativeCommands",
+        "codegenNativeComponent",
+        "experimental_LayoutConformance",
+        "findNodeHandle",
+        "processColor",
+        "registerCallableModule",
+        "requireNativeComponent",
+        "unstable_NativeText",
+        "unstable_NativeView",
+        "unstable_TextAncestorContext",
+        "unstable_VirtualView",
+        "unstable_batchedUpdates",
+        "useAnimatedColor",
+        "useAnimatedValue",
+        "useAnimatedValueXY",
+        "useColorScheme",
+        "usePressability",
+        "useWindowDimensions"
+    ]
+}