@granite-js/react-native 0.0.1

package/dist/intersection-observer/IntersectionObserver.d.ts

@@ -0,0 +1,67 @@
+import { LayoutRectangle, NativeScrollEvent } from 'react-native';
+export interface Root {
+    /**
+     * NodeHandle of the target component
+     */
+    node: any;
+    /**
+     * Whether horizontal scroll is enabled
+     */
+    horizontal: boolean;
+    /**
+     * Scroll event of the target component
+     */
+    current: NativeScrollEvent;
+    onLayout?: () => void;
+    onScroll?: (event: NativeScrollEvent) => void;
+}
+export interface Element {
+    inView: boolean;
+    intersectionRatio: number;
+    layout: LayoutRectangle;
+    measureLayout: (node: any, callback: (x: number, y: number, width: number, height: number) => void) => void;
+    onLayout?: () => void;
+}
+export interface IntersectionObserverEntry {
+    target: Element;
+    isIntersecting: boolean;
+    intersectionRatio: number;
+}
+export interface RootMargin {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+}
+export interface IntersectionObserverOptions {
+    /**
+     * Information about the component that wraps the element
+     */
+    root: Root;
+    rootMargin?: RootMargin;
+    threshold?: number | number[];
+}
+export type IntersectionObserverCallback = (entries: IntersectionObserverEntry[]) => void;
+export declare const defaultRootMargin: RootMargin;
+export declare const defaultThreshold = 0;
+/**
+ * @kind class
+ * @name IntersectionObserver
+ * @description
+ * IntersectionObserver implemented for React Native environment.
+ *
+ * @param {IntersectionObserverCallback} callback - Callback function that is called when the visibility state of the target element changes.
+ * @param {IntersectionObserverOptions} options - Options object that controls the behavior of IntersectionObserver.
+ */
+declare class IntersectionObserver {
+    protected callback: IntersectionObserverCallback;
+    protected options: IntersectionObserverOptions;
+    protected targets: Element[];
+    constructor(callback: IntersectionObserverCallback, options: IntersectionObserverOptions);
+    protected measureTarget: (target: Element) => void;
+    protected handleLayout: () => void;
+    protected handleScroll: () => void;
+    observe(target: Element): void;
+    unobserve(target: Element): void;
+}
+export default IntersectionObserver;

package/dist/intersection-observer/index.d.ts

@@ -0,0 +1,8 @@
+import IOContext from './IOContext';
+import IOFlatList, { type IOFlatListController, type IOFlatListProps } from './IOFlatList';
+import IOScrollView, { type IOScrollViewController, type IOScrollViewProps } from './IOScrollView';
+import InView, { type InViewProps } from './InView';
+import { type IntersectionObserverEntry, type IntersectionObserverOptions, type RootMargin } from './IntersectionObserver';
+import type { IOComponentProps } from './withIO';
+export type { IntersectionObserverEntry, IntersectionObserverOptions, RootMargin, InViewProps, IOComponentProps, IOFlatListController, IOFlatListProps, IOScrollViewController, IOScrollViewProps, };
+export { InView, IOContext, IOFlatList, IOScrollView };

package/dist/intersection-observer/withIO.d.ts

@@ -0,0 +1,20 @@
+import { type ComponentProps } from 'react';
+import { ScrollView } from 'react-native';
+import { RootMargin } from './IntersectionObserver';
+export interface IOComponentProps {
+    rootMargin?: RootMargin;
+}
+/**
+ * @category Functions
+ * @kind function
+ * @name withIO
+ * @description
+ * A Higher-Order Component (HoC) that wraps a component with `IOContext` to enable Intersection Observer functionality.
+ *
+ * @argument
+ * @param {React.ComponentType} [BaseComponent] - Callback function that is called when the component is mounted.
+ * @param {string[]} [methods] - List of event handler names from BaseComponent to be bound.
+ * @returns {React.ComponentType} - Returns a wrapped component that can use Intersection Observer functionality.
+ */
+declare function withIO<CompProps extends Pick<ComponentProps<typeof ScrollView>, 'horizontal' | 'scrollEventThrottle' | 'onContentSizeChange' | 'onLayout' | 'onScroll'>>(BaseComponent: React.ComponentType<CompProps>, methods: string[]): typeof BaseComponent;
+export default withIO;

package/dist/jest/index.d.ts

@@ -0,0 +1 @@
+export { setup, config } from '@granite-js/jest';

package/dist/jest/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/jest/index.ts
+var index_exports = {};
+__export(index_exports, {
+  config: () => import_jest.config,
+  setup: () => import_jest.setup
+});
+module.exports = __toCommonJS(index_exports);
+var import_jest = require("@granite-js/jest");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  config,
+  setup
+});

package/dist/keyboard/KeyboardAboveView.d.ts

@@ -0,0 +1,40 @@
+import { ComponentProps, ReactElement } from 'react';
+import { View } from 'react-native';
+/**
+ * @public
+ * @category UI
+ * @name KeyboardAboveView
+ * @kind function
+ * @description
+ * A component that automatically lifts child components above the keyboard when it appears on the screen.
+ * It's useful when you want to keep elements like a "Send" button fixed above the keyboard during text input.
+ *
+ * @param {StyleProp<ViewStyle>} [props.style] - Additional styles can be applied. For example, you can set background color or size.
+ * @param {ReactNode} [props.children] - Components to be displayed above the keyboard when it appears. For example, you can include buttons, text input fields, etc.
+ * @returns {ReactElement} - Returns an [`Animated.View`](https://reactnative.dev/docs/animated#createanimatedcomponent) that is adjusted above the keyboard when it appears.
+ * @example
+ *
+ * ### Lifting elements above the keyboard
+ *
+ * ```tsx
+ * import { ScrollView, TextInput, View, Text } from 'react-native';
+ * import { KeyboardAboveView } from '@granite-js/react-native';
+ *
+ * export function KeyboardAboveViewExample() {
+ *   return (
+ *     <>
+ *       <ScrollView>
+ *         <TextInput placeholder="placeholder" />
+ *       </ScrollView>
+ *
+ *       <KeyboardAboveView>
+ *         <View style={{ width: '100%', height: 50, backgroundColor: 'yellow' }}>
+ *           <Text>Above the keyboard</Text>
+ *         </View>
+ *       </KeyboardAboveView>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export declare function KeyboardAboveView({ style, children, ...props }: ComponentProps<typeof View>): ReactElement;

package/dist/keyboard/index.d.ts

@@ -0,0 +1 @@
+export { KeyboardAboveView } from './KeyboardAboveView';

package/dist/keyboard/useKeyboardAnimatedHeight.d.ts

@@ -0,0 +1,20 @@
+import { Animated } from 'react-native';
+/**
+ * @category Hooks
+ * @name useKeyboardAnimatedHeight
+ * @description
+ * A Hook that returns an animatable value (`Animated.Value`) representing the keyboard height changes when the keyboard appears or disappears. You can smoothly animate UI elements according to the keyboard height as it rises or falls.
+ *
+ * This Hook is primarily used on iOS. On Android, it does not detect keyboard height changes and always returns an `Animated.Value` with an initial value of `0`. In other words, animations are not applied in the Android environment.
+ *
+ * @returns {Animated.Value} - An animation value representing the keyboard height.
+ * @example
+ * ```typescript
+ * const keyboardHeight = useKeyboardAnimatedHeight();
+ *
+ * <Animated.View style={{ marginBottom: keyboardHeight }}>
+ *  {children}
+ * </Animated.View>
+ * ```
+ */
+export declare function useKeyboardAnimatedHeight(): Animated.Value;

package/dist/native-event-emitter/eventEmitters/index.d.ts

@@ -0,0 +1,2 @@
+import { VisibilityChangedEventEmitter } from './visibilityChanged';
+export type EventEmitters = VisibilityChangedEventEmitter;

package/dist/native-event-emitter/eventEmitters/types.d.ts

@@ -0,0 +1,4 @@
+export interface EventEmitterSchema<K extends string, P extends unknown[]> {
+    name: K;
+    params: P;
+}

package/dist/native-event-emitter/eventEmitters/visibilityChanged.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitterSchema } from './types';
+/**
+ * @name VisibilityChangedEventEmitter
+ * @kind typedef
+ * @platform iOS
+ * @description
+ * Emits an event when the visibility state of the app changes.
+ * Only available on iOS.
+ */
+export type VisibilityChangedEventEmitter = EventEmitterSchema<'visibilityChanged', [boolean]>;

package/dist/native-event-emitter/index.d.ts

@@ -0,0 +1 @@
+export * from './nativeEventEmitter';

package/dist/native-event-emitter/nativeEventEmitter.d.ts

@@ -0,0 +1,15 @@
+import { EmitterSubscription } from 'react-native';
+import { EventEmitters } from './eventEmitters';
+import { EventEmitterSchema } from './eventEmitters/types';
+type MapOf<T> = T extends EventEmitterSchema<infer K, any> ? {
+    [key in K]: T;
+} : never;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type EventEmittersMap = UnionToIntersection<MapOf<EventEmitters>>;
+type EventKeys = keyof EventEmittersMap;
+type ParamOf<K extends EventKeys> = EventEmittersMap[K]['params'];
+interface EventEmitter {
+    addListener<Event extends EventKeys>(event: Event, callback: (...params: ParamOf<Event>) => void): EmitterSubscription;
+}
+export declare const nativeEventEmitter: EventEmitter;
+export {};

package/dist/native-modules/core/GraniteCoreModule.d.ts

@@ -0,0 +1,8 @@
+import { TurboModule } from 'react-native';
+interface GraniteCoreModule extends TurboModule {
+    addListener: (eventType: string) => void;
+    removeListeners: (count: number) => void;
+    importLazy: () => Promise<void>;
+}
+export declare const GraniteCoreModule: GraniteCoreModule;
+export {};

package/dist/native-modules/index.d.ts

@@ -0,0 +1,3 @@
+/** Bridges API */
+export * from './natives';
+export { GraniteCoreModule } from './core/GraniteCoreModule';

package/dist/native-modules/natives/GraniteModule.d.ts

@@ -0,0 +1,7 @@
+import { TurboModule } from 'react-native';
+interface GraniteModuleSpec extends TurboModule {
+    closeView: () => void;
+    schemeUri: string;
+}
+export declare const GraniteModule: GraniteModuleSpec;
+export {};

package/dist/native-modules/natives/closeView.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @public
+ * @category Screen Control
+ * @kind function
+ * @name closeView
+ * @description Function that closes the current screen. It can be used when you want to exit a service by pressing a "Close" button.
+ * @returns {Promise<void>}
+ *
+ * @example
+ * ### Close screen with close button
+ *
+ * ```tsx
+ * import { Button } from 'react-native';
+ * import { closeView } from '@granite-js/react-native';
+ *
+ * function CloseButton() {
+ *  return <Button title="Close" onPress={closeView} />;
+ * }
+ * ```
+ */
+export declare function closeView(): Promise<void>;

package/dist/native-modules/natives/getSchemeUri.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @public
+ * @name getSchemeUri
+ * @category Environment Check
+ * @kind function
+ * @description Returns the scheme value when first entering the screen. URI changes due to page navigation are not reflected.
+ * @returns {string} Returns the scheme value when first entering the screen.
+ *
+ * @example
+ * ### Get initial scheme value
+ *
+ * ```tsx
+ * import { getSchemeUri } from '@granite-js/react-native';
+ * import { Text } from 'react-native';
+ *
+ * function MyPage() {
+ *  const schemeUri = getSchemeUri();
+ *
+ *  return <Text>Initial scheme value: {schemeUri}</Text>
+ * }
+ * ```
+ */
+export declare function getSchemeUri(): string;

package/dist/native-modules/natives/index.d.ts

@@ -0,0 +1,3 @@
+export * from './closeView';
+export * from './getSchemeUri';
+export * from './openURL';

package/dist/native-modules/natives/openURL.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @public
+ * @kind function
+ * @category Screen Navigation
+ *
+ * @name openURL
+ * @signature
+ * ```typescript
+ * function openURL(url: string): Promise<any>;
+ * ```
+ *
+ * @description
+ * Opens the specified URL in the device's default browser or related app.
+ * This function uses the [`Linking.openURL`](https://reactnative.dev/docs/0.72/linking#openurl) method from `react-native` to open the URL.
+ *
+ * @param {string} url URL address to open
+ * @returns {Promise<any>} Promise that resolves when the URL is successfully opened
+ *
+ * @example
+ *
+ * ### Open external URL
+ *
+ * ```tsx
+ * import { openURL } from '@granite-js/react-native';
+ * import { Button } from 'react-native';
+ *
+ * function Page() {
+ *   const handlePress = () => {
+ *     openURL('https://google.com');
+ *   };
+ *
+ *   return <Button title="Open Google Website" onPress={handlePress} />;
+ * }
+ * ```
+ */
+export declare function openURL(url: string): Promise<any>;

package/dist/react/index.d.ts

@@ -0,0 +1 @@
+export { useWaitForReturnNavigator } from './useWaitForReturnNavigator';

package/dist/react/useWaitForReturnNavigator.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @public
+ * @category Screen Control
+ * @name useWaitForReturnNavigator
+ * @description
+ * A Hook that helps execute the next code synchronously when returning from a screen transition.
+ * Screen navigation uses [@react-navigation/native `useNavigation`'s `navigate`](https://reactnavigation.org/docs/6.x/navigation-prop#navigate).
+ *
+ * For example, it can be used when you want to log that a user has navigated to another screen and returned.
+ *
+ * @example
+ * ### Example of code execution when returning from screen navigation
+ *
+ * When the **"Navigate"** button is pressed, it navigates to another screen, and logs are created when returning.
+ *
+ * ```tsx
+ * import { Button } from 'react-native';
+ * import { useWaitForReturnNavigator } from '@granite-js/react-native';
+ *
+ * export function UseWaitForReturnNavigator() {
+ *   const navigate = useWaitForReturnNavigator();
+ *
+ *   return (
+ *     <>
+ *       <Button
+ *         title="Navigate"
+ *         onPress={async () => {
+ *           console.log(1);
+ *           await navigate('/examples/use-visibility');
+ *           // This code executes when returning to the screen
+ *           console.log(2);
+ *         }}
+ *       />
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export declare function useWaitForReturnNavigator<T extends Record<string, object | undefined>>(): <RouteName extends keyof T>(route: RouteName, params?: T[RouteName]) => Promise<void>;

package/dist/rn-polyfills/index.d.ts

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

package/dist/rn-polyfills/symbol-asynciterator/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Polyfill for @swc/helpers build compatibility
+ *
+ * @see https://github.com/swc-project/swc/blob/v1.4.15/packages/helpers/esm/_async_iterator.js#L3
+ *
+ * - babel: No runtime issues after build as there is a fallback for `Symbol.asyncIterator`
+ * - swc: No fallback for `Symbol.asyncIterator`, so it needs to be defined in advance
+ */
+export declare function setup(): void;

package/dist/rn-polyfills/url/index.d.ts

@@ -0,0 +1 @@
+export { setupURLPolyfill as setup } from 'react-native-url-polyfill';

package/dist/router/Router.d.ts

@@ -0,0 +1,59 @@
+import { NavigationContainer, NavigationContainerRefWithCurrent, ParamListBase, RouteProp } from '@granite-js/native/@react-navigation/native';
+import { NativeStackNavigationOptions } from '@granite-js/native/@react-navigation/native-stack';
+import { ComponentProps, ComponentType, PropsWithChildren, ReactElement } from 'react';
+export type RouterProps = StackNavigatorProps & NavigationContainerProps;
+interface StackNavigatorProps {
+    /**
+     * @name navigationContainerRef
+     * @description
+     * You can create and pass a NavigationContainerRef from @react-navigation/native externally. This allows external control of the router.
+     */
+    navigationContainerRef?: NavigationContainerRefWithCurrent<any>;
+    /**
+     * @name defaultScreenOption
+     * @description
+     * Default options for screens. You can set options to be applied commonly to screens, such as title or headerStyle.
+     */
+    defaultScreenOption?: NativeStackNavigationOptions | ((props: {
+        route: RouteProp<ParamListBase>;
+        navigation: any;
+    }) => NativeStackNavigationOptions);
+    /**
+     * @name screenContainer
+     * @description
+     * Container component that wraps each Screen component.
+     */
+    screenContainer?: ComponentType<PropsWithChildren<any>>;
+}
+type NavigationContainerProps = Pick<ComponentProps<typeof NavigationContainer>, 'ref' | 'documentTitle' | 'fallback' | 'onReady' | 'onUnhandledAction' | 'onStateChange'>;
+/**
+ * @category Components
+ * @kind function
+ * @name Router
+ * @description
+ * Router component for page navigation in React Native environment.
+ * Automatically assigns appropriate paths to screens based on file naming rules in pages/*.
+ * Using this component, you can manage screens in a way similar to Next.js's file-based routing.
+ *
+ * @param {string} prefix Prefix to use when the scheme is executed. For example, to enter 'scheme://my-service/intro', you need to set 'scheme://my-service' as the prefix.
+ * @param {RequireContext} context Object containing information about screens for file-based routing.
+ * @param {NavigationContainerRefWithCurrent<any>} [navigationContainerRef] You can create and pass a NavigationContainerRef from @react-navigation/native externally. This allows external control of the router.
+ * @param {NativeStackNavigationOptions | ((props: { route: RouteProp<ParamListBase>; navigation: any }) => NativeStackNavigationOptions)} [defaultScreenOption] Default options for screens. You can set options to be applied commonly to screens, such as title or headerStyle.
+ * @param {boolean} [canGoBack=true] Whether navigation back is possible. Default is true, and when set to true, you can use the back gesture or back button from @react-navigation/native.
+ * @param {() => void} [onBack] Callback function called when the user presses the back button or uses the back gesture. For example, you can set it to log when the user presses the back button.
+ * @param {ComponentType<{ children: ReactNode }>} [container=Fragment] Container component that wraps the Navigator from @react-navigation/native.
+ * @param {NavigationContainerProps} [navigationContainerProps] - You can set props to be passed to NavigationContainer from @react-navigation/native.
+ *
+ * @returns {ReactElement} - Returns the router component.
+ * @example
+ * ```tsx
+ * import { Router } from '@granite-js/react-native';
+ * import { context } from '../require.context';
+ *
+ * function App() {
+ *  return <Router context={context} prefix={'scheme://testbench'} />;
+ * }
+ * ```
+ */
+export declare function Router({ prefix, context, canGoBack, onBack, container: Container, initialProps, navigationContainerRef, defaultScreenOption, screenContainer, ...navigationContainerProps }: InternalRouterProps & RouterProps): ReactElement;
+export {};

package/dist/router/components/BackButton.d.ts

@@ -0,0 +1,7 @@
+import { TouchableOpacityProps } from 'react-native';
+interface BackButtonProps extends TouchableOpacityProps {
+    tintColor?: string;
+    onPress?: () => void;
+}
+declare function BackButton({ tintColor, onPress }: BackButtonProps): import("react/jsx-runtime").JSX.Element;
+export { BackButton };

package/dist/router/components/CanGoBackGuard.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+export declare function CanGoBackGuard({ children, canGoBack, onBack, }: {
+    canGoBack: boolean;
+    children: ReactNode;
+    onBack?: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/router/components/RouterBackButton.d.ts

@@ -0,0 +1,9 @@
+import { NavigationContainerRefWithCurrent } from '@granite-js/native/@react-navigation/native';
+export type RouterBackButtonProps = {
+    onPress?: () => void;
+    tintColor?: string;
+    canGoBack?: boolean;
+    onBack?: () => void;
+    navigationContainerRef: NavigationContainerRefWithCurrent<any>;
+};
+export declare function RouterBackButton({ tintColor, canGoBack, onBack, navigationContainerRef }: RouterBackButtonProps): import("react/jsx-runtime").JSX.Element;

package/dist/router/components/StackNavigator.d.ts

@@ -0,0 +1,54 @@
+export declare const StackNavigator: {
+    Navigator: import("react").ComponentType<Omit<import("@react-navigation/routers").DefaultRouterOptions<string> & {
+        id?: string;
+        children: React.ReactNode;
+        screenListeners?: Partial<{
+            transitionStart: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "transitionStart">;
+            transitionEnd: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "transitionEnd">;
+            focus: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "focus">;
+            blur: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "blur">;
+            state: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "state">;
+            beforeRemove: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "beforeRemove">;
+        }> | ((props: {
+            route: import("@react-navigation/core").RouteProp<import("@react-navigation/routers").ParamListBase, string>;
+            navigation: any;
+        }) => Partial<{
+            transitionStart: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "transitionStart">;
+            transitionEnd: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "transitionEnd">;
+            focus: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "focus">;
+            blur: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "blur">;
+            state: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "state">;
+            beforeRemove: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "beforeRemove">;
+        }>) | undefined;
+        screenOptions?: import("@react-navigation/native-stack").NativeStackNavigationOptions | ((props: {
+            route: import("@react-navigation/core").RouteProp<import("@react-navigation/routers").ParamListBase, string>;
+            navigation: any;
+        }) => import("@react-navigation/native-stack").NativeStackNavigationOptions) | undefined;
+    } & import("@react-navigation/routers").StackRouterOptions, "children" | "id" | "initialRouteName" | "screenListeners" | "screenOptions"> & import("@react-navigation/routers").DefaultRouterOptions<string> & {
+        id?: string;
+        children: React.ReactNode;
+        screenListeners?: Partial<{
+            transitionStart: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "transitionStart">;
+            transitionEnd: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "transitionEnd">;
+            focus: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "focus">;
+            blur: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "blur">;
+            state: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "state">;
+            beforeRemove: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "beforeRemove">;
+        }> | ((props: {
+            route: import("@react-navigation/core").RouteProp<import("@react-navigation/routers").ParamListBase, string>;
+            navigation: any;
+        }) => Partial<{
+            transitionStart: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "transitionStart">;
+            transitionEnd: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "transitionEnd">;
+            focus: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "focus">;
+            blur: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "blur">;
+            state: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "state">;
+            beforeRemove: import("@react-navigation/core").EventListenerCallback<import("@react-navigation/native-stack").NativeStackNavigationEventMap & import("@react-navigation/core").EventMapCore<import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>>, "beforeRemove">;
+        }>) | undefined;
+        screenOptions?: import("@react-navigation/native-stack").NativeStackNavigationOptions | ((props: {
+            route: import("@react-navigation/core").RouteProp<import("@react-navigation/routers").ParamListBase, string>;
+            navigation: any;
+        }) => import("@react-navigation/native-stack").NativeStackNavigationOptions) | undefined;
+    }>;
+    Screen: <RouteName extends string>(_: import("@react-navigation/core").RouteConfig<import("@react-navigation/routers").ParamListBase, RouteName, import("@react-navigation/routers").StackNavigationState<import("@react-navigation/routers").ParamListBase>, import("@react-navigation/native-stack").NativeStackNavigationOptions, import("@react-navigation/native-stack").NativeStackNavigationEventMap>) => null;
+};

package/dist/router/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const RESERVED_KEYWORDS: string[];
+export declare const RESERVED_PATHS: string[];

package/dist/router/createRoute.d.ts

@@ -0,0 +1,39 @@
+import { type ParamListBase } from '@granite-js/native/@react-navigation/native';
+import { NativeStackNavigationProp } from '@granite-js/native/@react-navigation/native-stack';
+import { defaultParserParams } from './utils/defaultParserParams';
+export interface RouteOptions<T extends Readonly<object | undefined>> {
+    parserParams?: (params: Record<string, unknown>) => Record<string, unknown>;
+    validateParams?: (params: Readonly<object | undefined>) => T;
+    component: React.FC<any>;
+}
+export type NavigationProps = NativeStackNavigationProp<keyof RegisterScreen extends never ? ParamListBase : RegisterScreen>;
+export interface RegisterScreen {
+}
+export declare function useNavigation(): NavigationProps;
+export type RouteHooksOptions<TScreen extends keyof RegisterScreen> = {
+    from: TScreen;
+    strict?: true;
+} | {
+    strict: false;
+    from?: never;
+};
+export declare const routeMap: Map<"/test", {
+    options: Omit<RouteOptions<any>, "component">;
+    component: React.FC<any>;
+}>;
+export declare function useMatchOptions<TScreen extends keyof RegisterScreen>(options: RouteHooksOptions<TScreen>): {
+    parserParams: ((params: Record<string, unknown>) => Record<string, unknown>) | typeof defaultParserParams;
+    validateParams?: ((params: Readonly<object | undefined>) => any) | undefined;
+} | null;
+export declare function useParams<TScreen extends keyof RegisterScreen>(options: {
+    from: TScreen;
+    strict?: true;
+}): RegisterScreen[TScreen];
+export declare function useParams(options: {
+    strict: false;
+}): Readonly<object | undefined>;
+export declare const createRoute: <T extends Readonly<object | undefined>>(path: keyof RegisterScreen, options: RouteOptions<T>) => {
+    _path: "/test";
+    useNavigation: typeof useNavigation;
+    useParams: () => T;
+};

package/dist/router/createRoute.test-d.d.ts

@@ -0,0 +1,9 @@
+declare module './createRoute' {
+    interface RegisterScreen {
+        '/test': {
+            id: string;
+            name: string;
+        };
+    }
+}
+export {};

package/dist/router/hooks/useInitialRouteName.d.ts

@@ -0,0 +1 @@
+export declare function useInitialRouteName(prefix: string): string | undefined;

package/dist/router/hooks/useIsInitialScreen.d.ts

@@ -0,0 +1 @@
+export declare function useIsInitialScreen(): boolean;