expo-router 1.2.2 → 1.3.0

package/build/primitives.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+export declare const Screen: <RouteName extends string>(_: import("@react-navigation/core").RouteConfig<import("@react-navigation/core").ParamListBase, RouteName, Readonly<{
+    key: string;
+    index: number;
+    routeNames: string[];
+    history?: unknown[] | undefined;
+    routes: (Readonly<{
+        key: string;
+        name: string;
+        path?: string | undefined;
+    }> & Readonly<{
+        params?: Readonly<object | undefined>;
+    }> & {
+        state?: Readonly<any> | import("@react-navigation/core").PartialState<Readonly<any>> | undefined;
+    })[];
+    type: string;
+    stale: false;
+}>, {}, import("@react-navigation/core").EventMapBase>) => null, Group: import("react").ComponentType<import("@react-navigation/core").RouteGroupConfig<import("@react-navigation/core").ParamListBase, {}>>;
+//# sourceMappingURL=primitives.d.ts.map

package/build/primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../src/primitives.tsx"],"names":[],"mappings":";AAIA,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;iEAAE,KAAK,sIAAwC,CAAC"}

package/build/renderRootComponent.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+/**
+ * Register and mount the root component using the predefined rendering
+ * method. This function ensures the Splash Screen and errors are handled correctly.
+ */
+export declare function renderRootComponent(Component: React.ComponentType<any>): void;
+//# sourceMappingURL=renderRootComponent.d.ts.map

package/build/renderRootComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderRootComponent.d.ts","sourceRoot":"","sources":["../src/renderRootComponent.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAgD1B;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,QA+BtE"}

package/build/static/renderStaticContent.d.ts

@@ -0,0 +1,8 @@
+import { getManifest } from "expo-router/_root";
+import React from "react";
+export declare function getStaticContent(location: URL): string;
+export declare function Root({ children }: {
+    children: React.ReactNode;
+}): JSX.Element;
+export { getManifest };
+//# sourceMappingURL=renderStaticContent.d.ts.map

package/build/static/renderStaticContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderStaticContent.d.ts","sourceRoot":"","sources":["../../src/static/renderStaticContent.tsx"],"names":[],"mappings":"AAOA,OAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,MAAM,OAAO,CAAC;AAQ1B,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,GAAG,GAAG,MAAM,CA2CtD;AA2DD,wBAAgB,IAAI,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,eAe/D;AAGD,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/build/static/useServerState.d.ts

@@ -0,0 +1,42 @@
+export declare function useServerState(): (Partial<Omit<Readonly<{
+    key: string;
+    index: number;
+    routeNames: string[];
+    history?: unknown[] | undefined;
+    routes: (Readonly<{
+        key: string;
+        name: string;
+        path?: string | undefined;
+    }> & Readonly<{
+        params?: Readonly<object | undefined>;
+    }> & {
+        state?: Readonly<any> | import("@react-navigation/routers").PartialState<Readonly<any>> | undefined;
+    })[];
+    type: string;
+    stale: false;
+}>, "stale" | "routes">> & Readonly<{
+    stale?: true | undefined;
+    routes: import("@react-navigation/routers").PartialRoute<import("@react-navigation/routers").Route<string, object | undefined>>[];
+}> & {
+    state?: (Partial<Omit<Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[] | undefined;
+        routes: (Readonly<{
+            key: string;
+            name: string;
+            path?: string | undefined;
+        }> & Readonly<{
+            params?: Readonly<object | undefined>;
+        }> & {
+            state?: Readonly<any> | import("@react-navigation/routers").PartialState<Readonly<any>> | undefined;
+        })[];
+        type: string;
+        stale: false;
+    }>, "stale" | "routes">> & Readonly<{
+        stale?: true | undefined;
+        routes: import("@react-navigation/routers").PartialRoute<import("@react-navigation/routers").Route<string, object | undefined>>[];
+    }> & any) | undefined;
+}) | null | undefined;
+//# sourceMappingURL=useServerState.d.ts.map

package/build/static/useServerState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useServerState.d.ts","sourceRoot":"","sources":["../../src/static/useServerState.ts"],"names":[],"mappings":"AAQA,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAmB7B"}

package/build/static/useServerState.native.d.ts

@@ -0,0 +1,2 @@
+export declare function useServerState(): null;
+//# sourceMappingURL=useServerState.native.d.ts.map

package/build/static/useServerState.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useServerState.native.d.ts","sourceRoot":"","sources":["../../src/static/useServerState.native.ts"],"names":[],"mappings":"AAAA,wBAAgB,cAAc,SAG7B"}

package/build/types.d.ts

@@ -0,0 +1,13 @@
+export interface RequireContext {
+    /** Return the keys that can be resolved. */
+    keys(): string[];
+    (id: string): any;
+    <T>(id: string): T;
+    /** **Unimplemented:** Return the module identifier for a user request. */
+    resolve(id: string): string;
+    /** **Unimplemented:** Readable identifier for the context module. */
+    id: string;
+}
+/** The list of input keys will become optional, everything else will remain the same. */
+export type PickPartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+//# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,cAAc;IAC7B,4CAA4C;IAC5C,IAAI,IAAI,MAAM,EAAE,CAAC;IACjB,CAAC,EAAE,EAAE,MAAM,GAAG,GAAG,CAAC;IAClB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,CAAC,CAAC;IACnB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5B,qEAAqE;IACrE,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,yFAAyF;AACzF,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GACxD,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC"}

package/build/useFocusEffect.d.ts

@@ -0,0 +1,11 @@
+type EffectCallback = () => undefined | void | (() => void);
+/**
+ * Hook to run an effect in a focused screen, similar to `React.useEffect`.
+ * This can be used to perform side-effects such as fetching data or subscribing to events.
+ * The passed callback should be wrapped in `React.useCallback` to avoid running the effect too often.
+ *
+ * @param callback Memoized callback containing the effect, should optionally return a cleanup function.
+ */
+export declare function useFocusEffect(effect: EffectCallback, do_not_pass_a_second_prop?: never): void;
+export {};
+//# sourceMappingURL=useFocusEffect.d.ts.map

package/build/useFocusEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFocusEffect.d.ts","sourceRoot":"","sources":["../src/useFocusEffect.tsx"],"names":[],"mappings":"AAMA,KAAK,cAAc,GAAG,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC;AAE5D;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,cAAc,EACtB,yBAAyB,CAAC,EAAE,KAAK,QAuGlC"}

package/build/useInitialRootState.d.ts

@@ -0,0 +1,42 @@
+export declare function useInitialRootState(): (Partial<Omit<Readonly<{
+    key: string;
+    index: number;
+    routeNames: string[];
+    history?: unknown[] | undefined;
+    routes: (Readonly<{
+        key: string;
+        name: string;
+        path?: string | undefined;
+    }> & Readonly<{
+        params?: Readonly<object | undefined>;
+    }> & {
+        state?: Readonly<any> | import("@react-navigation/routers").PartialState<Readonly<any>> | undefined;
+    })[];
+    type: string;
+    stale: false;
+}>, "stale" | "routes">> & Readonly<{
+    stale?: true | undefined;
+    routes: import("@react-navigation/routers").PartialRoute<import("@react-navigation/routers").Route<string, object | undefined>>[];
+}> & {
+    state?: (Partial<Omit<Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[] | undefined;
+        routes: (Readonly<{
+            key: string;
+            name: string;
+            path?: string | undefined;
+        }> & Readonly<{
+            params?: Readonly<object | undefined>;
+        }> & {
+            state?: Readonly<any> | import("@react-navigation/routers").PartialState<Readonly<any>> | undefined;
+        })[];
+        type: string;
+        stale: false;
+    }>, "stale" | "routes">> & Readonly<{
+        stale?: true | undefined;
+        routes: import("@react-navigation/routers").PartialRoute<import("@react-navigation/routers").Route<string, object | undefined>>[];
+    }> & any) | undefined;
+}) | null | undefined;
+//# sourceMappingURL=useInitialRootState.d.ts.map

package/build/useInitialRootState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInitialRootState.d.ts","sourceRoot":"","sources":["../src/useInitialRootState.tsx"],"names":[],"mappings":"AAGA,wBAAgB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAYlC"}

package/build/useInitialRootState.native.d.ts

@@ -0,0 +1,3 @@
+import { State } from "./fork/getPathFromState";
+export declare function useInitialRootState(): State | null;
+//# sourceMappingURL=useInitialRootState.native.d.ts.map

package/build/useInitialRootState.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInitialRootState.native.d.ts","sourceRoot":"","sources":["../src/useInitialRootState.native.tsx"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAehD,wBAAgB,mBAAmB,iBAgBlC"}

package/build/useInitialRootStateContext.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+import { State } from "./fork/getPathFromState";
+export declare const InitialRootStateContext: React.Context<State | null>;
+/** Fetch the initial root navigation state instantly on web and slightly delayed on native. */
+export declare function useInitialRootStateContext(): State;
+/**
+ * Unlike React Navigation, we statically know the config and always assume a URL is available.
+ * This enables us to always know the root state.
+ */
+export declare function InitialRootStateProvider({ children, }: {
+    children: React.ReactNode;
+}): JSX.Element | null;
+//# sourceMappingURL=useInitialRootStateContext.d.ts.map

package/build/useInitialRootStateContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInitialRootStateContext.d.ts","sourceRoot":"","sources":["../src/useInitialRootStateContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoC,MAAM,OAAO,CAAC;AAEzD,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAGhD,eAAO,MAAM,uBAAuB,6BAAoC,CAAC;AAMzE,+FAA+F;AAC/F,wBAAgB,0BAA0B,UAQzC;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,EACvC,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,sBAeA"}

package/build/useNavigation.d.ts

@@ -0,0 +1,9 @@
+import { NavigationProp } from "@react-navigation/native";
+/**
+ * Return the navigation object for the current route.
+ * @param parent Provide an absolute path like `/(root)` to the parent route or a relative path like `../../` to the parent route.
+ * @returns the navigation object for the provided route.
+ */
+export declare function useNavigation(parent?: string): NavigationProp<ReactNavigation.RootParamList>;
+export declare function resolveParentId(contextKey: string, parentId?: string | null): string | null;
+//# sourceMappingURL=useNavigation.d.ts.map

package/build/useNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNavigation.d.ts","sourceRoot":"","sources":["../src/useNavigation.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,cAAc,EACf,MAAM,0BAA0B,CAAC;AAMlC;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,MAAM,CAAC,EAAE,MAAM,GACd,cAAc,CAAC,eAAe,CAAC,aAAa,CAAC,CAgC/C;AAED,wBAAgB,eAAe,CAC7B,UAAU,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GACvB,MAAM,GAAG,IAAI,CASf"}

package/build/useRootNavigation.d.ts

@@ -0,0 +1,9 @@
+import { NavigationContainerRefWithCurrent } from "@react-navigation/native";
+import React from "react";
+import { State } from "./fork/getPathFromState";
+export declare const RootNavigationRef: React.Context<{
+    ref: NavigationContainerRefWithCurrent<ReactNavigation.RootParamList> | null;
+}>;
+export declare function useRootNavigation(): NavigationContainerRefWithCurrent<ReactNavigation.RootParamList> | null;
+export declare function useRootNavigationState(): State | undefined;
+//# sourceMappingURL=useRootNavigation.d.ts.map

package/build/useRootNavigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRootNavigation.d.ts","sourceRoot":"","sources":["../src/useRootNavigation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iCAAiC,EAAE,MAAM,0BAA0B,CAAC;AAC7E,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAEhD,eAAO,MAAM,iBAAiB;SACvB,kCAAkC,gBAAgB,aAAa,CAAC,GAAG,IAAI;EAC7D,CAAC;AAMlB,wBAAgB,iBAAiB,4EAQhC;AAED,wBAAgB,sBAAsB,IAAI,KAAK,GAAG,SAAS,CAkB1D"}

package/build/useRootRouteNodeContext.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import { RouteNode } from "./Route";
+import { RequireContext } from "./types";
+export declare const RootRouteNodeContext: React.Context<RouteNode | null>;
+export declare function useRootRouteNodeContext(): RouteNode;
+/** Provide the require context as normalized routes. */
+export declare function RootRouteNodeProvider({ context, children, }: {
+    context: RequireContext;
+    children: React.ReactNode;
+}): JSX.Element;
+//# sourceMappingURL=useRootRouteNodeContext.d.ts.map

package/build/useRootRouteNodeContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRootRouteNodeContext.d.ts","sourceRoot":"","sources":["../src/useRootRouteNodeContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA6C,MAAM,OAAO,CAAC;AAElE,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpC,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAGzC,eAAO,MAAM,oBAAoB,iCAAwC,CAAC;AAM1E,wBAAgB,uBAAuB,cAQtC;AAED,wDAAwD;AACxD,wBAAgB,qBAAqB,CAAC,EACpC,OAAO,EACP,QAAQ,GACT,EAAE;IACD,OAAO,EAAE,cAAc,CAAC;IACxB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B,eASA"}

package/build/useScreens.d.ts

@@ -0,0 +1,27 @@
+import React from "react";
+import { RouteNode } from "./Route";
+export type ScreenProps<TOptions extends Record<string, any> = Record<string, any>> = {
+    /** Name is required when used inside a Layout component. */
+    name?: string;
+    /**
+     * Redirect to the nearest sibling route.
+     * If all children are redirect={true}, the layout will render `null` as there are no children to render.
+     */
+    redirect?: boolean;
+    initialParams?: {
+        [key: string]: any;
+    };
+    options?: TOptions;
+    listeners?: any;
+};
+/**
+ * @returns React Navigation screens sorted by the `route` property.
+ */
+export declare function useSortedScreens(order: ScreenProps[]): React.ReactNode[];
+/** Wrap the component with various enhancements and add access to child routes. */
+export declare function getQualifiedRouteComponent(value: RouteNode): React.ComponentType<any> | React.ForwardRefExoticComponent<Pick<any, string | number | symbol> & React.RefAttributes<unknown>>;
+/** @returns a function which provides a screen id that matches the dynamic route name in params. */
+export declare function createGetIdForRoute(route: Pick<RouteNode, "dynamic" | "route">): (({ params }: {
+    params?: Record<string, any> | undefined;
+}) => string | undefined) | undefined;
+//# sourceMappingURL=useScreens.d.ts.map

package/build/useScreens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useScreens.d.ts","sourceRoot":"","sources":["../src/useScreens.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,EAGL,SAAS,EAGV,MAAM,SAAS,CAAC;AAIjB,MAAM,MAAM,WAAW,CACrB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IACxD;IACF,4DAA4D;IAC5D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,aAAa,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC;IACvC,OAAO,CAAC,EAAE,QAAQ,CAAC;IAGnB,SAAS,CAAC,EAAE,GAAG,CAAC;CACjB,CAAC;AA8DF;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,KAAK,CAAC,SAAS,EAAE,CAUxE;AAMD,mFAAmF;AACnF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,SAAS,kIAgD1D;AAED,oGAAoG;AACpG,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC;;sCA0B5C"}

package/build/utils/mockState.d.ts

@@ -0,0 +1,11 @@
+import { RequireContext } from "../types";
+export declare function createMockContextModule(map?: Record<string, Record<string, any>>): RequireContext;
+export declare function configFromFs(map?: (string | [string, object])[]): {
+    initialRouteName?: string | undefined;
+    screens: Record<string, string | {
+        path: string;
+        screens: Record<string, string | any>;
+        initialRouteName?: string | undefined;
+    }>;
+};
+//# sourceMappingURL=mockState.d.ts.map

package/build/utils/mockState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mockState.d.ts","sourceRoot":"","sources":["../../src/utils/mockState.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE1C,wBAAgB,uBAAuB,CACrC,GAAG,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAM,kBAS9C;AAED,wBAAgB,YAAY,CAAC,GAAG,GAAE,CAAC,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAO;;;;;;;EAcnE"}

package/build/views/ErrorBoundary.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { ErrorBoundaryProps } from "./Try";
+export declare function ErrorBoundary({ error, retry }: ErrorBoundaryProps): JSX.Element;
+//# sourceMappingURL=ErrorBoundary.d.ts.map

package/build/views/ErrorBoundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorBoundary.d.ts","sourceRoot":"","sources":["../../src/views/ErrorBoundary.tsx"],"names":[],"mappings":";AAKA,OAAO,EAAE,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAG3C,wBAAgB,aAAa,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,kBAAkB,eAkEjE"}

package/build/views/Navigator.d.ts

@@ -0,0 +1,280 @@
+import { RouterFactory, useNavigationBuilder } from "@react-navigation/native";
+import * as React from "react";
+type NavigatorTypes = ReturnType<typeof useNavigationBuilder>;
+export declare const NavigatorContext: React.Context<{
+    contextKey: string;
+    state: NavigatorTypes["state"];
+    navigation: NavigatorTypes["navigation"];
+    descriptors: NavigatorTypes["descriptors"];
+    router: RouterFactory<any, any, any>;
+} | null>;
+export type NavigatorProps = {
+    initialRouteName?: Parameters<typeof useNavigationBuilder>[1]["initialRouteName"];
+    screenOptions?: Parameters<typeof useNavigationBuilder>[1]["screenOptions"];
+    children?: Parameters<typeof useNavigationBuilder>[1]["children"];
+    router?: Parameters<typeof useNavigationBuilder>[0];
+};
+/** An unstyled custom navigator. Good for basic web layouts */
+export declare function Navigator({ initialRouteName, screenOptions, children, router, }: NavigatorProps): JSX.Element | null;
+export declare namespace Navigator {
+    var Slot: typeof import("./Navigator").Slot;
+    var useContext: typeof useNavigatorContext;
+    var Screen: typeof import("./Screen").Screen;
+}
+export declare function useNavigatorContext(): {
+    contextKey: string;
+    state: Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[] | undefined;
+        routes: (Readonly<{
+            key: string;
+            name: string;
+            path?: string | undefined;
+        }> & Readonly<{
+            params?: Readonly<object | undefined>;
+        }> & {
+            state?: Readonly<any> | import("@react-navigation/native").PartialState<Readonly<any>> | undefined;
+        })[];
+        type: string;
+        stale: false;
+    }>;
+    navigation: {
+        dispatch(action: Readonly<{
+            type: string;
+            payload?: object | undefined;
+            source?: string | undefined;
+            target?: string | undefined;
+        }> | ((state: Readonly<{
+            key: string;
+            index: number;
+            routeNames: string[];
+            history?: unknown[] | undefined;
+            routes: (Readonly<{
+                key: string;
+                name: string;
+                path?: string | undefined;
+            }> & Readonly<{
+                params?: Readonly<object | undefined>;
+            }> & {
+                state?: Readonly<any> | import("@react-navigation/native").PartialState<Readonly<any>> | undefined;
+            })[];
+            type: string;
+            stale: false;
+        }>) => Readonly<{
+            type: string;
+            payload?: object | undefined;
+            source?: string | undefined;
+            target?: string | undefined;
+        }>)): void;
+        navigate<RouteName extends string>(...args: RouteName extends unknown ? [screen: RouteName] | [screen: RouteName, params: object | undefined] : never): void;
+        navigate<RouteName_1 extends string>(options: RouteName_1 extends unknown ? {
+            key: string;
+            params?: object | undefined;
+            merge?: boolean | undefined;
+        } | {
+            name: RouteName_1;
+            key?: string | undefined;
+            params: object | undefined;
+            merge?: boolean | undefined;
+        } : never): void;
+        reset(state: Readonly<{
+            key: string;
+            index: number;
+            routeNames: string[];
+            history?: unknown[] | undefined;
+            routes: (Readonly<{
+                key: string;
+                name: string;
+                path?: string | undefined;
+            }> & Readonly<{
+                params?: Readonly<object | undefined>;
+            }> & {
+                state?: Readonly<any> | import("@react-navigation/native").PartialState<Readonly<any>> | undefined;
+            })[];
+            type: string;
+            stale: false;
+        }> | import("@react-navigation/native").PartialState<Readonly<{
+            key: string;
+            index: number;
+            routeNames: string[];
+            history?: unknown[] | undefined;
+            routes: (Readonly<{
+                key: string;
+                name: string;
+                path?: string | undefined;
+            }> & Readonly<{
+                params?: Readonly<object | undefined>;
+            }> & {
+                state?: Readonly<any> | import("@react-navigation/native").PartialState<Readonly<any>> | undefined;
+            })[];
+            type: string;
+            /** Used to configure route settings. */
+            stale: false;
+        }>>): void;
+        goBack(): void;
+        isFocused(): boolean;
+        canGoBack(): boolean;
+        getId(): string | undefined;
+        getParent<T = import("@react-navigation/native").NavigationHelpers<import("@react-navigation/native").ParamListBase, {}> | undefined>(id?: string | undefined): T;
+        getState(): Readonly<{
+            key: string;
+            index: number;
+            routeNames: string[];
+            history?: unknown[] | undefined;
+            routes: (Readonly<{
+                key: string;
+                name: string;
+                path?: string | undefined;
+            }> & Readonly<{
+                params?: Readonly<object | undefined>;
+            }> & {
+                state?: Readonly<any> | import("@react-navigation/native").PartialState<Readonly<any>> | undefined;
+            })[];
+            type: string;
+            stale: false;
+        }>;
+    } & import("@react-navigation/native").PrivateValueStore<[import("@react-navigation/native").ParamListBase, unknown, unknown]> & import("@react-navigation/native").EventEmitter<Record<string, any>> & {
+        setParams<RouteName_2 extends string>(params: Partial<object | undefined>): void;
+    } & Record<string, () => void>;
+    descriptors: Record<string, import("@react-navigation/native").Descriptor<{}, Omit<{
+        dispatch(action: Readonly<{
+            type: string;
+            payload?: object | undefined;
+            source?: string | undefined;
+            target?: string | undefined;
+        }> | ((state: Readonly<{
+            key: string;
+            index: number;
+            routeNames: string[];
+            history?: unknown[] | undefined;
+            routes: (Readonly<{
+                key: string;
+                name: string;
+                path?: string | undefined;
+            }> & Readonly<{
+                params?: Readonly<object | undefined>;
+            }> & {
+                state?: Readonly<any> | import("@react-navigation/native").PartialState<Readonly<any>> | undefined;
+            })[];
+            type: string;
+            stale: false;
+        }>) => Readonly<{
+            type: string;
+            payload?: object | undefined;
+            source?: string | undefined;
+            target?: string | undefined;
+        }>)): void;
+        navigate<RouteName_3 extends string>(...args: RouteName_3 extends unknown ? [screen: RouteName_3] | [screen: RouteName_3, params: object | undefined] : never): void;
+        navigate<RouteName_1_1 extends string>(options: RouteName_1_1 extends unknown ? {
+            key: string;
+            params?: object | undefined;
+            merge?: boolean | undefined;
+        } | {
+            name: RouteName_1_1;
+            key?: string | undefined;
+            params: object | undefined;
+            merge?: boolean | undefined;
+        } : never): void;
+        reset(state: Readonly<{
+            key: string;
+            index: number;
+            routeNames: string[];
+            history?: unknown[] | undefined;
+            routes: (Readonly<{
+                key: string;
+                name: string;
+                path?: string | undefined;
+            }> & Readonly<{
+                params?: Readonly<object | undefined>;
+            }> & {
+                state?: Readonly<any> | import("@react-navigation/native").PartialState<Readonly<any>> | undefined;
+            })[];
+            type: string;
+            stale: false;
+        }> | import("@react-navigation/native").PartialState<Readonly<{
+            key: string;
+            index: number;
+            routeNames: string[];
+            history?: unknown[] | undefined;
+            routes: (Readonly<{
+                key: string;
+                name: string;
+                path?: string | undefined;
+            }> & Readonly<{
+                params?: Readonly<object | undefined>;
+            }> & {
+                state?: Readonly<any> | import("@react-navigation/native").PartialState<Readonly<any>> | undefined;
+            })[];
+            type: string;
+            stale: false;
+        }>>): void;
+        goBack(): void;
+        isFocused(): boolean;
+        canGoBack(): boolean;
+        getId(): string | undefined;
+        getParent<T_1 = import("@react-navigation/native").NavigationHelpers<import("@react-navigation/native").ParamListBase, {}> | undefined>(id?: string | undefined): T_1;
+        getState(): Readonly<{
+            key: string;
+            index: number;
+            routeNames: string[];
+            history?: unknown[] | undefined;
+            routes: (Readonly<{
+                key: string;
+                name: string;
+                path?: string | undefined;
+            }> & Readonly<{
+                params?: Readonly<object | undefined>;
+            }> & {
+                state?: Readonly<any> | import("@react-navigation/native").PartialState<Readonly<any>> | undefined;
+            })[];
+            type: string;
+            stale: false;
+        }>;
+    } & import("@react-navigation/native").PrivateValueStore<[import("@react-navigation/native").ParamListBase, unknown, unknown]>, "getParent"> & {
+        getParent<T_1 = import("@react-navigation/native").NavigationProp<import("@react-navigation/native").ParamListBase, string, undefined, Readonly<{
+            key: string;
+            index: number;
+            routeNames: string[];
+            history?: unknown[] | undefined;
+            routes: (Readonly<{
+                key: string;
+                name: string;
+                path?: string | undefined;
+            }> & Readonly<{
+                params?: Readonly<object | undefined>;
+            }> & {
+                state?: Readonly<any> | import("@react-navigation/native").PartialState<Readonly<any>> | undefined;
+            })[];
+            type: string;
+            stale: false;
+        }>, {}, {}> | undefined>(id?: string | undefined): T_1;
+        setParams(params: Partial<object | undefined>): void;
+        setOptions(options: Partial<{}>): void;
+    } & import("@react-navigation/native").EventConsumer<Record<string, any> & import("@react-navigation/native").EventMapCore<Readonly<{
+        key: string;
+        index: number;
+        routeNames: string[];
+        history?: unknown[] | undefined;
+        routes: (Readonly<{
+            key: string;
+            name: string;
+            path?: string | undefined;
+        }> & Readonly<{
+            params?: Readonly<object | undefined>;
+        }> & {
+            state?: Readonly<any> | import("@react-navigation/native").PartialState<Readonly<any>> | undefined;
+        })[];
+        type: string;
+        stale: false;
+    }>>> & import("@react-navigation/native").PrivateValueStore<[import("@react-navigation/native").ParamListBase, string, Record<string, any>]> & Record<string, () => void>, import("@react-navigation/native").RouteProp<import("@react-navigation/native").ParamListBase, string>>>;
+    router: RouterFactory<any, any, any>;
+};
+export declare function useSlot(): JSX.Element | null;
+/** Renders the currently selected content. */
+export declare function Slot(props: Omit<NavigatorProps, "children">): JSX.Element;
+export declare function QualifiedSlot(): JSX.Element | null;
+export declare function DefaultNavigator(): JSX.Element;
+export {};
+//# sourceMappingURL=Navigator.d.ts.map

package/build/views/Navigator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Navigator.d.ts","sourceRoot":"","sources":["../../src/views/Navigator.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAEb,oBAAoB,EACrB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAO/B,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAG9D,eAAO,MAAM,gBAAgB;gBACf,MAAM;WACX,cAAc,CAAC,OAAO,CAAC;gBAClB,cAAc,CAAC,YAAY,CAAC;iBAC3B,cAAc,CAAC,aAAa,CAAC;YAClC,cAAc,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;SACvB,CAAC;AAMhB,MAAM,MAAM,cAAc,GAAG;IAC3B,gBAAgB,CAAC,EAAE,UAAU,CAC3B,OAAO,oBAAoB,CAC5B,CAAC,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC;IACzB,aAAa,CAAC,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC;IAC5E,QAAQ,CAAC,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;IAClE,MAAM,CAAC,EAAE,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC;CACrD,CAAC;AAEF,+DAA+D;AAC/D,wBAAgB,SAAS,CAAC,EACxB,gBAAgB,EAChB,aAAa,EACb,QAAQ,EACR,MAAM,GACP,EAAE,cAAc,sBA2BhB;yBAhCe,SAAS;;;;;AAkEzB,wBAAgB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAwDnC,wCAAwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAlDvC;AAED,wBAAgB,OAAO,uBActB;AAED,8CAA8C;AAC9C,wBAAgB,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,UAAU,CAAC,eAc3D;AAED,wBAAgB,aAAa,uBAE5B;AAED,wBAAgB,gBAAgB,gBAM/B"}

package/build/views/Screen.d.ts

@@ -0,0 +1,19 @@
+export type ScreenProps<TOptions extends Record<string, any> = Record<string, any>> = {
+    /**
+     * Name is required when used inside a Layout component.
+     *
+     * When used in a route, this can be an absolute path like `/(root)` to the parent route or a relative path like `../../` to the parent route.
+     * This should not be used inside of a Layout component.
+     * @example `/(root)` maps to a layout route `/app/(root).tsx`.
+     */
+    name?: string;
+    /** Should redirect away from this screen. */
+    redirect?: boolean;
+    initialParams?: {
+        [key: string]: any;
+    };
+    options?: TOptions;
+};
+/** Component for setting the current screen's options dynamically. */
+export declare function Screen<TOptions extends object = object>({ name, redirect, options, }: ScreenProps<TOptions>): null;
+//# sourceMappingURL=Screen.d.ts.map

package/build/views/Screen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Screen.d.ts","sourceRoot":"","sources":["../../src/views/Screen.tsx"],"names":[],"mappings":"AAIA,MAAM,MAAM,WAAW,CACrB,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,IACxD;IACF;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB,aAAa,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC;IACvC,OAAO,CAAC,EAAE,QAAQ,CAAC;CACpB,CAAC;AAEF,sEAAsE;AACtE,wBAAgB,MAAM,CAAC,QAAQ,SAAS,MAAM,GAAG,MAAM,EAAE,EACvD,IAAI,EACJ,QAAQ,EACR,OAAO,GACR,EAAE,WAAW,CAAC,QAAQ,CAAC,QAmBvB"}

package/build/views/Sitemap.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { NativeStackNavigationOptions } from "@react-navigation/native-stack";
+export declare function getNavOptions(): NativeStackNavigationOptions;
+export declare function Sitemap(): JSX.Element;
+//# sourceMappingURL=Sitemap.d.ts.map

package/build/views/Sitemap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sitemap.d.ts","sourceRoot":"","sources":["../../src/views/Sitemap.tsx"],"names":[],"mappings":";AAEA,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AA2B9E,wBAAgB,aAAa,IAAI,4BAA4B,CAqB5D;AAED,wBAAgB,OAAO,gBA6BtB"}