@react-navigation/core 7.0.0-alpha.4 → 7.0.0-alpha.6

package/src/useNavigationBuilder.tsx

@@ -1,17 +1,18 @@
 import {
   CommonActions,
-  DefaultRouterOptions,
-  NavigationAction,
-  NavigationState,
-  ParamListBase,
-  PartialState,
-  Route,
-  Router,
-  RouterConfigOptions,
-  RouterFactory,
+  type DefaultRouterOptions,
+  type NavigationAction,
+  type NavigationState,
+  type ParamListBase,
+  type PartialState,
+  type Route,
+  type Router,
+  type RouterConfigOptions,
+  type RouterFactory,
 } from '@react-navigation/routers';
 import * as React from 'react';
 import { isValidElementType } from 'react-is';
+import useLatestCallback from 'use-latest-callback';
 
 import { Group } from './Group';
 import { isArrayEqual } from './isArrayEqual';
@@ -22,30 +23,29 @@ import { NavigationStateContext } from './NavigationStateContext';
 import { PreventRemoveProvider } from './PreventRemoveProvider';
 import { Screen } from './Screen';
 import {
-  DefaultNavigatorOptions,
-  EventMapBase,
-  EventMapCore,
-  NavigatorScreenParams,
+  type DefaultNavigatorOptions,
+  type EventMapBase,
+  type EventMapCore,
+  type NavigatorScreenParams,
   PrivateValueStore,
-  RouteConfig,
+  type RouteConfig,
 } from './types';
 import { useChildListeners } from './useChildListeners';
 import { useComponent } from './useComponent';
 import { useCurrentRender } from './useCurrentRender';
-import { ScreenConfigWithParent, useDescriptors } from './useDescriptors';
+import { type ScreenConfigWithParent, useDescriptors } from './useDescriptors';
 import { useEventEmitter } from './useEventEmitter';
 import { useFocusedListenersChildrenAdapter } from './useFocusedListenersChildrenAdapter';
 import { useFocusEvents } from './useFocusEvents';
+import { useIsomorphicLayoutEffect } from './useIsomorphicLayoutEffect';
 import { useKeyedChildListeners } from './useKeyedChildListeners';
 import { useNavigationHelpers } from './useNavigationHelpers';
 import { useOnAction } from './useOnAction';
 import { useOnGetState } from './useOnGetState';
 import { useOnRouteFocus } from './useOnRouteFocus';
 import { useRegisterNavigator } from './useRegisterNavigator';
-import { useScheduleUpdate } from './useScheduleUpdate';
 
 // This is to make TypeScript compiler happy
-// eslint-disable-next-line babel/no-unused-expressions
 PrivateValueStore;
 
 type NavigatorRoute = {
@@ -64,7 +64,7 @@ const isValidKey = (key: unknown) =>
 const getRouteConfigsFromChildren = <
   State extends NavigationState,
   ScreenOptions extends {},
-  EventMap extends EventMapBase
+  EventMap extends EventMapBase,
 >(
   children: React.ReactNode,
   groupKey?: string,
@@ -242,7 +242,7 @@ export function useNavigationBuilder<
   RouterOptions extends DefaultRouterOptions,
   ActionHelpers extends Record<string, () => void>,
   ScreenOptions extends {},
-  EventMap extends Record<string, any>
+  EventMap extends Record<string, any>,
 >(
   createRouter: RouterFactory<State, any, RouterOptions>,
   options: DefaultNavigatorOptions<
@@ -259,17 +259,9 @@ export function useNavigationBuilder<
     | NavigatorRoute
     | undefined;
 
-  const { children, screenListeners, ...rest } = options;
+  const { children, layout, screenOptions, screenListeners, ...rest } = options;
   const { current: router } = React.useRef<Router<State, any>>(
-    createRouter({
-      ...(rest as unknown as RouterOptions),
-      ...(route?.params &&
-      route.params.state == null &&
-      route.params.initial !== false &&
-      typeof route.params.screen === 'string'
-        ? { initialRouteName: route.params.screen }
-        : null),
-    })
+    createRouter(rest as unknown as RouterOptions)
   );
 
   const routeConfigs = getRouteConfigsFromChildren<
@@ -346,12 +338,7 @@ export function useNavigationBuilder<
 
   const stateCleanedUp = React.useRef(false);
 
-  const cleanUpState = React.useCallback(() => {
-    setCurrentState(undefined);
-    stateCleanedUp.current = true;
-  }, [setCurrentState]);
-
-  const setState = React.useCallback(
+  const setState = useLatestCallback(
     (state: NavigationState | PartialState<NavigationState> | undefined) => {
       if (stateCleanedUp.current) {
         // State might have been already cleaned up due to unmount
@@ -359,9 +346,9 @@ export function useNavigationBuilder<
         // This would lead to old data preservation on main navigator unmount
         return;
       }
+
       setCurrentState(state);
-    },
-    [setCurrentState]
+    }
   );
 
   const [initializedState, isFirstStateInitialization] = React.useMemo(() => {
@@ -393,7 +380,11 @@ export function useNavigationBuilder<
     // So we need to rehydrate it to make it usable
     if (
       (currentState === undefined || !isStateValid(currentState)) &&
-      route?.params?.state == null
+      route?.params?.state == null &&
+      !(
+        typeof route?.params?.screen === 'string' &&
+        route?.params?.initial !== false
+      )
     ) {
       return [
         router.getInitialState({
@@ -404,9 +395,29 @@ export function useNavigationBuilder<
         true,
       ];
     } else {
+      let stateFromParams;
+
+      if (route?.params?.state != null) {
+        stateFromParams = route.params.state;
+      } else if (
+        typeof route?.params?.screen === 'string' &&
+        route?.params?.initial !== false
+      ) {
+        stateFromParams = {
+          index: 0,
+          routes: [
+            {
+              name: route.params.screen,
+              params: route.params.params,
+              path: route.params.path,
+            },
+          ],
+        };
+      }
+
       return [
         router.getRehydratedState(
-          (route?.params?.state ?? currentState) as PartialState<State>,
+          (stateFromParams ?? currentState) as PartialState<State>,
           {
             routeNames,
             routeParamList: initialRouteParamList,
@@ -446,17 +457,26 @@ export function useNavigationBuilder<
     !isArrayEqual(state.routeNames, routeNames) ||
     !isRecordEqual(routeKeyList, previousRouteKeyList)
   ) {
+    const navigatorStateForNextRouteNamesChange =
+      options.getStateForRouteNamesChange?.(state);
     // When the list of route names change, the router should handle it to remove invalid routes
-    nextState = router.getStateForRouteNamesChange(state, {
-      routeNames,
-      routeParamList,
-      routeGetIdList,
-      routeKeyChanges: Object.keys(routeKeyList).filter(
-        (name) =>
-          previousRouteKeyList.hasOwnProperty(name) &&
-          routeKeyList[name] !== previousRouteKeyList[name]
-      ),
-    });
+    nextState = navigatorStateForNextRouteNamesChange
+      ? // @ts-expect-error this is ok
+        router.getRehydratedState(navigatorStateForNextRouteNamesChange, {
+          routeNames,
+          routeParamList,
+          routeGetIdList,
+        })
+      : router.getStateForRouteNamesChange(state, {
+          routeNames,
+          routeParamList,
+          routeGetIdList,
+          routeKeyChanges: Object.keys(routeKeyList).filter(
+            (name) =>
+              name in previousRouteKeyList &&
+              routeKeyList[name] !== previousRouteKeyList[name]
+          ),
+        });
   }
 
   const previousNestedParamsRef = React.useRef(route?.params);
@@ -511,7 +531,7 @@ export function useNavigationBuilder<
 
   const shouldUpdate = state !== nextState;
 
-  useScheduleUpdate(() => {
+  useIsomorphicLayoutEffect(() => {
     if (shouldUpdate) {
       // If the state needs to be updated, we'll schedule an update
       setState(nextState);
@@ -535,34 +555,24 @@ export function useNavigationBuilder<
 
     return () => {
       // We need to clean up state for this navigator on unmount
-      // We do it in a timeout because we need to detect if another navigator mounted in the meantime
-      // For example, if another navigator has started rendering, we should skip cleanup
-      // Otherwise, our cleanup step will cleanup state for the other navigator and re-initialize it
-      setTimeout(() => {
-        if (getCurrentState() !== undefined && getKey() === navigatorKey) {
-          cleanUpState();
-        }
-      }, 0);
+      if (getCurrentState() !== undefined && getKey() === navigatorKey) {
+        setCurrentState(undefined);
+        stateCleanedUp.current = true;
+      }
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
-  // We initialize this ref here to avoid a new getState getting initialized
-  // whenever initializedState changes. We want getState to have access to the
-  // latest initializedState, but don't need it to change when that happens
-  const initializedStateRef = React.useRef<State>();
-  initializedStateRef.current = initializedState;
+  const getState = useLatestCallback((): State => {
+    const currentState = shouldUpdate ? nextState : getCurrentState();
 
-  const getState = React.useCallback((): State => {
-    const currentState = getCurrentState();
-
-    return isStateInitialized(currentState)
-      ? (currentState as State)
-      : (initializedStateRef.current as State);
-  }, [getCurrentState, isStateInitialized]);
+    return (
+      isStateInitialized(currentState) ? currentState : initializedState
+    ) as State;
+  });
 
   const emitter = useEventEmitter<EventMapCore<State>>((e) => {
-    let routeNames = [];
+    const routeNames = [];
 
     let route: Route<string> | undefined;
 
@@ -678,7 +688,7 @@ export function useNavigationBuilder<
     state,
     screens,
     navigation,
-    screenOptions: options.screenOptions,
+    screenOptions,
     onAction,
     getState,
     setState,
@@ -696,11 +706,23 @@ export function useNavigationBuilder<
     descriptors,
   });
 
-  const NavigationContent = useComponent((children: React.ReactNode) => (
-    <NavigationHelpersContext.Provider value={navigation}>
-      <PreventRemoveProvider>{children}</PreventRemoveProvider>
-    </NavigationHelpersContext.Provider>
-  ));
+  const NavigationContent = useComponent((children: React.ReactNode) => {
+    const element =
+      layout != null
+        ? layout({
+            state,
+            descriptors,
+            navigation,
+            children,
+          })
+        : children;
+
+    return (
+      <NavigationHelpersContext.Provider value={navigation}>
+        <PreventRemoveProvider>{element}</PreventRemoveProvider>
+      </NavigationHelpersContext.Provider>
+    );
+  });
 
   return {
     state,

package/src/useNavigationCache.tsx

@@ -1,9 +1,9 @@
 import {
   CommonActions,
-  NavigationAction,
-  NavigationState,
-  ParamListBase,
-  Router,
+  type NavigationAction,
+  type NavigationState,
+  type ParamListBase,
+  type Router,
 } from '@react-navigation/routers';
 import * as React from 'react';
 
@@ -14,7 +14,7 @@ import type { NavigationEventEmitter } from './useEventEmitter';
 type Options<
   State extends NavigationState,
   ScreenOptions extends {},
-  EventMap extends Record<string, any>
+  EventMap extends Record<string, any>,
 > = {
   state: State;
   getState: () => State;
@@ -32,7 +32,7 @@ type Options<
 type NavigationCache<
   State extends NavigationState,
   ScreenOptions extends {},
-  EventMap extends Record<string, any>
+  EventMap extends Record<string, any>,
 > = Record<
   string,
   NavigationProp<
@@ -53,7 +53,7 @@ type NavigationCache<
 export function useNavigationCache<
   State extends NavigationState,
   ScreenOptions extends {},
-  EventMap extends Record<string, any>
+  EventMap extends Record<string, any>,
 >({
   state,
   getState,

package/src/useNavigationContainerRef.tsx

@@ -4,7 +4,7 @@ import { createNavigationContainerRef } from './createNavigationContainerRef';
 import type { NavigationContainerRefWithCurrent } from './types';
 
 export function useNavigationContainerRef<
-  ParamList extends {} = ReactNavigation.RootParamList
+  ParamList extends {} = ReactNavigation.RootParamList,
 >(): NavigationContainerRefWithCurrent<ParamList> {
   const navigation =
     React.useRef<NavigationContainerRefWithCurrent<ParamList> | null>(null);

package/src/useNavigationHelpers.tsx

@@ -1,19 +1,18 @@
 import {
   CommonActions,
-  NavigationAction,
-  NavigationState,
-  ParamListBase,
-  Router,
+  type NavigationAction,
+  type NavigationState,
+  type ParamListBase,
+  type Router,
 } from '@react-navigation/routers';
 import * as React from 'react';
 
 import { NavigationContext } from './NavigationContext';
-import { NavigationHelpers, PrivateValueStore } from './types';
+import { type NavigationHelpers, PrivateValueStore } from './types';
 import { UnhandledActionContext } from './UnhandledActionContext';
 import type { NavigationEventEmitter } from './useEventEmitter';
 
 // This is to make TypeScript compiler happy
-// eslint-disable-next-line babel/no-unused-expressions
 PrivateValueStore;
 
 type Options<State extends NavigationState, Action extends NavigationAction> = {
@@ -32,7 +31,7 @@ export function useNavigationHelpers<
   State extends NavigationState,
   ActionHelpers extends Record<string, () => void>,
   Action extends NavigationAction,
-  EventMap extends Record<string, any>
+  EventMap extends Record<string, any>,
 >({
   id: navigatorId,
   onAction,

package/src/useOnAction.tsx

@@ -9,8 +9,8 @@ import * as React from 'react';
 
 import { DeprecatedNavigationInChildContext } from './DeprecatedNavigationInChildContext';
 import {
-  ChildActionListener,
-  ChildBeforeRemoveListener,
+  type ChildActionListener,
+  type ChildBeforeRemoveListener,
   NavigationBuilderContext,
 } from './NavigationBuilderContext';
 import type { EventMapCore } from './types';

package/src/useOnGetState.tsx

@@ -3,7 +3,7 @@ import * as React from 'react';
 
 import { isArrayEqual } from './isArrayEqual';
 import {
-  GetStateListener,
+  type GetStateListener,
   NavigationBuilderContext,
 } from './NavigationBuilderContext';
 import { NavigationRouteContext } from './NavigationRouteContext';

package/src/useOnPreventRemove.tsx

@@ -5,7 +5,7 @@ import type {
 import * as React from 'react';
 
 import {
-  ChildBeforeRemoveListener,
+  type ChildBeforeRemoveListener,
   NavigationBuilderContext,
 } from './NavigationBuilderContext';
 import { NavigationRouteContext } from './NavigationRouteContext';

package/src/useOptionsGetters.tsx

@@ -39,8 +39,8 @@ export function useOptionsGetters({ key, options, navigation }: Options) {
   }, [navigation, options, optionsChangeListener]);
 
   const getOptionsFromListener = React.useCallback(() => {
-    for (let key in optionsGettersFromChildRef.current) {
-      if (optionsGettersFromChildRef.current.hasOwnProperty(key)) {
+    for (const key in optionsGettersFromChildRef.current) {
+      if (key in optionsGettersFromChildRef.current) {
         const result = optionsGettersFromChildRef.current[key]?.();
 
         // null means unfocused route

package/src/useSyncState.tsx

@@ -1,74 +1,46 @@
 import * as React from 'react';
 
-const UNINTIALIZED_STATE = {};
+const createStore = <T,>(getInitialState: () => T) => {
+  const listeners: (() => void)[] = [];
 
-/**
- * This is definitely not compatible with concurrent mode, but we don't have a solution for sync state yet.
- */
-export function useSyncState<T>(initialState?: (() => T) | T) {
-  const stateRef = React.useRef<T>(UNINTIALIZED_STATE as any);
-  const isSchedulingRef = React.useRef(false);
-  const isMountedRef = React.useRef(true);
+  let state: T = getInitialState();
 
-  React.useEffect(() => {
-    isMountedRef.current = true;
+  const getState = () => state;
 
-    return () => {
-      isMountedRef.current = false;
-    };
-  }, []);
-
-  if (stateRef.current === UNINTIALIZED_STATE) {
-    stateRef.current =
-      // @ts-expect-error: initialState is a function, but TypeScript doesn't think so
-      typeof initialState === 'function' ? initialState() : initialState;
-  }
-
-  const [trackingState, setTrackingState] = React.useState(stateRef.current);
-
-  const getState = React.useCallback(() => stateRef.current, []);
+  const setState = (newState: T) => {
+    state = newState;
+    listeners.forEach((listener) => listener());
+  };
 
-  const setState = React.useCallback((state: T) => {
-    if (state === stateRef.current || !isMountedRef.current) {
-      return;
-    }
+  const subscribe = (callback: () => void) => {
+    listeners.push(callback);
 
-    stateRef.current = state;
-
-    if (!isSchedulingRef.current) {
-      setTrackingState(state);
-    }
-  }, []);
-
-  const scheduleUpdate = React.useCallback((callback: () => void) => {
-    isSchedulingRef.current = true;
-
-    try {
-      callback();
-    } finally {
-      isSchedulingRef.current = false;
-    }
-  }, []);
+    return () => {
+      const index = listeners.indexOf(callback);
 
-  const flushUpdates = React.useCallback(() => {
-    if (!isMountedRef.current) {
-      return;
-    }
+      if (index > -1) {
+        listeners.splice(index, 1);
+      }
+    };
+  };
 
-    // Make sure that the tracking state is up-to-date.
-    // We call it unconditionally, but React should skip the update if state is unchanged.
-    setTrackingState(stateRef.current);
-  }, []);
+  return {
+    getState,
+    setState,
+    subscribe,
+  };
+};
 
-  // If we're rendering and the tracking state is out of date, update it immediately
-  // This will make sure that our updates are applied as early as possible.
-  if (trackingState !== stateRef.current) {
-    setTrackingState(stateRef.current);
-  }
+export function useSyncState<T>(getInitialState: () => T) {
+  const store = React.useRef(createStore(getInitialState)).current;
 
-  const state = stateRef.current;
+  const state = React.useSyncExternalStore(
+    store.subscribe,
+    store.getState,
+    store.getState
+  );
 
   React.useDebugValue(state);
 
-  return [state, getState, setState, scheduleUpdate, flushUpdates] as const;
+  return [state, store.getState, store.setState] as const;
 }

package/lib/commonjs/useScheduleUpdate.js

@@ -1,37 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ScheduleUpdateContext = void 0;
-exports.useScheduleUpdate = useScheduleUpdate;
-var React = _interopRequireWildcard(require("react"));
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-const MISSING_CONTEXT_ERROR = "Couldn't find a schedule context.";
-const ScheduleUpdateContext = /*#__PURE__*/React.createContext({
-  scheduleUpdate() {
-    throw new Error(MISSING_CONTEXT_ERROR);
-  },
-  flushUpdates() {
-    throw new Error(MISSING_CONTEXT_ERROR);
-  }
-});
-
-/**
- * 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.
- */
-exports.ScheduleUpdateContext = ScheduleUpdateContext;
-function useScheduleUpdate(callback) {
-  const {
-    scheduleUpdate,
-    flushUpdates
-  } = React.useContext(ScheduleUpdateContext);
-  scheduleUpdate(callback);
-  React.useEffect(flushUpdates);
-}
-//# sourceMappingURL=useScheduleUpdate.js.map

package/lib/commonjs/useScheduleUpdate.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["MISSING_CONTEXT_ERROR","ScheduleUpdateContext","React","createContext","scheduleUpdate","Error","flushUpdates","useScheduleUpdate","callback","useContext","useEffect"],"sourceRoot":"../../src","sources":["useScheduleUpdate.tsx"],"mappings":";;;;;;;AAAA;AAA+B;AAAA;AAE/B,MAAMA,qBAAqB,GAAG,mCAAmC;AAE1D,MAAMC,qBAAqB,gBAAGC,KAAK,CAACC,aAAa,CAGrD;EACDC,cAAc,GAAG;IACf,MAAM,IAAIC,KAAK,CAACL,qBAAqB,CAAC;EACxC,CAAC;EACDM,YAAY,GAAG;IACb,MAAM,IAAID,KAAK,CAACL,qBAAqB,CAAC;EACxC;AACF,CAAC,CAAC;;AAEF;AACA;AACA;AACA;AACA;AACA;AACA;AANA;AAOO,SAASO,iBAAiB,CAACC,QAAoB,EAAE;EACtD,MAAM;IAAEJ,cAAc;IAAEE;EAAa,CAAC,GAAGJ,KAAK,CAACO,UAAU,CACvDR,qBAAqB,CACtB;EAEDG,cAAc,CAACI,QAAQ,CAAC;EAExBN,KAAK,CAACQ,SAAS,CAACJ,YAAY,CAAC;AAC/B"}

package/lib/module/useScheduleUpdate.js

@@ -1,27 +0,0 @@
-import * as React from 'react';
-const MISSING_CONTEXT_ERROR = "Couldn't find a schedule context.";
-export const ScheduleUpdateContext = /*#__PURE__*/React.createContext({
-  scheduleUpdate() {
-    throw new Error(MISSING_CONTEXT_ERROR);
-  },
-  flushUpdates() {
-    throw new Error(MISSING_CONTEXT_ERROR);
-  }
-});
-
-/**
- * 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 function useScheduleUpdate(callback) {
-  const {
-    scheduleUpdate,
-    flushUpdates
-  } = React.useContext(ScheduleUpdateContext);
-  scheduleUpdate(callback);
-  React.useEffect(flushUpdates);
-}
-//# sourceMappingURL=useScheduleUpdate.js.map

package/lib/module/useScheduleUpdate.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["React","MISSING_CONTEXT_ERROR","ScheduleUpdateContext","createContext","scheduleUpdate","Error","flushUpdates","useScheduleUpdate","callback","useContext","useEffect"],"sourceRoot":"../../src","sources":["useScheduleUpdate.tsx"],"mappings":"AAAA,OAAO,KAAKA,KAAK,MAAM,OAAO;AAE9B,MAAMC,qBAAqB,GAAG,mCAAmC;AAEjE,OAAO,MAAMC,qBAAqB,gBAAGF,KAAK,CAACG,aAAa,CAGrD;EACDC,cAAc,GAAG;IACf,MAAM,IAAIC,KAAK,CAACJ,qBAAqB,CAAC;EACxC,CAAC;EACDK,YAAY,GAAG;IACb,MAAM,IAAID,KAAK,CAACJ,qBAAqB,CAAC;EACxC;AACF,CAAC,CAAC;;AAEF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASM,iBAAiB,CAACC,QAAoB,EAAE;EACtD,MAAM;IAAEJ,cAAc;IAAEE;EAAa,CAAC,GAAGN,KAAK,CAACS,UAAU,CACvDP,qBAAqB,CACtB;EAEDE,cAAc,CAACI,QAAQ,CAAC;EAExBR,KAAK,CAACU,SAAS,CAACJ,YAAY,CAAC;AAC/B"}

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

@@ -1,14 +0,0 @@
-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 declare function useScheduleUpdate(callback: () => void): void;
-//# sourceMappingURL=useScheduleUpdate.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"useScheduleUpdate.d.ts","sourceRoot":"","sources":["../../../src/useScheduleUpdate.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,eAAO,MAAM,qBAAqB;+BACL,MAAM,IAAI,KAAK,IAAI;kBAChC,MAAM,IAAI;EAQxB,CAAC;AAEH;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,IAAI,QAQrD"}

package/src/useScheduleUpdate.tsx

@@ -1,32 +0,0 @@
-import * as React from 'react';
-
-const MISSING_CONTEXT_ERROR = "Couldn't find a schedule context.";
-
-export const ScheduleUpdateContext = React.createContext<{
-  scheduleUpdate: (callback: () => void) => void;
-  flushUpdates: () => void;
-}>({
-  scheduleUpdate() {
-    throw new Error(MISSING_CONTEXT_ERROR);
-  },
-  flushUpdates() {
-    throw new Error(MISSING_CONTEXT_ERROR);
-  },
-});
-
-/**
- * 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 function useScheduleUpdate(callback: () => void) {
-  const { scheduleUpdate, flushUpdates } = React.useContext(
-    ScheduleUpdateContext
-  );
-
-  scheduleUpdate(callback);
-
-  React.useEffect(flushUpdates);
-}