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

package/dist/keyboard.d.ts

@@ -0,0 +1,140 @@
+import { type ReactNode, type Ref, type RefCallback } from "react";
+export type KeyboardNavigationDirection = "up" | "down" | "left" | "right";
+export type KeyboardNavigationSequentialDirection = 1 | -1;
+export type KeyboardNavigationReason = "keyboard" | "pointer" | "programmatic";
+export type KeyboardNavigationVerticalScope = "group" | "all";
+export type KeyboardNavigationRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type KeyboardNavigationTargetModel = {
+    id: string;
+    group?: string;
+    disabled?: boolean;
+    rect?: KeyboardNavigationRect;
+};
+export type KeyboardNavigationModelOptions = {
+    groupOrder?: readonly string[];
+    verticalScope?: KeyboardNavigationVerticalScope;
+};
+export type KeyboardNavigationFocusOptions = {
+    focusVisible?: boolean;
+    reason?: KeyboardNavigationReason;
+    direction?: KeyboardNavigationDirection | "next" | "previous";
+};
+export type KeyboardNavigationChange = {
+    previousId: string;
+    id: string;
+    previousTarget?: KeyboardNavigationTargetModel;
+    target: KeyboardNavigationTargetModel;
+    reason: KeyboardNavigationReason;
+    direction?: KeyboardNavigationDirection | "next" | "previous";
+};
+export type KeyboardNavigationTarget = KeyboardNavigationTargetModel & {
+    textEntry?: boolean;
+    activateOnArrow?: boolean;
+    onActivate?: (event?: unknown) => void;
+    onFocus?: (change: KeyboardNavigationChange) => void;
+    onBlur?: (change: KeyboardNavigationChange) => void;
+    onDismiss?: () => boolean;
+    onMove?: (direction: KeyboardNavigationDirection) => boolean;
+    onPreviewMove?: (direction: KeyboardNavigationDirection) => boolean;
+    onUnhandledMove?: (direction: KeyboardNavigationDirection) => boolean;
+    onSequentialMove?: (direction: KeyboardNavigationSequentialDirection) => boolean;
+    pressToActivate?: boolean;
+    composeRef?: Ref<unknown>;
+};
+export type KeyboardNavigationState = {
+    focusedId: string;
+    focusedGroup: string;
+    focusVisible: boolean;
+    focusedTextEntry: boolean;
+};
+export type KeyboardNavigationController = {
+    focusedId: string;
+    focusedGroup: string;
+    focusVisible: boolean;
+    focusedTextEntry: boolean;
+    focusTarget: (id: string, options?: KeyboardNavigationFocusOptions) => boolean;
+    reportRect: (id: string, rect: KeyboardNavigationRect) => void;
+    focusFirstInGroup: (group: string) => boolean;
+    moveFocus: (direction: KeyboardNavigationDirection, mode?: "preview" | "immediate") => boolean;
+    moveSequentialFocus: (direction: KeyboardNavigationSequentialDirection, options?: {
+        allowTextEntry?: boolean;
+    }) => boolean;
+    activateFocused: () => boolean;
+    dismissFocused: () => boolean;
+    restoreLastNonTextFocus: () => boolean;
+    registerTarget: (target: KeyboardNavigationTarget) => () => void;
+    subscribeState: (listener: () => void) => () => void;
+    stateSnapshot: () => KeyboardNavigationState;
+    subscribeTarget: (id: string, listener: () => void) => () => void;
+    targetSnapshot: (id: string) => string;
+    debugTargets: () => KeyboardNavigationTargetModel[];
+    idPrefix: string;
+};
+export type KeyboardNavigationControllerOptions = KeyboardNavigationModelOptions & {
+    initialId: string;
+    initialGroup?: string;
+    initialFocusVisible?: boolean;
+    idPrefix?: string;
+    onFocusChange?: (change: KeyboardNavigationChange) => void;
+};
+export type KeyboardNavigationKeyPressOptions = {
+    enabled?: boolean;
+    allowTextEntryTab?: boolean;
+    onEscape?: () => void;
+    shouldHandleEvent?: (event: unknown) => boolean;
+};
+export type KeyboardNavigationEventLike = {
+    nativeEvent?: {
+        key?: string;
+        shiftKey?: boolean;
+        ctrlKey?: boolean;
+        altKey?: boolean;
+        metaKey?: boolean;
+        isComposing?: boolean;
+    };
+    key?: string;
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    altKey?: boolean;
+    metaKey?: boolean;
+    isComposing?: boolean;
+};
+export declare function KeyboardNavigationProvider({ controller, children, }: {
+    controller: KeyboardNavigationController;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useKeyboardNavigation(): KeyboardNavigationController | null;
+export declare function mergeRefs<T>(...refs: Array<Ref<T> | undefined | null>): RefCallback<T>;
+export declare function enabledKeyboardNavigationTargets(targets: KeyboardNavigationTargetModel[]): KeyboardNavigationTargetModel[];
+export declare function firstKeyboardNavigationTarget(targets: KeyboardNavigationTargetModel[], options?: KeyboardNavigationModelOptions): string;
+export declare function nextKeyboardNavigationTarget(targets: KeyboardNavigationTargetModel[], currentId: string, direction: KeyboardNavigationDirection, options?: KeyboardNavigationModelOptions): string;
+export declare function nextSequentialKeyboardNavigationTarget(targets: KeyboardNavigationTargetModel[], currentId: string, direction: KeyboardNavigationSequentialDirection, options?: KeyboardNavigationModelOptions): string;
+export declare function useKeyboardNavigationController(optionsOrInitialId: KeyboardNavigationControllerOptions | string): KeyboardNavigationController;
+export declare function useKeyboardNavigationState(controller: KeyboardNavigationController): KeyboardNavigationState;
+export declare function useKeyboardNavigationTarget(target: KeyboardNavigationTarget): {
+    focused: boolean;
+    focusVisible: boolean;
+    focus: () => boolean;
+    activate: (event?: unknown) => void;
+    targetProps: {
+        onPress?: ((event?: unknown) => void) | undefined;
+        ref?: RefCallback<unknown> | undefined;
+        id: string;
+        tabIndex: 0 | undefined;
+    } | {
+        onPress?: ((event?: unknown) => void) | undefined;
+        nativeID: string;
+        ref: RefCallback<unknown>;
+        tabIndex: 0 | undefined;
+    };
+};
+export declare function useKeyboardNavigationKeyPress(controller: KeyboardNavigationController, options?: KeyboardNavigationKeyPressOptions): (event: unknown) => boolean;
+export declare function hasKeyboardNavigationModifier(event: KeyboardNavigationEventLike, options?: {
+    allowShift?: boolean;
+}): boolean;
+export declare function useKeyboardNavigationWindowKeyboard(controller: KeyboardNavigationController, options?: KeyboardNavigationKeyPressOptions): (event: unknown) => boolean;

package/dist/native-menu.d.ts

@@ -0,0 +1,7 @@
+type RegisterNativeMenuAdapter = (adapter: {
+    name: string;
+    Menu: unknown;
+    ContextMenu: unknown;
+}) => void;
+export declare function setupTamaguiNativeMenus(registerNativeMenuAdapter: RegisterNativeMenuAdapter): void;
+export {};

package/dist/platform-driver.d.ts

@@ -0,0 +1,32 @@
+export type PseudoState = {
+    hovered: boolean;
+    pressed: boolean;
+};
+export type PseudoListener = (state: PseudoState) => void;
+/**
+ * Register a listener for a node's native hover/press flips, keyed by globalId, and turn on
+ * the host's per-node opt-in. Returns a dispose that removes the listener and clears the
+ * opt-in once the node has no listeners left. Used by `platformDriver.pseudo.subscribe`.
+ */
+export declare function registerPseudoListener(globalId: number, listener: PseudoListener): () => void;
+/**
+ * Fan a host `pseudo` event to the node's listeners. Called by the render layer's host-event
+ * dispatch (render.ts) for `event === "pseudo"` — BEFORE the React `dispatchEvent` path, so
+ * pseudo state drives the listener (and tamagui's animation driver) without a React commit.
+ */
+export declare function dispatchPseudo(globalId: number, hovered: boolean, pressed: boolean): void;
+/**
+ * The renderer platform driver. tamagui's `@tamagui/core` `setupPlatformDriver(driver)`
+ * consumes this: when a driver with `pseudo` is present, createComponent skips wiring its own
+ * hover/press React event handlers, opens the avoidReRenders gate for any component with
+ * pseudo styles, and feeds this signal into its existing setStateShallow/emitter path so the
+ * style update rides the animation driver (spring if styled, instant otherwise) with zero
+ * React commits. More capabilities (measure, focus, scroll) can slot in over time.
+ */
+export declare const platformDriver: {
+    pseudo: {
+        subscribe(hostInstance: {
+            id: number;
+        }, listener: PseudoListener): () => void;
+    };
+};

package/dist/platform-services.d.ts

@@ -0,0 +1,35 @@
+declare global {
+    var __rngpui_platformRequest: ((op: string, args: unknown) => Promise<unknown>) | undefined;
+    var __rngpui_storageInfo: {
+        persistent: boolean;
+        path: string | null;
+    } | undefined;
+}
+export declare function platformRequest<T>(op: string, args: unknown): Promise<T>;
+export type NotificationOptions = {
+    title: string;
+    body?: string;
+};
+export declare const Notifications: {
+    isAvailable(): boolean;
+    show(options: NotificationOptions): Promise<boolean>;
+};
+export type SoundSource = "ping" | (string & {});
+export type SoundOptions = {
+    volume?: number;
+};
+export declare const Sound: {
+    isAvailable(): boolean;
+    play(source?: SoundSource, options?: SoundOptions): Promise<void>;
+};
+export declare const Processes: {
+    isAvailable(): boolean;
+    findRunning(names: readonly string[]): Promise<string[]>;
+};
+export declare const LocalStorage: {
+    isPersistent(): boolean;
+    getPath(): string | null;
+    flush(): Promise<void>;
+};
+export declare function getRandomValues<T extends ArrayBufferView>(array: T): T;
+export declare function randomUUID(): `${string}-${string}-${string}-${string}-${string}`;

package/dist/portal.d.ts

@@ -0,0 +1,43 @@
+import { type ReactNode } from "react";
+import type { ViewStyle } from "./types";
+export type PortalProviderProps = {
+    children?: ReactNode;
+};
+export type PortalHostProps = {
+    name?: string;
+    style?: ViewStyle;
+    children?: ReactNode;
+};
+export type PortalProps = {
+    hostName?: string;
+    name?: string;
+    style?: ViewStyle;
+    children?: ReactNode;
+};
+export declare function PortalProvider({ children }: PortalProviderProps): import("react").FunctionComponentElement<import("react").FragmentProps>;
+export declare function PortalHost({ name, style, children }: PortalHostProps): import("react").ReactElement<{
+    name: string;
+    pointerEvents: string;
+    style: ViewStyle | (ViewStyle | undefined)[] | undefined;
+}, string | import("react").JSXElementConstructor<any>>;
+export declare function Portal({ children, hostName, name, style }: PortalProps): import("react").ReactElement<{
+    hostName: string;
+    name: string | undefined;
+    pointerEvents: string;
+    style: ViewStyle | undefined;
+}, string | import("react").JSXElementConstructor<any>>;
+export declare const NativePortal: typeof Portal;
+export declare const NativePortalHost: typeof PortalHost;
+export declare function usePortal(_hostName?: string): {
+    isHostAvailable: boolean;
+    removePortal(_name: string): void;
+};
+type TamaguiPortalAccessor = {
+    set: (state: {
+        enabled: boolean;
+        type: "teleport";
+    }) => void;
+};
+type TamaguiGetPortal = (() => TamaguiPortalAccessor) | TamaguiPortalAccessor | undefined;
+export declare function setupTamaguiNativePortal(getPortal?: TamaguiGetPortal): void;
+export {};

package/dist/raf.d.ts

@@ -0,0 +1,4 @@
+declare const root: typeof globalThis & {
+    requestAnimationFrame?: (callback: FrameRequestCallback) => number;
+    cancelAnimationFrame?: (id: number) => void;
+};

package/dist/reanimated/colors-processor-shim.d.ts

@@ -0,0 +1,10 @@
+type StyleProps = Record<string, unknown>;
+export declare function processColor(color: unknown): number | null;
+export declare function processColorNumber(value: unknown): number | null;
+export declare function processColorsInProps(props: StyleProps): void;
+export declare function PlatformColor(...names: string[]): unknown;
+export declare function DynamicColorIOS(tuple: {
+    light: unknown;
+    dark: unknown;
+}): unknown;
+export {};

package/dist/reanimated/reanimated-host.d.ts

@@ -0,0 +1,10 @@
+export * from 'rngpui-reanimated-prebuilt';
+export { default } from 'rngpui-reanimated-prebuilt';
+type AnimationFactory = (...args: unknown[]) => unknown;
+export declare const withTiming: AnimationFactory;
+export declare const withSpring: AnimationFactory;
+export declare const withDecay: AnimationFactory;
+export declare const withDelay: AnimationFactory;
+export declare const withRepeat: AnimationFactory;
+export declare const withSequence: AnimationFactory;
+export declare const withClamp: AnimationFactory;

package/dist/reanimated/seam.d.ts

@@ -0,0 +1,34 @@
+interface MeasuredDimensions {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    pageX: number;
+    pageY: number;
+}
+interface StyleProps {
+    [key: string]: unknown;
+}
+interface SerializableLike {
+    __init?: () => unknown;
+}
+/** Register a viewTag → globalId mapping for an animated component's lifetime. */
+export declare function registerAnimatedViewTag(viewTag: number, globalId: number): void;
+export declare function unregisterAnimatedViewTag(viewTag: number): void;
+declare function installReanimatedNativeSeam(): void;
+declare const _default: {
+    installTurboModule(): boolean;
+};
+export default _default;
+declare function scrollToImpl(animatedRef: unknown, x: number, y: number, _animated: boolean): void;
+declare function measureImpl(animatedRef: unknown): MeasuredDimensions | null;
+declare function setNativePropsImpl(animatedRef: unknown, updates: StyleProps): void;
+declare function dispatchCommandImpl(): void;
+declare function setGestureStateImpl(): void;
+export declare const scrollTo: typeof scrollToImpl;
+export declare const measure: typeof measureImpl;
+export declare const setNativeProps: typeof setNativePropsImpl;
+export declare const dispatchCommand: typeof dispatchCommandImpl;
+export declare const setGestureState: typeof setGestureStateImpl;
+export { installReanimatedNativeSeam };
+export type { SerializableLike };

package/dist/reanimated/ui-entry.d.ts

@@ -0,0 +1,2 @@
+import './seam';
+import '../raf';

package/dist/reanimated/worklet-channel.d.ts

@@ -0,0 +1,10 @@
+import type { WorkletChannel, WorkletRuntime, WorkletRuntimeRole } from './worklet-runtime';
+export declare function makeChannel(role: WorkletRuntimeRole): WorkletChannel;
+/**
+ * Install the inbound receiver so rust can deliver peer messages into this
+ * runtime. `__rngpui_peerRecv(json)` is the single entry point rust calls on the
+ * receiving runtime's queue; it decodes and hands the message to the runtime,
+ * console.erroring (rather than throwing into the rust caller) on a malformed
+ * payload.
+ */
+export declare function installChannel(_role: WorkletRuntimeRole, runtime: WorkletRuntime): void;