@felipe-software/react-native-gpui 0.0.0-placeholder → 1.0.1

package/dist/reconciler.d.ts

@@ -0,0 +1,102 @@
+import ReactReconciler from "react-reconciler";
+import type { SerializedNode } from "./runtime";
+export interface Instance {
+    id: number;
+    type: string;
+    props: Record<string, unknown>;
+    children: Array<Instance | TextInstance>;
+    parent: Instance | null;
+    dirty: boolean;
+    cached: SerializedNode | undefined;
+    cachedListGroup: string | undefined;
+    layoutSnapshot: LayoutSnapshot | undefined;
+    layoutDirty: boolean;
+    preparedStyle: Record<string, unknown> | undefined;
+    hasPreparedStyle: boolean;
+    hasPortal: boolean;
+    measure: (callback: MeasureCallback) => void;
+    measureInWindow: (callback: MeasureInWindowCallback) => void;
+    measureLayout: (relativeToNativeNode: Instance | number | null, onSuccess: (left: number, top: number, width: number, height: number) => void, onFail?: () => void) => void;
+    __nativeTag: number;
+    __internalInstanceHandle: {
+        stateNode: {
+            node: number;
+        };
+        type: string;
+    };
+    _viewConfig: {
+        uiViewClassName: string;
+    };
+}
+export interface TextInstance {
+    id: number;
+    text: string;
+    parent: Instance | null;
+}
+export interface Container {
+    rootID: number;
+    width: number;
+    height: number;
+    children: Array<Instance | TextInstance>;
+    windowId?: number;
+    rootGlobalId?: number;
+}
+export type ReconcilerCommitDiagnostics = {
+    mutationMs: number;
+    serializeMs: number;
+    updates: number;
+    creates: number;
+    serializeHits: number;
+    serializeMisses: number;
+};
+export declare function createWindowContainer(windowId: number, width: number, height: number): Container;
+export declare function registerWindowContainer(container: Container, push: (tree: SerializedNode) => void): void;
+export declare function unregisterWindowContainer(windowId: number): void;
+export declare function pushWindowTree(windowId: number): void;
+export declare function windowContainers(): Container[];
+export declare function invalidateSerializeCaches(container: Container): void;
+type LayoutSnapshot = Pick<SerializedNode, "type" | "style" | "text" | "runs" | "numberOfLines" | "placeholder" | "value" | "src" | "nativeLayoutKey" | "nativeResize" | "wordDiff" | "collapsedPaths" | "diffScroll" | "maxLines">;
+type MeasureCallback = (x: number, y: number, width: number, height: number, pageX: number, pageY: number) => void;
+type MeasureInWindowCallback = (x: number, y: number, width: number, height: number) => void;
+/** The platform driver opts a node into (or out of) the renderer→JS pseudo lane by
+ * globalId. Toggles `pseudoEvents` in the serializer's side set, marks the node dirty,
+ * and recommits so the host learns the flag without a React render. */
+export declare function setPseudoEvents(id: number, on: boolean): void;
+/** Called by the render layer when the bridge reports a native event. */
+export declare function dispatchEvent(id: number, event: string, payload: {
+    value?: string;
+    key?: string;
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    altKey?: boolean;
+    metaKey?: boolean;
+    isComposing?: boolean;
+    eventCount?: number;
+    button?: number;
+    buttons?: number;
+    pressDrag?: boolean;
+    pageX?: number;
+    pageY?: number;
+    locationX?: number;
+    locationY?: number;
+    scrollX?: number;
+    scrollY?: number;
+    scrollWidth?: number;
+    scrollHeight?: number;
+    scrollContentWidth?: number;
+    scrollContentHeight?: number;
+    layout?: unknown;
+    cols?: number;
+    rows?: number;
+    oldLine?: number;
+    newLine?: number;
+    chat?: unknown;
+}): void;
+export declare function findHostNodeId(ref: unknown): number | null;
+export declare function measureHostNode(node: Instance | number | null | undefined, callback: MeasureCallback): void;
+export declare function measureHostNodeInWindow(node: Instance | number | null | undefined, callback: MeasureInWindowCallback): void;
+export declare function measureHostNodeLayout(node: Instance | number | null | undefined, relativeToNativeNode: Instance | number | null | undefined, onSuccess: (left: number, top: number, width: number, height: number) => void, onFail?: () => void): void;
+export declare function serializeContainer(c: Container): SerializedNode;
+export declare function setCommitSink(fn: (tree: SerializedNode, diagnostics?: ReconcilerCommitDiagnostics) => void): void;
+declare const Reconciler: ReactReconciler.Reconciler<unknown, unknown, unknown, unknown, unknown>;
+export default Reconciler;

package/dist/refresh.d.ts

@@ -0,0 +1 @@
+export declare function installRefreshRuntime(): void;

package/dist/render.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The render entry point. Drives react-reconciler into the GPUI bridge:
+ *   React tree → reconciler → serialized node tree → startBridge → GPUI window.
+ * Native events (press / changeText / layout / resize) flow back the other way.
+ */
+import { type ReactElement, type ComponentType } from "react";
+export type DevtoolsOptions = {
+    /** hold Option to inspect native GPUI nodes; Option-click copies a node snapshot. */
+    inspector?: boolean;
+    /** show native frame, commit, and bridge timing in the app window. */
+    performanceHud?: boolean;
+};
+export interface RootOptions {
+    /** initial window size; defaults to the current Dimensions window */
+    width?: number;
+    height?: number;
+    /** optional native development tools for this root */
+    devtools?: boolean | DevtoolsOptions;
+}
+export interface Root {
+    render(element: ReactElement): void;
+    unmount(): void;
+}
+export declare function createRoot(options?: RootOptions): Root;
+/** Convenience entry point for the process's single native window. */
+export declare function render(element: ReactElement, options?: RootOptions): Root;
+export declare function unstable_batchedUpdates<T>(fn: (arg?: T) => unknown, arg?: T): unknown;
+type ComponentProvider = () => ComponentType<any>;
+export interface RunApplicationOptions extends RootOptions {
+    initialProps?: Record<string, unknown>;
+}
+export declare const AppRegistry: {
+    registerComponent(appKey: string, provider: ComponentProvider): string;
+    runApplication(appKey: string, options?: RunApplicationOptions): Root;
+    getAppKeys(): string[];
+};
+export {};

package/dist/runtime.d.ts

@@ -0,0 +1,235 @@
+/**
+ * Runtime bridge — in-process host calls to the embedded JavaScriptCore host (rust/src/jsc.rs).
+ *
+ * Single-process model: this code runs inside JavaScriptCore on the JS thread; the Rust binary owns
+ * the GPUI/Metal main thread. Instead of spawning a service and streaming NDJSON over pipes,
+ * every committed tree is handed to the host fn `globalThis.__rngpui_applyTree(json)`, and
+ * native events arrive by the host calling `globalThis.__rngpui_onHostEvent(json)`.
+ *
+ * The JSON tree/event protocol is unchanged from the old stdio bridge — only the transport.
+ */
+export type SerializedNode = {
+    globalId: number;
+    /** delta wire only: a `{ globalId, ref: true }` node tells the host to reuse the prior
+     * commit's subtree for this id unchanged (emitted by toWireDelta in render.ts). Full
+     * nodes omit it and always carry `type`; refs carry only globalId + ref. */
+    ref?: boolean;
+    type?: string;
+    style?: Record<string, unknown>;
+    /** opt-in renderer→JS pseudo lane: when true, the host emits a coalesced `pseudo`
+     * event ({hovered, pressed}) on every native hover/press flip of this node's hitbox,
+     * routed by the pseudo registry (platform-driver.ts) to a renderer-platform driver
+     * (tamagui). Set imperatively via `platformDriver.pseudo.subscribe`, not a React prop. */
+    pseudoEvents?: boolean;
+    /** internal authored JSX source location. toWireDelta interns this before transport. */
+    source?: string;
+    /** compact wire tuple: [source-file id, line, column]. */
+    sourceId?: [number, number, number];
+    /** root-only source-file definitions first referenced by this tree update. */
+    sources?: Record<string, string>;
+    accessibility?: SerializedAccessibility;
+    text?: string;
+    numberOfLines?: number;
+    /** RN Text `selectable`: opts into the native drag selection + Cmd+C copy. */
+    selectable?: boolean;
+    value?: string;
+    defaultValue?: string;
+    editable?: boolean;
+    secureTextEntry?: boolean;
+    autoFocus?: boolean;
+    mostRecentEventCount?: number;
+    src?: string;
+    /** `<Image resizeMode>` — how the picture fills the box layout gave the element. */
+    resizeMode?: string;
+    /** `<Image dragOut>` — opt into macOS file drag-out. A string is the dropped filename. */
+    dragOut?: boolean | string;
+    dragFileName?: string;
+    /** `<Diff>` options. The patch itself uses `text` so large-field interning applies. */
+    wordDiff?: boolean;
+    collapsedPaths?: string[];
+    diffScroll?: boolean;
+    maxLines?: number;
+    chatList?: Record<string, unknown>;
+    /** delta wire only: this (changed) node's large `text`/`src` is byte-identical to
+     * what the host already holds for this globalId, so it was omitted — the host reuses
+     * its prior value (parse_json_tree, same PRIOR_TREE_INDEX the node-level `ref` uses).
+     * Emitted by toWireDelta's big-field interning; never set on a first/changed send. */
+    textRef?: boolean;
+    srcRef?: boolean;
+    name?: string;
+    placeholder?: string;
+    placeholderTextColor?: string;
+    /** RN ScrollView overlay-scroller visibility. Scrolling stays enabled when false. */
+    showsVerticalScrollIndicator?: boolean;
+    showsHorizontalScrollIndicator?: boolean;
+    /** `<SystemView>` NSVisualEffectView material name */
+    systemMaterial?: string;
+    /** `<SystemView>` NSGlassEffectView liquid-glass variant name (macOS 26+) */
+    systemGlassVariant?: string;
+    /** `<SystemView>` optional tint overlay, as a CSS color string */
+    systemTint?: string;
+    /** `<SystemView>` optional native outer drop shadow */
+    systemShadow?: {
+        color?: string;
+        radius?: number;
+        offsetX?: number;
+        offsetY?: number;
+        opacity?: number;
+    };
+    /** `<SystemView>` horizontal native alpha fade at the left/right edges, 0..0.5 */
+    systemEdgeFade?: number;
+    /** `<SystemView>` vertical native alpha fade start, 0..1 from top to bottom */
+    systemTopFadeStart?: number;
+    /** in-app liquid-glass backdrop blur radius (logical-px gaussian sigma) for a `<View>` */
+    backdropBlur?: number;
+    /** tint composited over the blurred backdrop, as a CSS color string */
+    backdropTint?: string;
+    events?: string[];
+    children?: SerializedNode[];
+    /** inline styled runs for `<Text>` with nested `<Text>` children */
+    runs?: Array<{
+        text: string;
+        fontWeight?: string;
+        color?: string;
+        fontStyle?: string;
+    }>;
+    /** native-only layout override key, used by the gpui runtime without React commits */
+    nativeLayoutKey?: string;
+    /** native-only resize gesture, applied to a keyed native layout target */
+    nativeResize?: SerializedNativeResize;
+    /** native-only press-drag selection group */
+    nativeListGroup?: string;
+};
+export type SerializedNativeResize = {
+    target: string;
+    edge: "left" | "right" | "top" | "bottom";
+    min?: number;
+    max?: number;
+};
+export type SerializedAccessibility = {
+    accessible?: boolean;
+    hidden?: boolean;
+    label?: string;
+    role?: string;
+    hint?: string;
+    value?: string;
+    identifier?: string;
+    identifierSource?: "nativeID" | "testID" | "id";
+    nativeID?: string;
+    testID?: string;
+    propID?: string;
+    disabled?: boolean;
+    selected?: boolean;
+    checked?: boolean | "mixed";
+    expanded?: boolean;
+};
+export type BridgeEvent = {
+    type: "ready";
+    width: number;
+    height: number;
+} | {
+    type: "resize";
+    width: number;
+    height: number;
+} | {
+    type: "command";
+    id: string;
+} | {
+    type: "appearance";
+    colorScheme: "light" | "dark";
+} | {
+    type: "rendererProvenance";
+    requestId: number;
+    provenance: RendererProvenance;
+} | {
+    type: "imagePrefetch";
+    requestId: number;
+    loaded: boolean;
+} | {
+    type: "window";
+    windowId: number;
+    event: "open" | "resize" | "close" | "focus" | "blur";
+    width?: number;
+    height?: number;
+    reason?: "system" | "escape" | "blur" | "error";
+} | {
+    type: "appState";
+    state: "active" | "inactive";
+    windowId: number | null;
+} | {
+    type: "event";
+    id: number;
+    event: string;
+    value?: string;
+    key?: string;
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    altKey?: boolean;
+    metaKey?: boolean;
+    isComposing?: boolean;
+    eventCount?: number;
+    button?: number;
+    buttons?: number;
+    pressDrag?: boolean;
+    pageX?: number;
+    pageY?: number;
+    locationX?: number;
+    locationY?: number;
+    scrollX?: number;
+    scrollY?: number;
+    scrollWidth?: number;
+    scrollHeight?: number;
+    scrollContentWidth?: number;
+    scrollContentHeight?: number;
+    layout?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    oldLine?: number;
+    newLine?: number;
+    /** `pseudo` lane: absolute native hover/press state of the node's hitbox */
+    hovered?: boolean;
+    pressed?: boolean;
+    chat?: unknown;
+};
+export interface Bridge {
+    initialUpdate: BridgeUpdateDiagnostics;
+    update(tree: SerializedNode): BridgeUpdateDiagnostics;
+    /** send an imperative command (host → frame), e.g. a WebView eval/reload */
+    command(cmd: object): void;
+    onEvent(cb: (e: BridgeEvent) => void): void;
+    close(): void;
+}
+export type BridgeUpdateDiagnostics = {
+    bytes: number;
+    stringifyMs: number;
+};
+export interface BridgeOptions {
+    /** Enables the native Option-key element inspector in the host. */
+    inspector?: boolean;
+    /** Enables the native in-window frame/commit performance HUD. */
+    performanceHud?: boolean;
+}
+export type RendererProvenance = {
+    renderer: string;
+    rendererVersion: string;
+    gpuiRevision: string;
+    serviceVersion: string;
+    jsEngine: string;
+    jsEngineVersion: string;
+    bundleUrl: string | null;
+    development: boolean;
+};
+/**
+ * Send one `$cmd` envelope to the host without a bridge.
+ *
+ * `startBridge` does not run until the first commit, so anything the host needs
+ * *before* React has rendered has no bridge to travel on. The host fns are
+ * installed before this bundle is even evaluated, so the channel itself is ready
+ * long before the bridge is.
+ */
+export declare function sendHostCommand(cmd: object): void;
+export declare function setEventBatcher(fn: ((run: () => void) => void) | undefined): void;
+export declare function startBridge(initial: SerializedNode, options?: BridgeOptions): Bridge;

package/dist/surfaces.d.ts

@@ -0,0 +1,51 @@
+import { type ReactNode } from "react";
+import { type SystemViewGlassVariant, type SystemViewMaterial, type SystemViewShadow } from "./components";
+import type { ColorValue, StyleProp, ViewProps, ViewStyle } from "./types";
+export type LiquidGlassChrome = false | {
+    fill?: ColorValue;
+    borderColor?: ColorValue;
+    borderWidth?: number;
+};
+export interface LiquidGlassBackgroundProps {
+    radius?: number;
+    material?: SystemViewMaterial;
+    glassVariant?: SystemViewGlassVariant;
+    tint?: ColorValue;
+    shadow?: SystemViewShadow;
+    edgeFade?: number;
+    topFadeStart?: number;
+    chrome?: LiquidGlassChrome;
+    style?: StyleProp<ViewStyle>;
+}
+export interface LiquidGlassViewProps extends Omit<ViewProps, "style">, Omit<LiquidGlassBackgroundProps, "style"> {
+    style?: StyleProp<ViewStyle>;
+    backgroundStyle?: StyleProp<ViewStyle>;
+    children?: ReactNode;
+}
+export type SmokeEffect = {
+    type: "smoke";
+    color?: ColorValue;
+    fadedColor?: ColorValue;
+    alpha?: number;
+    reach?: number;
+    topClear?: number;
+};
+export type BackgroundImageEffect = {
+    type: "backgroundImage";
+    backgroundImage: string;
+};
+export type EffectSurfaceEffect = SmokeEffect | BackgroundImageEffect;
+export interface EffectSurfaceProps extends Omit<ViewProps, "style" | "backgroundImage" | "experimental_backgroundImage"> {
+    effect: EffectSurfaceEffect;
+    radius?: number;
+    style?: StyleProp<ViewStyle>;
+    children?: ReactNode;
+}
+export interface SmokeEffectSurfaceProps extends Omit<EffectSurfaceProps, "effect">, Omit<SmokeEffect, "type"> {
+}
+export declare function LiquidGlassBackground({ radius, material, glassVariant, tint, shadow, edgeFade, topFadeStart, chrome, style, }: LiquidGlassBackgroundProps): import("react/jsx-runtime").JSX.Element;
+export declare function LiquidGlassView({ children, style, backgroundStyle, radius, material, glassVariant, tint, shadow, edgeFade, topFadeStart, chrome, ...viewProps }: LiquidGlassViewProps): import("react/jsx-runtime").JSX.Element;
+export declare function EffectSurface({ effect, radius, style, children, ...viewProps }: EffectSurfaceProps): import("react/jsx-runtime").JSX.Element;
+export declare function SmokeEffectSurface({ color, fadedColor, alpha, reach, topClear, ...props }: SmokeEffectSurfaceProps): import("react/jsx-runtime").JSX.Element;
+export declare function effectBackgroundImage(effect: EffectSurfaceEffect): string;
+export declare function smokeEffectBackgroundImage(effect: Omit<SmokeEffect, "type">): string;