@react-navigation/core 8.0.0-alpha.3 → 8.0.0-alpha.30

package/src/utilities.tsx

@@ -15,6 +15,39 @@ export type KeysOf<T> = T extends {} ? keyof T : never;
  */
 export type KeyOf<T extends {}> = Extract<keyof T, string>;
 
+/**
+ * TS only checks object literals for excess properties when they are not generic.
+ * When an object is captured as a generic type, unknown keys are not caught.
+ * This builds a type from the provided object where any key not in the allowed type has the type `never`.
+ * Checking the provided object against this type then produces an error for each unknown key.
+ *
+ * When `Provided` has a string index signature (e.g. a type built from `any`,
+ * whose `keyof` includes `string`), there are no specific excess keys to flag,
+ * so this resolves to an empty type to avoid marking every key as `never`.
+ */
+export type NoExcessObject<Provided, Allowed> = string extends keyof Provided
+  ? {}
+  : Record<Exclude<keyof Provided, keyof Allowed>, never>;
+
+/**
+ * Check an object captured as a generic type against an allowed type,
+ * e.g. an object returned from a callback isn't checked for excess properties.
+ */
+export type NoExcessCallbackReturn<
+  Provided extends {},
+  Allowed extends {},
+> = Allowed & Provided & NoExcessObject<Provided, Allowed>;
+
+/**
+ * Apply excess property checking to a value,
+ * or to the return value if the value is a function.
+ */
+export type NoExcessValue<Provided, Allowed extends {}> = Provided extends (
+  ...args: never[]
+) => infer Return
+  ? (...args: never[]) => Allowed & NoExcessObject<Return, Allowed>
+  : NoExcessObject<Provided, Allowed>;
+
 /**
  * We get a union type when using keyof, but we want an intersection instead.
  * https://stackoverflow.com/a/50375286/1665026
@@ -25,8 +58,6 @@ export type UnionToIntersection<U> = (
   ? I
   : never;
 
-export type UnknownToUndefined<T> = unknown extends T ? undefined : T;
-
 /**
  * Exclude undefined from a type.
  * Similar to NonNullable but only excludes undefined, not null.
@@ -35,6 +66,33 @@ export type NotUndefined<T> = T extends undefined ? never : T;
 
 export type AnyToUnknown<T> = 0 extends 1 & T ? unknown : T;
 
+export type RequiredKeys<T extends object> = {
+  [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];
+
+type OptionalKeys<T extends object> = Exclude<keyof T, RequiredKeys<T>>;
+
+/**
+ * Remove `| undefined` from the object type,
+ * and adjust the optionality of the keys based on the original type.
+ */
+export type NotUndefinedObject<
+  T extends object | undefined,
+  O extends object = NotUndefined<T>,
+> = undefined extends T
+  ? {
+      [K in RequiredKeys<O>]: O[K];
+    } & {
+      [K in OptionalKeys<O>]?: O[K] | undefined;
+    }
+  : T;
+
+export type UndefinedIfAllOptional<T> = T extends object
+  ? RequiredKeys<T> extends never
+    ? T | undefined
+    : T
+  : T;
+
 /**
  * Check if a function type has arguments.
  */
@@ -66,6 +124,24 @@ type ExtractSegmentParam<Segment extends string> =
       ? { [K in StripRegex<Param>]: string }
       : {};
 
+export type StandardSchemaValidationResult<Output> =
+  | { value: Output; issues?: undefined }
+  | { value?: undefined; issues: readonly unknown[] };
+
+export type StandardSchemaV1<Input = unknown, Output = Input> = {
+  readonly '~standard': {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly validate: (
+      value: Input
+    ) =>
+      | StandardSchemaValidationResult<Output>
+      | Promise<StandardSchemaValidationResult<Output>>;
+  };
+};
+
+export type QueryParamInput = string | string[] | null | undefined;
+
 /**
  * Extract path params from a path string.
  * e.g. `/foo/:userId/:postId` -> `{ userId: string; postId: string }`
@@ -78,45 +154,82 @@ export type ExtractParamStrings<Path extends string> =
     : ExtractSegmentParam<Path>;
 
 /**
- * Extract the parsed params type from base params and parse functions.
- * Applies the return type of parse functions to the corresponding params.
+ * Get the type of params based on the `parse` config and the path pattern.
  */
 export type ExtractParamsType<Params, Parse> = {
+  /**
+   * Base param types from path pattern
+   * Refine the type based on standard schema, then parse function
+   * Otherwise, use the type from path pattern
+   */
   [K in keyof Params]: K extends keyof Parse
-    ? Parse[K] extends (value: string) => infer R
+    ? Parse[K] extends StandardSchemaV1<unknown, infer R>
       ? R
-      : Params[K]
+      : Parse[K] extends (value: string) => infer R
+        ? R
+        : Params[K]
     : Params[K];
-};
+} & // Query params are the parse keys not present in the path pattern. When there
+  // are none (the common case), skip building the query param mapped types.
+  ([Exclude<keyof Parse, keyof Params>] extends [never]
+    ? {}
+    : {
+        /**
+         * Optional param types not in path pattern (for query params)
+         */
+        [K in QueryParamOptionalKeys<Params, Parse>]?: QueryParamValue<
+          Parse[K]
+        >;
+      } & {
+        /**
+         * Required param types not in path pattern (for query params)
+         */
+        [K in QueryParamRequiredKeys<Params, Parse>]: QueryParamValue<Parse[K]>;
+      });
 
-/**
- * Infer the path string from a linking config.
- */
-export type InferPath<T> = T extends { path: infer P extends string }
-  ? P
-  : never;
+type QueryParamValue<ParseValue> =
+  ParseValue extends StandardSchemaV1<unknown, infer R>
+    ? R
+    : ParseValue extends (value: string) => infer R
+      ? R
+      : never;
 
 /**
- * Infer the parse functions from a linking config.
+ * For schema, it's optional if the output has `undefined`, otherwise required
+ * For parse function, it's always optional as it can't say if it's required or not
  */
-export type InferParse<T> = T extends { parse: infer P } ? P : {};
+type QueryParamOptionalKeys<Params, Parse> = {
+  [K in Exclude<keyof Parse, keyof Params>]: Parse[K] extends StandardSchemaV1<
+    unknown,
+    infer R
+  >
+    ? undefined extends R
+      ? K
+      : never
+    : Parse[K] extends (value: string) => unknown
+      ? K
+      : never;
+}[Exclude<keyof Parse, keyof Params>];
 
 /**
- * Infer the params type from a screen component or nested navigator.
+ * Exclude optional keys to get required keys
+ * For schema, it's required if the output doesn't have `undefined`, otherwise optional
+ * It doesn't include parse functions (as they are always optional)
  */
-export type InferScreenParams<T> =
-  T extends React.ComponentType<{ route: { params: infer P } }>
-    ? P
-    : T extends { config: { screens: infer Screens } }
-      ? import('./types').NavigatorScreenParams<{
-          [K in keyof Screens]: Screens[K] extends React.ComponentType<{
-            route: { params: infer P };
-          }>
-            ? P
-            : Screens[K] extends { screen: infer S }
-              ? S extends React.ComponentType<{ route: { params: infer P } }>
-                ? P
-                : undefined
-              : undefined;
-        }>
+type QueryParamRequiredKeys<Params, Parse> = Exclude<
+  Exclude<keyof Parse, keyof Params>,
+  QueryParamOptionalKeys<Params, Parse>
+>;
+
+export type InferParamsFromLinking<T> = T extends {
+  path: infer P extends string;
+  parse: infer Parse;
+}
+  ? UndefinedIfAllOptional<ExtractParamsType<ExtractParamStrings<P>, Parse>>
+  : T extends {
+        path: infer P extends string;
+      }
+    ? UndefinedIfAllOptional<ExtractParamStrings<P>>
+    : T extends string
+      ? UndefinedIfAllOptional<ExtractParamStrings<T>>
       : undefined;

package/src/validatePathConfig.tsx

@@ -1,23 +1,39 @@
-const formatToList = (items: Record<string, string>) =>
-  Object.entries(items)
-    .map(([key, value]) => `- ${key} (${value})`)
-    .join('\n');
+const ROOT_VALIDATION_LIST = [
+  '- path (string)',
+  '- initialRouteName (string)',
+  '- screens (object)',
+].join('\n');
 
-export function validatePathConfig(config: unknown, root = true) {
-  const validation = {
-    path: 'string',
-    initialRouteName: 'string',
-    screens: 'object',
-    ...(root
-      ? null
-      : {
-          alias: 'array',
-          exact: 'boolean',
-          stringify: 'object',
-          parse: 'object',
-        }),
-  };
+const NESTED_VALIDATION_LIST = [
+  ROOT_VALIDATION_LIST,
+  '- alias (array)',
+  '- exact (boolean)',
+  '- stringify (object)',
+  '- parse (object)',
+  '- shared (boolean)',
+].join('\n');
+
+const getValidationType = (key: string, root: boolean) => {
+  switch (key) {
+    case 'path':
+    case 'initialRouteName':
+      return 'string';
+    case 'screens':
+      return 'object';
+    case 'alias':
+      return root ? undefined : 'array';
+    case 'exact':
+    case 'shared':
+      return root ? undefined : 'boolean';
+    case 'stringify':
+    case 'parse':
+      return root ? undefined : 'object';
+    default:
+      return undefined;
+  }
+};
 
+export function validatePathConfig(config: unknown, root = true) {
   if (typeof config !== 'object' || config === null) {
     throw new Error(
       `Expected the configuration to be an object, but got ${JSON.stringify(
@@ -26,58 +42,71 @@ export function validatePathConfig(config: unknown, root = true) {
     );
   }
 
-  const validationErrors = Object.fromEntries(
-    Object.keys(config)
-      .map((key) => {
-        if (key in validation) {
-          const type = validation[key as keyof typeof validation];
-          // @ts-expect-error: we know the key exists
-          const value = config[key];
-
-          if (value !== undefined) {
-            if (type === 'array') {
-              if (!Array.isArray(value)) {
-                return [key, `expected 'Array', got '${typeof value}'`];
-              }
-            } else if (typeof value !== type) {
-              return [key, `expected '${type}', got '${typeof value}'`];
-            }
-          }
-        } else {
-          return [key, 'extraneous'];
-        }
-
-        return null;
-      })
-      .filter(Boolean) as [string, string][]
-  );
-
-  if (Object.keys(validationErrors).length) {
+  const pathConfig = config as Record<string, unknown>;
+
+  let validationErrors: string[] | undefined;
+
+  for (const key in pathConfig) {
+    const type = getValidationType(key, root);
+
+    if (type === undefined) {
+      (validationErrors ??= []).push(`- ${key} (extraneous)`);
+      continue;
+    }
+
+    const value = pathConfig[key];
+
+    if (value === undefined) {
+      continue;
+    }
+
+    if (type === 'array') {
+      if (!Array.isArray(value)) {
+        (validationErrors ??= []).push(
+          `- ${key} (expected 'Array', got '${typeof value}')`
+        );
+      }
+    } else if (typeof value !== type) {
+      (validationErrors ??= []).push(
+        `- ${key} (expected '${type}', got '${typeof value}')`
+      );
+    }
+  }
+
+  if (validationErrors) {
     throw new Error(
-      `Found invalid properties in the configuration:\n${formatToList(
-        validationErrors
-      )}\n\nYou can only specify the following properties:\n${formatToList(
-        validation
-      )}\n\nIf you want to specify configuration for screens, you need to specify them under a 'screens' property.\n\nSee https://reactnavigation.org/docs/configuring-links for more details on how to specify a linking configuration.`
+      `Found invalid properties in the configuration:\n${validationErrors.join(
+        '\n'
+      )}\n\nYou can only specify the following properties:\n${
+        root ? ROOT_VALIDATION_LIST : NESTED_VALIDATION_LIST
+      }\n\nIf you want to specify configuration for screens, you need to specify them under a 'screens' property.\n\nSee https://reactnavigation.org/docs/configuring-links for more details on how to specify a linking configuration.`
     );
   }
 
+  const path = pathConfig.path;
+
   if (
     root &&
-    'path' in config &&
-    typeof config.path === 'string' &&
-    config.path.includes(':')
+    'path' in pathConfig &&
+    typeof path === 'string' &&
+    path.includes(':')
   ) {
     throw new Error(
-      `Found invalid path '${config.path}'. The 'path' in the top-level configuration cannot contain patterns for params.`
+      `Found invalid path '${path}'. The 'path' in the top-level configuration cannot contain patterns for params.`
     );
   }
 
-  if ('screens' in config && config.screens) {
-    Object.entries(config.screens).forEach(([_, value]) => {
+  const screens = pathConfig.screens;
+
+  if (screens && typeof screens === 'object') {
+    const screenConfig = screens as Record<string, unknown>;
+
+    for (const name in screenConfig) {
+      const value = screenConfig[name];
+
       if (typeof value !== 'string') {
         validatePathConfig(value, false);
       }
-    });
+    }
   }
 }

package/lib/module/CurrentRenderContext.js

@@ -1,10 +0,0 @@
-"use strict";
-
-import * as React from 'react';
-
-/**
- * Context which holds the values for the current navigation tree.
- * Intended for use in SSR. This is not safe to use on the client.
- */
-export const CurrentRenderContext = /*#__PURE__*/React.createContext(undefined);
-//# sourceMappingURL=CurrentRenderContext.js.map

package/lib/module/CurrentRenderContext.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["React","CurrentRenderContext","createContext","undefined"],"sourceRoot":"../../src","sources":["CurrentRenderContext.tsx"],"mappings":";;AAAA,OAAO,KAAKA,KAAK,MAAM,OAAO;;AAE9B;AACA;AACA;AACA;AACA,OAAO,MAAMC,oBAAoB,gBAAGD,KAAK,CAACE,aAAa,CAErDC,SAAS,CAAC","ignoreList":[]}

package/lib/module/useCurrentRender.js

@@ -1,19 +0,0 @@
-"use strict";
-
-import * as React from 'react';
-import { CurrentRenderContext } from "./CurrentRenderContext.js";
-/**
- * Write the current options, so that server renderer can get current values
- * Mutating values like this is not safe in async mode, but it doesn't apply to SSR
- */
-export function useCurrentRender({
-  state,
-  navigation,
-  descriptors
-}) {
-  const current = React.useContext(CurrentRenderContext);
-  if (current && navigation.isFocused()) {
-    current.options = descriptors[state.routes[state.index].key].options;
-  }
-}
-//# sourceMappingURL=useCurrentRender.js.map

package/lib/module/useCurrentRender.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["React","CurrentRenderContext","useCurrentRender","state","navigation","descriptors","current","useContext","isFocused","options","routes","index","key"],"sourceRoot":"../../src","sources":["useCurrentRender.tsx"],"mappings":";;AACA,OAAO,KAAKA,KAAK,MAAM,OAAO;AAE9B,SAASC,oBAAoB,QAAQ,2BAAwB;AAiB7D;AACA;AACA;AACA;AACA,OAAO,SAASC,gBAAgBA,CAAC;EAAEC,KAAK;EAAEC,UAAU;EAAEC;AAAqB,CAAC,EAAE;EAC5E,MAAMC,OAAO,GAAGN,KAAK,CAACO,UAAU,CAACN,oBAAoB,CAAC;EAEtD,IAAIK,OAAO,IAAIF,UAAU,CAACI,SAAS,CAAC,CAAC,EAAE;IACrCF,OAAO,CAACG,OAAO,GAAGJ,WAAW,CAACF,KAAK,CAACO,MAAM,CAACP,KAAK,CAACQ,KAAK,CAAC,CAACC,GAAG,CAAC,CAACH,OAAO;EACtE;AACF","ignoreList":[]}

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

@@ -1,9 +0,0 @@
-import * as React from 'react';
-/**
- * Context which holds the values for the current navigation tree.
- * Intended for use in SSR. This is not safe to use on the client.
- */
-export declare const CurrentRenderContext: React.Context<{
-    options?: object;
-} | undefined>;
-//# sourceMappingURL=CurrentRenderContext.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"CurrentRenderContext.d.ts","sourceRoot":"","sources":["../../../src/CurrentRenderContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B;;;GAGG;AACH,eAAO,MAAM,oBAAoB;cACnB,MAAM;cACR,CAAC"}

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

@@ -1,14 +0,0 @@
-import type { NavigationState, ParamListBase } from '@react-navigation/routers';
-import type { Descriptor, NavigationHelpers, NavigationProp, RouteProp } from './types';
-type Options = {
-    state: NavigationState;
-    navigation: NavigationHelpers<ParamListBase>;
-    descriptors: Record<string, Descriptor<object, NavigationProp<ParamListBase>, RouteProp<ParamListBase>>>;
-};
-/**
- * Write the current options, so that server renderer can get current values
- * Mutating values like this is not safe in async mode, but it doesn't apply to SSR
- */
-export declare function useCurrentRender({ state, navigation, descriptors }: Options): void;
-export {};
-//# sourceMappingURL=useCurrentRender.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"useCurrentRender.d.ts","sourceRoot":"","sources":["../../../src/useCurrentRender.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAIhF,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,cAAc,EACd,SAAS,EACV,MAAM,SAAS,CAAC;AAEjB,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,eAAe,CAAC;IACvB,UAAU,EAAE,iBAAiB,CAAC,aAAa,CAAC,CAAC;IAC7C,WAAW,EAAE,MAAM,CACjB,MAAM,EACN,UAAU,CAAC,MAAM,EAAE,cAAc,CAAC,aAAa,CAAC,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC,CAC5E,CAAC;CACH,CAAC;AAEF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,EAAE,OAAO,QAM3E"}

package/src/CurrentRenderContext.tsx

@@ -1,9 +0,0 @@
-import * as React from 'react';
-
-/**
- * Context which holds the values for the current navigation tree.
- * Intended for use in SSR. This is not safe to use on the client.
- */
-export const CurrentRenderContext = React.createContext<
-  { options?: object } | undefined
->(undefined);

package/src/useCurrentRender.tsx

@@ -1,31 +0,0 @@
-import type { NavigationState, ParamListBase } from '@react-navigation/routers';
-import * as React from 'react';
-
-import { CurrentRenderContext } from './CurrentRenderContext';
-import type {
-  Descriptor,
-  NavigationHelpers,
-  NavigationProp,
-  RouteProp,
-} from './types';
-
-type Options = {
-  state: NavigationState;
-  navigation: NavigationHelpers<ParamListBase>;
-  descriptors: Record<
-    string,
-    Descriptor<object, NavigationProp<ParamListBase>, RouteProp<ParamListBase>>
-  >;
-};
-
-/**
- * Write the current options, so that server renderer can get current values
- * Mutating values like this is not safe in async mode, but it doesn't apply to SSR
- */
-export function useCurrentRender({ state, navigation, descriptors }: Options) {
-  const current = React.useContext(CurrentRenderContext);
-
-  if (current && navigation.isFocused()) {
-    current.options = descriptors[state.routes[state.index].key].options;
-  }
-}