@react-navigation/core 8.0.0-alpha.4 → 8.0.0-alpha.40

package/src/getStateFromRouteParams.tsx

@@ -0,0 +1,59 @@
+import type { NavigationState, PartialState } from '@react-navigation/routers';
+
+export function getStateFromRouteParams(
+  params: object | undefined
+): PartialState<NavigationState> | NavigationState | undefined {
+  if (params == null || typeof params !== 'object') {
+    return undefined;
+  }
+
+  if (
+    'state' in params &&
+    params.state &&
+    typeof params.state === 'object' &&
+    'routes' in params.state &&
+    Array.isArray(params.state.routes) &&
+    params.state.routes.every(
+      (route) =>
+        typeof route === 'object' &&
+        route != null &&
+        'name' in route &&
+        typeof route.name === 'string'
+    )
+  ) {
+    // @ts-expect-error this is fine 🔥
+    return params.state;
+  }
+
+  if (
+    'screen' in params &&
+    params.screen &&
+    typeof params.screen === 'string'
+  ) {
+    return {
+      routes: [
+        {
+          name: params.screen,
+          params:
+            'params' in params &&
+            typeof params.params === 'object' &&
+            params.params != null
+              ? params.params
+              : undefined,
+          path:
+            'path' in params && typeof params.path === 'string'
+              ? params.path
+              : undefined,
+          state:
+            'params' in params &&
+            typeof params.params === 'object' &&
+            params.params != null
+              ? getStateFromRouteParams(params.params)
+              : undefined,
+        },
+      ],
+    };
+  }
+
+  return undefined;
+}

package/src/index.tsx

@@ -1,40 +1,90 @@
 export { BaseNavigationContainer } from './BaseNavigationContainer';
 export { createNavigationContainerRef } from './createNavigationContainerRef';
-export { createNavigatorFactory } from './createNavigatorFactory';
-export { CurrentRenderContext } from './CurrentRenderContext';
+export {
+  createNavigatorFactory,
+  type TypedNavigatorFactory,
+} from './createNavigatorFactory';
+export { getLoaderForState as UNSTABLE_getLoaderForState } from './DataLoading';
 export { findFocusedRoute } from './findFocusedRoute';
 export { getActionFromState } from './getActionFromState';
 export { getFocusedRouteNameFromRoute } from './getFocusedRouteNameFromRoute';
 export { getPathFromState } from './getPathFromState';
 export { getStateFromPath } from './getStateFromPath';
 export { NavigationContainerRefContext } from './NavigationContainerRefContext';
+export {
+  type FocusedRouteState,
+  NavigationFocusedRouteStateContext,
+} from './NavigationFocusedRouteStateContext';
 export { NavigationHelpersContext } from './NavigationHelpersContext';
 export { NavigationIndependentTree } from './NavigationIndependentTree';
-export { NavigationMetaContext } from './NavigationMetaContext';
 export {
+  IsScreenContext,
   NavigationContext,
   NavigationProvider,
   NavigationRouteContext,
 } from './NavigationProvider';
+export { NavigationRootContext } from './NavigationRootContext';
 export { PreventRemoveContext } from './PreventRemoveContext';
 export { PreventRemoveProvider } from './PreventRemoveProvider';
 export {
-  createComponentForStaticNavigation,
   createPathConfigForStaticNavigation,
+  createScreenFactory,
   type StaticConfig,
   type StaticNavigation,
   type StaticParamList,
   type StaticScreenConfig,
   type StaticScreenConfigLinking,
   type StaticScreenConfigScreen,
+  type StaticScreenFactory,
   type StaticScreenProps,
 } from './StaticNavigation';
 export { ThemeContext } from './theming/ThemeContext';
 export { ThemeProvider } from './theming/ThemeProvider';
 export { useTheme } from './theming/useTheme';
-export * from './types';
+export type {
+  CompositeNavigationProp,
+  CompositeScreenProps,
+  DefaultNavigatorOptions,
+  Descriptor,
+  EventArg,
+  EventConsumer,
+  EventEmitter,
+  EventListenerCallback,
+  EventMapBase,
+  EventMapCore,
+  GenericNavigation,
+  NavigationContainerEventMap,
+  NavigationContainerProps,
+  NavigationContainerRef,
+  NavigationContainerRefWithCurrent,
+  NavigationHelpers,
+  NavigationListBase,
+  NavigationListForNavigator,
+  NavigationListForNested,
+  NavigationProp,
+  NavigatorScreenParams,
+  NavigatorTypeBagBase,
+  NavigatorTypeBagFor,
+  NestedNavigatorsForParamList,
+  ParamListForNavigator,
+  PathConfig,
+  PathConfigMap,
+  RootNavigator,
+  RootParamList,
+  RouteConfig,
+  RouteConfigComponent,
+  RouteConfigProps,
+  RouteForName,
+  RouteGroupConfig,
+  RouteProp,
+  ScreenLayoutArgs,
+  ScreenListeners,
+  Theme,
+  TypedNavigator,
+} from './types';
+export { PrivateValueStore } from './types';
 export { useFocusEffect } from './useFocusEffect';
-export { useIsFocused } from './useIsFocused';
+export { IsFocusedContext, useIsFocused } from './useIsFocused';
 export { useNavigation } from './useNavigation';
 export { useNavigationBuilder } from './useNavigationBuilder';
 export { useNavigationContainerRef } from './useNavigationContainerRef';
@@ -44,5 +94,6 @@ export { usePreventRemove } from './usePreventRemove';
 export { usePreventRemoveContext } from './usePreventRemoveContext';
 export { useRoute } from './useRoute';
 export { useStateForPath } from './useStateForPath';
+export type { QueryParamInput, StandardSchemaV1 } from './utilities';
 export { validatePathConfig } from './validatePathConfig';
 export * from '@react-navigation/routers';

package/src/internal.tsx

@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface Theme {}

package/src/isRecordEqual.tsx

@@ -16,5 +16,7 @@ export function isRecordEqual(
     return false;
   }
 
-  return aKeys.every((key) => Object.is(a[key], b[key]));
+  return aKeys.every(
+    (key) => Object.hasOwn(b, key) && Object.is(a[key], b[key])
+  );
 }

package/src/queryString.ts

@@ -0,0 +1,109 @@
+type QueryValue = string | null | (string | null)[];
+
+// Match complete UTF-8 sequences so malformed input can be decoded partially
+// without repeatedly splitting and retrying an arbitrarily long byte sequence.
+const ENCODED_UTF8 = new RegExp(
+  [
+    '%[0-7][\\dA-F]',
+    '%(?:C[2-9A-F]|D[\\dA-F])%[89AB][\\dA-F]',
+    '%E0%[AB][\\dA-F]%[89AB][\\dA-F]',
+    '%E[1-9A-CEF](?:%[89AB][\\dA-F]){2}',
+    '%ED%[89][\\dA-F]%[89AB][\\dA-F]',
+    '%F0%[9AB][\\dA-F](?:%[89AB][\\dA-F]){2}',
+    '%F[1-3](?:%[89AB][\\dA-F]){3}',
+    '%F4%8[\\dA-F](?:%[89AB][\\dA-F]){2}',
+  ].join('|'),
+  'gi'
+);
+
+const decode = (value: string) => {
+  if (!value.includes('%')) {
+    return value;
+  }
+
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value.replace(ENCODED_UTF8, (sequence) =>
+      decodeURIComponent(sequence)
+    );
+  }
+};
+
+const encode = (value: string) => {
+  if (/^[A-Za-z0-9_.~-]*$/.test(value)) {
+    return value;
+  }
+
+  return encodeURIComponent(value).replace(
+    /[!'()*]/g,
+    (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+};
+
+export function parse(query: string): Record<string, QueryValue> {
+  const params: Record<string, QueryValue> = Object.create(null);
+
+  query = query.trim().replace(/^[?#&]/, '');
+
+  let start = 0;
+
+  while (start < query.length) {
+    if (query[start] === '&') {
+      start++;
+      continue;
+    }
+
+    const end = query.indexOf('&', start);
+    const index = end === -1 ? query.length : end;
+    const part = query.slice(start, index).replace(/\+/g, ' ');
+    const separator = part.indexOf('=');
+    const key = decode(separator === -1 ? part : part.slice(0, separator));
+    const value = separator === -1 ? null : decode(part.slice(separator + 1));
+    const previous = params[key];
+
+    if (previous === undefined) {
+      params[key] = value;
+    } else if (Array.isArray(previous)) {
+      previous.push(value);
+    } else {
+      params[key] = [previous, value];
+    }
+
+    start = index + 1;
+  }
+
+  return params;
+}
+
+export function stringify(
+  params: Record<string, string | string[] | null>
+): string {
+  const parts: string[] = [];
+
+  for (const [key, value] of Object.entries(params)) {
+    if (Array.isArray(value)) {
+      let encodedKey: string | undefined;
+
+      value.forEach((item) => {
+        encodedKey ??= encode(key);
+
+        parts.push(`${encodedKey}=${encode(item)}`);
+      });
+
+      continue;
+    }
+
+    const encodedKey = encode(key);
+
+    if (value === null) {
+      if (encodedKey) {
+        parts.push(encodedKey);
+      }
+    } else {
+      parts.push(`${encodedKey}=${encode(value)}`);
+    }
+  }
+
+  return parts.join('&');
+}

package/src/theming/useTheme.tsx

@@ -3,7 +3,7 @@ import * as React from 'react';
 import { ThemeContext } from './ThemeContext';
 
 export function useTheme() {
-  const theme = React.useContext(ThemeContext);
+  const theme = React.use(ThemeContext);
 
   if (theme == null) {
     throw new Error(