@react-navigation/core 6.0.2

package/lib/typescript/src/useNavigationBuilder.d.ts

@@ -0,0 +1,223 @@
+import { DefaultRouterOptions, NavigationState, ParamListBase, PartialState, RouterFactory } from '@react-navigation/routers';
+import * as React from 'react';
+import { DefaultNavigatorOptions, EventMapCore, PrivateValueStore } from './types';
+/**
+ * Hook for building navigators.
+ *
+ * @param createRouter Factory method which returns router object.
+ * @param options Options object containing `children` and additional options for the router.
+ * @returns An object containing `state`, `navigation`, `descriptors` objects.
+ */
+export default function useNavigationBuilder<State extends NavigationState, RouterOptions extends DefaultRouterOptions, ActionHelpers extends Record<string, () => void>, ScreenOptions extends {}, EventMap extends Record<string, any>>(createRouter: RouterFactory<State, any, RouterOptions>, options: DefaultNavigatorOptions<ParamListBase, State, ScreenOptions, EventMap> & RouterOptions): {
+    state: State;
+    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> | 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: [screen: RouteName] | [screen: RouteName, params: object | undefined]): void;
+        navigate<RouteName_1 extends string>(options: {
+            key: string;
+            params?: object | undefined;
+            merge?: boolean | undefined;
+        } | {
+            name: RouteName_1;
+            key?: string | undefined;
+            params: object | undefined;
+            merge?: boolean | undefined;
+        }): 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> | PartialState<Readonly<any>> | undefined;
+            })[];
+            type: string;
+            stale: false;
+        }> | 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> | PartialState<Readonly<any>> | undefined;
+            })[];
+            type: string;
+            stale: false;
+        }>>): void;
+        goBack(): void;
+        isFocused(): boolean;
+        canGoBack(): boolean;
+        getParent<T = import("./types").NavigationProp<ParamListBase, string, 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> | PartialState<Readonly<any>> | undefined;
+            })[];
+            type: string;
+            stale: false;
+        }>, {}, {}> | 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> | PartialState<Readonly<any>> | undefined;
+            })[];
+            type: string;
+            stale: false;
+        }>;
+    } & PrivateValueStore<ParamListBase, string, {}> & import("./types").EventEmitter<EventMap> & {
+        setParams<RouteName_2 extends string>(params: Partial<object | undefined>): void;
+    } & {
+        dispatch(action: Readonly<{
+            type: string;
+            payload?: object | undefined;
+            source?: string | undefined;
+            target?: string | undefined;
+        }> | ((state: any) => Readonly<{
+            type: string;
+            payload?: object | undefined;
+            source?: string | undefined;
+            target?: string | undefined;
+        }>)): void;
+        navigate<RouteName extends string>(...args: [screen: RouteName] | [screen: RouteName, params: object | undefined]): void;
+        navigate<RouteName_1 extends string>(options: {
+            key: string;
+            params?: object | undefined;
+            merge?: boolean | undefined;
+        } | {
+            name: RouteName_1;
+            key?: string | undefined;
+            params: object | undefined;
+            merge?: boolean | undefined;
+        }): void;
+        reset(state: any): void;
+        goBack(): void;
+        isFocused(): boolean;
+        canGoBack(): boolean;
+        getParent<T = import("./types").NavigationProp<ParamListBase, string, 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> | PartialState<Readonly<any>> | undefined;
+            })[];
+            type: string;
+            stale: false;
+        }>, {}, {}> | undefined>(): T;
+        getState(): any;
+    } & {
+        setParams(params: Partial<object | undefined>): void;
+        setOptions(options: Partial<any>): void;
+    } & import("./types").EventConsumer<any> & PrivateValueStore<ParamListBase, string, any> & ActionHelpers;
+    descriptors: Record<string, import("./types").Descriptor<ScreenOptions, {
+        dispatch(action: Readonly<{
+            type: string;
+            payload?: object | undefined;
+            source?: string | undefined;
+            target?: string | undefined;
+        }> | ((state: State) => Readonly<{
+            type: string;
+            payload?: object | undefined;
+            source?: string | undefined;
+            target?: string | undefined;
+        }>)): void;
+        navigate<RouteName extends string>(...args: [screen: RouteName] | [screen: RouteName, params: object | undefined]): void;
+        navigate<RouteName_1 extends string>(options: {
+            key: string;
+            params?: object | undefined;
+            merge?: boolean | undefined;
+        } | {
+            name: RouteName_1;
+            key?: string | undefined;
+            params: object | undefined;
+            merge?: boolean | undefined;
+        }): void;
+        reset(state: State | PartialState<State>): void;
+        goBack(): void;
+        isFocused(): boolean;
+        canGoBack(): boolean;
+        getParent<T = import("./types").NavigationProp<ParamListBase, string, 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> | PartialState<Readonly<any>> | undefined;
+            })[];
+            type: string;
+            stale: false;
+        }>, {}, {}> | undefined>(): T;
+        getState(): State;
+    } & PrivateValueStore<ParamListBase, string, {}> & {
+        setParams(params: Partial<object | undefined>): void;
+        setOptions(options: Partial<ScreenOptions>): void;
+    } & import("./types").EventConsumer<EventMap & EventMapCore<State>> & PrivateValueStore<ParamListBase, string, EventMap> & ActionHelpers, import("./types").RouteProp<ParamListBase, string>>>;
+    NavigationContent: (rest: Omit<React.ProviderProps<import("./types").NavigationHelpers<ParamListBase, {}> | undefined>, "value">) => JSX.Element;
+};

package/lib/typescript/src/useNavigationCache.d.ts

@@ -0,0 +1,19 @@
+import { NavigationAction, NavigationState, ParamListBase, Router } from '@react-navigation/routers';
+import type { NavigationHelpers, NavigationProp } from './types';
+import type { NavigationEventEmitter } from './useEventEmitter';
+declare type Options<State extends NavigationState, EventMap extends Record<string, any>> = {
+    state: State;
+    getState: () => State;
+    navigation: NavigationHelpers<ParamListBase> & Partial<NavigationProp<ParamListBase, string, any, any, any>>;
+    setOptions: (cb: (options: Record<string, object>) => Record<string, object>) => void;
+    router: Router<State, NavigationAction>;
+    emitter: NavigationEventEmitter<EventMap>;
+};
+declare type NavigationCache<State extends NavigationState, ScreenOptions extends {}, EventMap extends Record<string, any>> = Record<string, NavigationProp<ParamListBase, string, State, ScreenOptions, EventMap>>;
+/**
+ * Hook to cache navigation objects for each screen in the navigator.
+ * It's important to cache them to make sure navigation objects don't change between renders.
+ * This lets us apply optimizations like `React.memo` to minimize re-rendering screens.
+ */
+export default function useNavigationCache<State extends NavigationState, ScreenOptions extends {}, EventMap extends Record<string, any>>({ state, getState, navigation, setOptions, router, emitter, }: Options<State, EventMap>): NavigationCache<State, ScreenOptions, EventMap>;
+export {};

package/lib/typescript/src/useNavigationContainerRef.d.ts

@@ -0,0 +1,2 @@
+import type { NavigationContainerRefWithCurrent } from './types';
+export default function useNavigationContainerRef<ParamList extends {} = ReactNavigation.RootParamList>(): NavigationContainerRefWithCurrent<ParamList>;

package/lib/typescript/src/useNavigationHelpers.d.ts

@@ -0,0 +1,174 @@
+import { NavigationAction, NavigationState, ParamListBase, Router } from '@react-navigation/routers';
+import { NavigationProp, PrivateValueStore } from './types';
+import type { NavigationEventEmitter } from './useEventEmitter';
+declare type Options<State extends NavigationState, Action extends NavigationAction> = {
+    onAction: (action: NavigationAction) => boolean;
+    getState: () => State;
+    emitter: NavigationEventEmitter<any>;
+    router: Router<State, Action>;
+};
+/**
+ * Navigation object with helper methods to be used by a navigator.
+ * This object includes methods for common actions as well as methods the parent screen's navigation object.
+ */
+export default function useNavigationHelpers<State extends NavigationState, ActionHelpers extends Record<string, () => void>, Action extends NavigationAction, EventMap extends Record<string, any>>({ onAction, getState, emitter, router }: Options<State, Action>): {
+    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/routers").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: [screen: RouteName] | [screen: RouteName, params: object | undefined]): void;
+    navigate<RouteName_1 extends string>(options: {
+        key: string;
+        params?: object | undefined;
+        merge?: boolean | undefined;
+    } | {
+        name: RouteName_1;
+        key?: string | undefined;
+        params: object | undefined;
+        merge?: boolean | undefined;
+    }): 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/routers").PartialState<Readonly<any>> | undefined;
+        })[];
+        type: string;
+        stale: false;
+    }> | import("@react-navigation/routers").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/routers").PartialState<Readonly<any>> | undefined;
+        })[];
+        type: string;
+        stale: false;
+    }>>): void;
+    goBack(): void;
+    isFocused(): boolean;
+    canGoBack(): boolean;
+    getParent<T = NavigationProp<ParamListBase, string, 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;
+    }>, {}, {}> | 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/routers").PartialState<Readonly<any>> | undefined;
+        })[];
+        type: string;
+        stale: false;
+    }>;
+} & PrivateValueStore<ParamListBase, string, {}> & import("./types").EventEmitter<EventMap> & {
+    setParams<RouteName_2 extends string>(params: Partial<object | undefined>): void;
+} & {
+    dispatch(action: Readonly<{
+        type: string;
+        payload?: object | undefined;
+        source?: string | undefined;
+        target?: string | undefined;
+    }> | ((state: any) => Readonly<{
+        type: string;
+        payload?: object | undefined;
+        source?: string | undefined;
+        target?: string | undefined;
+    }>)): void;
+    navigate<RouteName extends string>(...args: [screen: RouteName] | [screen: RouteName, params: object | undefined]): void;
+    navigate<RouteName_1 extends string>(options: {
+        key: string;
+        params?: object | undefined;
+        merge?: boolean | undefined;
+    } | {
+        name: RouteName_1;
+        key?: string | undefined;
+        params: object | undefined;
+        merge?: boolean | undefined;
+    }): void;
+    reset(state: any): void;
+    goBack(): void;
+    isFocused(): boolean;
+    canGoBack(): boolean;
+    getParent<T = NavigationProp<ParamListBase, string, 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;
+    }>, {}, {}> | undefined>(): T;
+    getState(): any;
+} & {
+    setParams(params: Partial<object | undefined>): void;
+    setOptions(options: Partial<any>): void;
+} & import("./types").EventConsumer<any> & PrivateValueStore<ParamListBase, string, any> & ActionHelpers;
+export {};

package/lib/typescript/src/useNavigationState.d.ts

@@ -0,0 +1,9 @@
+import type { NavigationState, ParamListBase } from '@react-navigation/routers';
+declare type Selector<ParamList extends ParamListBase, T> = (state: NavigationState<ParamList>) => T;
+/**
+ * Hook to get a value from the current navigation state using a selector.
+ *
+ * @param selector Selector function to get a value from the state.
+ */
+export default function useNavigationState<ParamList extends ParamListBase, T>(selector: Selector<ParamList, T>): T;
+export {};

package/lib/typescript/src/useOnAction.d.ts

@@ -0,0 +1,25 @@
+import type { NavigationAction, NavigationState, PartialState, Router, RouterConfigOptions } from '@react-navigation/routers';
+import { ChildActionListener, ChildBeforeRemoveListener } from './NavigationBuilderContext';
+import type { EventMapCore } from './types';
+import type { NavigationEventEmitter } from './useEventEmitter';
+declare type Options = {
+    router: Router<NavigationState, NavigationAction>;
+    key?: string;
+    getState: () => NavigationState;
+    setState: (state: NavigationState | PartialState<NavigationState>) => void;
+    actionListeners: ChildActionListener[];
+    beforeRemoveListeners: Record<string, ChildBeforeRemoveListener | undefined>;
+    routerConfigOptions: RouterConfigOptions;
+    emitter: NavigationEventEmitter<EventMapCore<any>>;
+};
+/**
+ * Hook to handle actions for a navigator, including state updates and bubbling.
+ *
+ * Bubbling an action is achieved in 2 ways:
+ * 1. To bubble action to parent, we expose the action handler in context and then access the parent context
+ * 2. To bubble action to child, child adds event listeners subscribing to actions from parent
+ *
+ * When the action handler handles as action, it returns `true`, otherwise `false`.
+ */
+export default function useOnAction({ router, getState, setState, key, actionListeners, beforeRemoveListeners, routerConfigOptions, emitter, }: Options): (action: NavigationAction, visitedNavigators?: Set<string>) => boolean;
+export {};

package/lib/typescript/src/useOnGetState.d.ts

@@ -0,0 +1,8 @@
+import type { NavigationState } from '@react-navigation/routers';
+import { GetStateListener } from './NavigationBuilderContext';
+declare type Options = {
+    getState: () => NavigationState;
+    getStateListeners: Record<string, GetStateListener | undefined>;
+};
+export default function useOnGetState({ getState, getStateListeners, }: Options): void;
+export {};

package/lib/typescript/src/useOnPreventRemove.d.ts

@@ -0,0 +1,16 @@
+import type { NavigationAction, NavigationState } from '@react-navigation/routers';
+import { ChildBeforeRemoveListener } from './NavigationBuilderContext';
+import type { EventMapCore } from './types';
+import type { NavigationEventEmitter } from './useEventEmitter';
+declare type Options = {
+    getState: () => NavigationState;
+    emitter: NavigationEventEmitter<EventMapCore<any>>;
+    beforeRemoveListeners: Record<string, ChildBeforeRemoveListener | undefined>;
+};
+export declare const shouldPreventRemove: (emitter: NavigationEventEmitter<EventMapCore<any>>, beforeRemoveListeners: Record<string, ChildBeforeRemoveListener | undefined>, currentRoutes: {
+    key: string;
+}[], nextRoutes: {
+    key?: string | undefined;
+}[], action: NavigationAction) => boolean;
+export default function useOnPreventRemove({ getState, emitter, beforeRemoveListeners, }: Options): void;
+export {};

package/lib/typescript/src/useOnRouteFocus.d.ts

@@ -0,0 +1,14 @@
+import type { NavigationAction, NavigationState, Router } from '@react-navigation/routers';
+declare type Options<Action extends NavigationAction> = {
+    router: Router<NavigationState, Action>;
+    getState: () => NavigationState;
+    setState: (state: NavigationState) => void;
+    key?: string;
+};
+/**
+ * Hook to handle focus actions for a route.
+ * Focus action needs to be treated specially, coz when a nested route is focused,
+ * the parent navigators also needs to be focused.
+ */
+export default function useOnRouteFocus<Action extends NavigationAction>({ router, getState, key: sourceRouteKey, setState, }: Options<Action>): (key: string) => void;
+export {};

package/lib/typescript/src/useOptionsGetters.d.ts

@@ -0,0 +1,12 @@
+import type { ParamListBase } from '@react-navigation/routers';
+import type { NavigationProp } from './types';
+declare type Options = {
+    key?: string;
+    navigation?: NavigationProp<ParamListBase>;
+    options?: object | undefined;
+};
+export default function useOptionsGetters({ key, options, navigation, }: Options): {
+    addOptionsGetter: (key: string, getter: () => object | undefined | null) => () => void;
+    getCurrentOptions: () => object | null | undefined;
+};
+export {};

package/lib/typescript/src/useRegisterNavigator.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Register a navigator in the parent context (either a navigation container or a screen).
+ * This is used to prevent multiple navigators under a single container or screen.
+ */
+export default function useRegisterNavigator(): string;

package/lib/typescript/src/useRoute.d.ts

@@ -0,0 +1,8 @@
+import type { ParamListBase } from '@react-navigation/routers';
+import type { RouteProp } from './types';
+/**
+ * Hook to access the route prop of the parent screen anywhere.
+ *
+ * @returns Route prop of the parent screen.
+ */
+export default function useRoute<T extends RouteProp<ParamListBase>>(): T;

package/lib/typescript/src/useRouteCache.d.ts

@@ -0,0 +1,13 @@
+import type { NavigationState, ParamListBase } from '@react-navigation/routers';
+import type { RouteProp } from './types';
+/**
+ * Utilites such as `getFocusedRouteNameFromRoute` need to access state.
+ * So we need a way to suppress the warning for those use cases.
+ * This is fine since they are internal utilities and this is not public API.
+ */
+export declare const CHILD_STATE: unique symbol;
+/**
+ * Hook to cache route props for each screen in the navigator.
+ * This lets add warnings and modifications to the route object but keep references between renders.
+ */
+export default function useRouteCache<State extends NavigationState>(routes: State['routes']): RouteProp<ParamListBase, string>[];

package/lib/typescript/src/useScheduleUpdate.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+export declare const ScheduleUpdateContext: React.Context<{
+    scheduleUpdate: (callback: () => void) => void;
+    flushUpdates: () => void;
+}>;
+/**
+ * When screen config changes, we want to update the navigator in the same update phase.
+ * However, navigation state is in the root component and React won't let us update it from a child.
+ * This is a workaround for that, the scheduled update is stored in the ref without actually calling setState.
+ * It lets all subsequent updates access the latest state so it stays correct.
+ * Then we call setState during after the component updates.
+ */
+export default function useScheduleUpdate(callback: () => void): void;

package/lib/typescript/src/useSyncState.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This is definitely not compatible with concurrent mode, but we don't have a solution for sync state yet.
+ */
+export default function useSyncState<T>(initialState?: (() => T) | T): readonly [T, () => T, (state: T) => void, (callback: () => void) => void, () => void];

package/lib/typescript/src/validatePathConfig.d.ts

@@ -0,0 +1 @@
+export default function validatePathConfig(config: any, root?: boolean): void;

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@react-navigation/core",
+  "description": "Core utilities for building navigators",
+  "version": "6.0.2",
+  "keywords": [
+    "react",
+    "react-native",
+    "react-navigation"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/react-navigation/react-navigation.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/react-navigation/react-navigation/issues"
+  },
+  "homepage": "https://reactnavigation.org",
+  "main": "lib/commonjs/index.js",
+  "react-native": "src/index.tsx",
+  "source": "src/index.tsx",
+  "module": "lib/module/index.js",
+  "types": "lib/typescript/src/index.d.ts",
+  "files": [
+    "src",
+    "lib",
+    "!**/__tests__"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prepare": "bob build",
+    "clean": "del lib"
+  },
+  "dependencies": {
+    "@react-navigation/routers": "^6.0.1",
+    "escape-string-regexp": "^4.0.0",
+    "nanoid": "^3.1.23",
+    "query-string": "^7.0.0",
+    "react-is": "^16.13.0"
+  },
+  "devDependencies": {
+    "@testing-library/react-native": "^7.2.0",
+    "@types/react": "^17.0.9",
+    "@types/react-is": "^17.0.0",
+    "del-cli": "^3.0.1",
+    "immer": "^9.0.2",
+    "react": "~16.13.1",
+    "react-native-builder-bob": "^0.18.1",
+    "react-test-renderer": "~16.13.1",
+    "typescript": "^4.3.2"
+  },
+  "peerDependencies": {
+    "react": "*"
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "gitHead": "38ac69f17ee314f96d3d4bcee02349fa4a02d422"
+}