@react-navigation/core 6.0.2

package/src/SceneView.tsx

@@ -0,0 +1,134 @@
+import type {
+  NavigationState,
+  ParamListBase,
+  PartialState,
+  Route,
+} from '@react-navigation/routers';
+import * as React from 'react';
+
+import EnsureSingleNavigator from './EnsureSingleNavigator';
+import NavigationStateContext from './NavigationStateContext';
+import StaticContainer from './StaticContainer';
+import type { NavigationProp, RouteConfigComponent } from './types';
+import useOptionsGetters from './useOptionsGetters';
+
+type Props<State extends NavigationState, ScreenOptions extends {}> = {
+  screen: RouteConfigComponent<ParamListBase, string> & { name: string };
+  navigation: NavigationProp<ParamListBase, string, State, ScreenOptions>;
+  route: Route<string>;
+  routeState: NavigationState | PartialState<NavigationState> | undefined;
+  getState: () => State;
+  setState: (state: State) => void;
+  options: object;
+  clearOptions: () => void;
+};
+
+/**
+ * Component which takes care of rendering the screen for a route.
+ * It provides all required contexts and applies optimizations when applicable.
+ */
+export default function SceneView<
+  State extends NavigationState,
+  ScreenOptions extends {}
+>({
+  screen,
+  route,
+  navigation,
+  routeState,
+  getState,
+  setState,
+  options,
+  clearOptions,
+}: Props<State, ScreenOptions>) {
+  const navigatorKeyRef = React.useRef<string | undefined>();
+  const getKey = React.useCallback(() => navigatorKeyRef.current, []);
+
+  const { addOptionsGetter } = useOptionsGetters({
+    key: route.key,
+    options,
+    navigation,
+  });
+
+  const setKey = React.useCallback((key: string) => {
+    navigatorKeyRef.current = key;
+  }, []);
+
+  const getCurrentState = React.useCallback(() => {
+    const state = getState();
+    const currentRoute = state.routes.find((r) => r.key === route.key);
+
+    return currentRoute ? currentRoute.state : undefined;
+  }, [getState, route.key]);
+
+  const setCurrentState = React.useCallback(
+    (child: NavigationState | PartialState<NavigationState> | undefined) => {
+      const state = getState();
+
+      setState({
+        ...state,
+        routes: state.routes.map((r) =>
+          r.key === route.key ? { ...r, state: child } : r
+        ),
+      });
+    },
+    [getState, route.key, setState]
+  );
+
+  const isInitialRef = React.useRef(true);
+
+  React.useEffect(() => {
+    isInitialRef.current = false;
+  });
+
+  // Clear options set by this screen when it is unmounted
+  React.useEffect(() => {
+    return clearOptions;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const getIsInitial = React.useCallback(() => isInitialRef.current, []);
+
+  const context = React.useMemo(
+    () => ({
+      state: routeState,
+      getState: getCurrentState,
+      setState: setCurrentState,
+      getKey,
+      setKey,
+      getIsInitial,
+      addOptionsGetter,
+    }),
+    [
+      routeState,
+      getCurrentState,
+      setCurrentState,
+      getKey,
+      setKey,
+      getIsInitial,
+      addOptionsGetter,
+    ]
+  );
+
+  const ScreenComponent = screen.getComponent
+    ? screen.getComponent()
+    : screen.component;
+
+  return (
+    <NavigationStateContext.Provider value={context}>
+      <EnsureSingleNavigator>
+        <StaticContainer
+          name={screen.name}
+          render={ScreenComponent || screen.children}
+          navigation={navigation}
+          route={route}
+        >
+          {ScreenComponent !== undefined ? (
+            <ScreenComponent navigation={navigation} route={route} />
+          ) : screen.children !== undefined ? (
+            screen.children({ navigation, route })
+          ) : null}
+        </StaticContainer>
+      </EnsureSingleNavigator>
+    </NavigationStateContext.Provider>
+  );
+}

package/src/Screen.tsx

@@ -0,0 +1,17 @@
+import type { NavigationState, ParamListBase } from '@react-navigation/routers';
+
+import type { EventMapBase, RouteConfig } from './types';
+
+/**
+ * Empty component used for specifying route configuration.
+ */
+export default function Screen<
+  ParamList extends ParamListBase,
+  RouteName extends keyof ParamList,
+  State extends NavigationState,
+  ScreenOptions extends {},
+  EventMap extends EventMapBase
+>(_: RouteConfig<ParamList, RouteName, State, ScreenOptions, EventMap>) {
+  /* istanbul ignore next */
+  return null;
+}

package/src/StaticContainer.tsx

@@ -0,0 +1,29 @@
+import * as React from 'react';
+
+/**
+ * Component which prevents updates for children if no props changed
+ */
+function StaticContainer(props: any) {
+  return props.children;
+}
+
+export default React.memo(StaticContainer, (prevProps: any, nextProps: any) => {
+  const prevPropKeys = Object.keys(prevProps);
+  const nextPropKeys = Object.keys(nextProps);
+
+  if (prevPropKeys.length !== nextPropKeys.length) {
+    return false;
+  }
+
+  for (const key of prevPropKeys) {
+    if (key === 'children') {
+      continue;
+    }
+
+    if (prevProps[key] !== nextProps[key]) {
+      return false;
+    }
+  }
+
+  return true;
+});

package/src/UnhandledActionContext.tsx

@@ -0,0 +1,9 @@
+import type { NavigationAction } from '@react-navigation/routers';
+import * as React from 'react';
+
+const UnhandledActionContext =
+  React.createContext<((action: NavigationAction) => void) | undefined>(
+    undefined
+  );
+
+export default UnhandledActionContext;

package/src/checkDuplicateRouteNames.tsx

@@ -0,0 +1,33 @@
+import type { NavigationState, PartialState } from '@react-navigation/routers';
+
+export default function checkDuplicateRouteNames(state: NavigationState) {
+  const duplicates: string[][] = [];
+
+  const getRouteNames = (
+    location: string,
+    state: NavigationState | PartialState<NavigationState>
+  ) => {
+    state.routes.forEach((route: typeof state.routes[0]) => {
+      const currentLocation = location
+        ? `${location} > ${route.name}`
+        : route.name;
+
+      route.state?.routeNames?.forEach((routeName) => {
+        if (routeName === route.name) {
+          duplicates.push([
+            currentLocation,
+            `${currentLocation} > ${route.name}`,
+          ]);
+        }
+      });
+
+      if (route.state) {
+        getRouteNames(currentLocation, route.state);
+      }
+    });
+  };
+
+  getRouteNames('', state);
+
+  return duplicates;
+}

package/src/checkSerializable.tsx

@@ -0,0 +1,74 @@
+const checkSerializableWithoutCircularReference = (
+  o: { [key: string]: any },
+  seen: Set<any>,
+  location: (string | number)[]
+):
+  | { serializable: true }
+  | {
+      serializable: false;
+      location: (string | number)[];
+      reason: string;
+    } => {
+  if (
+    o === undefined ||
+    o === null ||
+    typeof o === 'boolean' ||
+    typeof o === 'number' ||
+    typeof o === 'string'
+  ) {
+    return { serializable: true };
+  }
+
+  if (
+    Object.prototype.toString.call(o) !== '[object Object]' &&
+    !Array.isArray(o)
+  ) {
+    return {
+      serializable: false,
+      location,
+      reason: typeof o === 'function' ? 'Function' : String(o),
+    };
+  }
+
+  if (seen.has(o)) {
+    return {
+      serializable: false,
+      reason: 'Circular reference',
+      location,
+    };
+  }
+
+  seen.add(o);
+
+  if (Array.isArray(o)) {
+    for (let i = 0; i < o.length; i++) {
+      const childResult = checkSerializableWithoutCircularReference(
+        o[i],
+        new Set<any>(seen),
+        [...location, i]
+      );
+
+      if (!childResult.serializable) {
+        return childResult;
+      }
+    }
+  } else {
+    for (const key in o) {
+      const childResult = checkSerializableWithoutCircularReference(
+        o[key],
+        new Set<any>(seen),
+        [...location, key]
+      );
+
+      if (!childResult.serializable) {
+        return childResult;
+      }
+    }
+  }
+
+  return { serializable: true };
+};
+
+export default function checkSerializable(o: { [key: string]: any }) {
+  return checkSerializableWithoutCircularReference(o, new Set<any>(), []);
+}

package/src/createNavigationContainerRef.tsx

@@ -0,0 +1,97 @@
+import { CommonActions } from '@react-navigation/routers';
+
+import type {
+  NavigationContainerEventMap,
+  NavigationContainerRef,
+  NavigationContainerRefWithCurrent,
+} from './types';
+
+export const NOT_INITIALIZED_ERROR =
+  "The 'navigation' object hasn't been initialized yet. This might happen if you don't have a navigator mounted, or if the navigator hasn't finished mounting. See https://reactnavigation.org/docs/navigating-without-navigation-prop#handling-initialization for more details.";
+
+export default function createNavigationContainerRef<
+  ParamList extends {} = ReactNavigation.RootParamList
+>(): NavigationContainerRefWithCurrent<ParamList> {
+  const methods = [
+    ...Object.keys(CommonActions),
+    'addListener',
+    'removeListener',
+    'resetRoot',
+    'dispatch',
+    'isFocused',
+    'canGoBack',
+    'getRootState',
+    'getState',
+    'getParent',
+    'getCurrentRoute',
+    'getCurrentOptions',
+  ] as const;
+
+  const listeners: Record<string, ((...args: any[]) => void)[]> = {};
+
+  const removeListener = (
+    event: string,
+    callback: (...args: any[]) => void
+  ) => {
+    listeners[event] = listeners[event]?.filter((cb) => cb !== callback);
+  };
+
+  let current: NavigationContainerRef<ParamList> | null = null;
+
+  const ref: NavigationContainerRefWithCurrent<ParamList> = {
+    get current() {
+      return current;
+    },
+    set current(value: NavigationContainerRef<ParamList> | null) {
+      current = value;
+
+      if (value != null) {
+        Object.entries(listeners).forEach(([event, callbacks]) => {
+          callbacks.forEach((callback) => {
+            value.addListener(
+              event as keyof NavigationContainerEventMap,
+              callback
+            );
+          });
+        });
+      }
+    },
+    isReady: () => {
+      if (current == null) {
+        return false;
+      }
+
+      return current.isReady();
+    },
+    ...methods.reduce<any>((acc, name) => {
+      acc[name] = (...args: any[]) => {
+        if (current == null) {
+          switch (name) {
+            case 'addListener': {
+              const [event, callback] = args;
+
+              listeners[event] = listeners[event] || [];
+              listeners[event].push(callback);
+
+              return () => removeListener(event, callback);
+            }
+            case 'removeListener': {
+              const [event, callback] = args;
+
+              removeListener(event, callback);
+              break;
+            }
+            default:
+              console.error(NOT_INITIALIZED_ERROR);
+          }
+        } else {
+          // @ts-expect-error: this is ok
+          return current[name](...args);
+        }
+      };
+      return acc;
+    }, {}),
+  };
+
+  return ref;
+}

package/src/createNavigatorFactory.tsx

@@ -0,0 +1,40 @@
+import type { NavigationState, ParamListBase } from '@react-navigation/routers';
+import type * as React from 'react';
+
+import Group from './Group';
+import Screen from './Screen';
+import type { EventMapBase, TypedNavigator } from './types';
+
+/**
+ * Higher order component to create a `Navigator` and `Screen` pair.
+ * Custom navigators should wrap the navigator component in `createNavigator` before exporting.
+ *
+ * @param Navigator The navigtor component to wrap.
+ * @returns Factory method to create a `Navigator` and `Screen` pair.
+ */
+export default function createNavigatorFactory<
+  State extends NavigationState,
+  ScreenOptions extends {},
+  EventMap extends EventMapBase,
+  NavigatorComponent extends React.ComponentType<any>
+>(Navigator: NavigatorComponent) {
+  return function <ParamList extends ParamListBase>(): TypedNavigator<
+    ParamList,
+    State,
+    ScreenOptions,
+    EventMap,
+    typeof Navigator
+  > {
+    if (arguments[0] !== undefined) {
+      throw new Error(
+        "Creating a navigator doesn't take an argument. Maybe you are trying to use React Navigation 4 API? See https://reactnavigation.org/docs/hello-react-navigation for the latest API and guides."
+      );
+    }
+
+    return {
+      Navigator,
+      Group,
+      Screen,
+    };
+  };
+}

package/src/findFocusedRoute.tsx

@@ -0,0 +1,13 @@
+import type { InitialState } from '@react-navigation/routers';
+
+export default function findFocusedRoute(state: InitialState) {
+  let current: InitialState | undefined = state;
+
+  while (current?.routes[current.index ?? 0].state != null) {
+    current = current.routes[current.index ?? 0].state;
+  }
+
+  const route = current?.routes[current?.index ?? 0];
+
+  return route;
+}

package/src/fromEntries.tsx

@@ -0,0 +1,13 @@
+// Object.fromEntries is not available in older iOS versions
+export default function fromEntries<K extends string, V>(
+  entries: (readonly [K, V])[]
+) {
+  return entries.reduce((acc, [k, v]) => {
+    if (acc.hasOwnProperty(k)) {
+      throw new Error(`A value for key '${k}' already exists in the object.`);
+    }
+
+    acc[k] = v;
+    return acc;
+  }, {} as Record<K, V>);
+}

package/src/getActionFromState.tsx

@@ -0,0 +1,154 @@
+import type {
+  CommonActions,
+  NavigationState,
+  ParamListBase,
+  PartialRoute,
+  PartialState,
+  Route,
+} from '@react-navigation/routers';
+
+import type { NavigatorScreenParams, PathConfig, PathConfigMap } from './types';
+
+type ConfigItem = {
+  initialRouteName?: string;
+  screens?: Record<string, ConfigItem>;
+};
+
+type Options = {
+  initialRouteName?: string;
+  screens: PathConfigMap<object>;
+};
+
+type NavigateAction<State extends NavigationState> = {
+  type: 'NAVIGATE';
+  payload: {
+    name: string;
+    params?: NavigatorScreenParams<State>;
+    path?: string;
+  };
+};
+
+export default function getActionFromState(
+  state: PartialState<NavigationState>,
+  options?: Options
+): NavigateAction<NavigationState> | CommonActions.Action | undefined {
+  // Create a normalized configs object which will be easier to use
+  const normalizedConfig = options
+    ? createNormalizedConfigItem(options as PathConfig<object> | string)
+    : {};
+
+  const routes =
+    state.index != null ? state.routes.slice(0, state.index + 1) : state.routes;
+
+  if (routes.length === 0) {
+    return undefined;
+  }
+
+  if (
+    !(
+      (routes.length === 1 && routes[0].key === undefined) ||
+      (routes.length === 2 &&
+        routes[0].key === undefined &&
+        routes[0].name === normalizedConfig?.initialRouteName &&
+        routes[1].key === undefined)
+    )
+  ) {
+    return {
+      type: 'RESET',
+      payload: state,
+    };
+  }
+
+  const route = state.routes[state.index ?? state.routes.length - 1];
+
+  let current: PartialState<NavigationState> | undefined = route?.state;
+  let config: ConfigItem | undefined = normalizedConfig?.screens?.[route?.name];
+  let params = { ...route.params } as NavigatorScreenParams<
+    ParamListBase,
+    NavigationState
+  >;
+
+  let payload = route
+    ? { name: route.name, path: route.path, params }
+    : undefined;
+
+  while (current) {
+    if (current.routes.length === 0) {
+      return undefined;
+    }
+
+    const routes =
+      current.index != null
+        ? current.routes.slice(0, current.index + 1)
+        : current.routes;
+
+    const route: Route<string> | PartialRoute<Route<string>> =
+      routes[routes.length - 1];
+
+    // Explicitly set to override existing value when merging params
+    Object.assign(params, {
+      initial: undefined,
+      screen: undefined,
+      params: undefined,
+      state: undefined,
+    });
+
+    if (routes.length === 1 && routes[0].key === undefined) {
+      params.initial = true;
+      params.screen = route.name;
+    } else if (
+      routes.length === 2 &&
+      routes[0].key === undefined &&
+      routes[0].name === config?.initialRouteName &&
+      routes[1].key === undefined
+    ) {
+      params.initial = false;
+      params.screen = route.name;
+    } else {
+      params.state = current;
+      break;
+    }
+
+    if (route.state) {
+      params.params = { ...route.params };
+      params = params.params as NavigatorScreenParams<
+        ParamListBase,
+        NavigationState
+      >;
+    } else {
+      params.path = route.path;
+      params.params = route.params;
+    }
+
+    current = route.state;
+    config = config?.screens?.[route.name];
+  }
+
+  if (!payload) {
+    return;
+  }
+
+  // Try to construct payload for a `NAVIGATE` action from the state
+  // This lets us preserve the navigation state and not lose it
+  return {
+    type: 'NAVIGATE',
+    payload,
+  };
+}
+
+const createNormalizedConfigItem = (config: PathConfig<object> | string) =>
+  typeof config === 'object' && config != null
+    ? {
+        initialRouteName: config.initialRouteName,
+        screens:
+          config.screens != null
+            ? createNormalizedConfigs(config.screens)
+            : undefined,
+      }
+    : {};
+
+const createNormalizedConfigs = (options: PathConfigMap<object>) =>
+  Object.entries(options).reduce<Record<string, ConfigItem>>((acc, [k, v]) => {
+    acc[k] = createNormalizedConfigItem(v);
+    return acc;
+  }, {});

package/src/getFocusedRouteNameFromRoute.tsx

@@ -0,0 +1,28 @@
+import type { Route } from '@react-navigation/routers';
+
+import { CHILD_STATE } from './useRouteCache';
+
+export default function getFocusedRouteNameFromRoute(
+  route: Partial<Route<string>>
+): string | undefined {
+  // @ts-expect-error: this isn't in type definitions coz we want this private
+  const state = route[CHILD_STATE] ?? route.state;
+  const params = route.params as { screen?: unknown } | undefined;
+
+  const routeName = state
+    ? // Get the currently active route name in the nested navigator
+      state.routes[
+        // If we have a partial state without index, for tab/drawer, first screen will be focused one, and last for stack
+        // The type property will only exist for rehydrated state and not for state from deep link
+        state.index ??
+          (typeof state.type === 'string' && state.type !== 'stack'
+            ? 0
+            : state.routes.length - 1)
+      ].name
+    : // If state doesn't exist, we need to default to `screen` param if available
+    typeof params?.screen === 'string'
+    ? params.screen
+    : undefined;
+
+  return routeName;
+}