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

package/src/useSyncState.tsx

@@ -24,12 +24,29 @@ const createStore = <T,>(getInitialState: () => T) => {
   let isBatching = false;
   let didUpdate = false;
 
+  const notify = () => {
+    let error: { value: unknown } | undefined;
+
+    listeners.forEach((listener) => {
+      try {
+        listener();
+      } catch (e) {
+        error = error ?? { value: e };
+      }
+    });
+
+    if (error) {
+      throw error.value;
+    }
+  };
+
   const setState = (newState: T) => {
     state = deepFreeze(newState);
-    didUpdate = true;
 
-    if (!isBatching) {
-      listeners.forEach((listener) => listener());
+    if (isBatching) {
+      didUpdate = true;
+    } else {
+      notify();
     }
   };
 
@@ -43,12 +60,16 @@ const createStore = <T,>(getInitialState: () => T) => {
 
   const batchUpdates = (callback: () => void) => {
     isBatching = true;
-    callback();
-    isBatching = false;
 
-    if (didUpdate) {
-      didUpdate = false;
-      listeners.forEach((listener) => listener());
+    try {
+      callback();
+    } finally {
+      isBatching = false;
+
+      if (didUpdate) {
+        didUpdate = false;
+        notify();
+      }
     }
   };
 
@@ -87,21 +108,23 @@ export function useSyncState<T>(getInitialState: () => T) {
     return unsubscribe;
   }, [store]);
 
-  const pendingUpdatesRef = React.useRef<(() => void)[]>([]);
+  const pendingUpdates = useLazyValue(() => new Set<() => void>());
 
   const scheduleUpdate = useLatestCallback((callback: () => void) => {
-    pendingUpdatesRef.current.push(callback);
+    pendingUpdates.add(callback);
   });
 
   const flushUpdates = useLatestCallback(() => {
-    const pendingUpdates = pendingUpdatesRef.current;
+    if (pendingUpdates.size !== 0) {
+      // Updates are queued child-first as insertion effects run bottom-up.
+      // The root navigator replaces the whole state while nested navigators merge into it.
+      // So we apply them root-first to avoid the root clobbering nested updates.
+      const callbacks = Array.from(pendingUpdates).reverse();
 
-    pendingUpdatesRef.current = [];
+      pendingUpdates.clear();
 
-    if (pendingUpdates.length !== 0) {
       store.batchUpdates(() => {
-        // Flush all the pending updates
-        for (const update of pendingUpdates) {
+        for (const update of callbacks) {
           update();
         }
       });
@@ -114,6 +137,7 @@ export function useSyncState<T>(getInitialState: () => T) {
     state,
     getState: store.getState,
     setState: store.setState,
+    subscribe: store.subscribe,
     scheduleUpdate,
     flushUpdates,
   } as const;

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.
  */
@@ -62,61 +120,119 @@ type StripRegex<Param extends string> = Param extends `${infer Name}(${string})`
 type ExtractSegmentParam<Segment extends string> =
   Segment extends `:${infer Param}?`
     ? { [K in StripRegex<Param>]?: string }
-    : Segment extends `:${infer Param}`
+    : Segment extends `:${infer Param}${'+' | '*'}`
       ? { [K in StripRegex<Param>]: string }
-      : {};
+      : Segment extends `:${infer Param}`
+        ? { [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 }`
  * Supports optional params with `?` suffix.
+ * Supports repeated params with `+` and `*` suffixes as strings.
  * Params must start with `:` at the beginning of a segment (after `/`).
  */
-export type ExtractParamStrings<Path extends string> =
+type ExtractParamStrings<Path extends string> =
   Path extends `${infer Segment}/${infer Rest}`
     ? ExtractSegmentParam<Segment> & ExtractParamStrings<Rest>
     : 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> = {
+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/NavigationMetaContext.js

@@ -1,15 +0,0 @@
-"use strict";
-
-import * as React from 'react';
-
-/**
- * Context with additional metadata to pass to child navigator in a screen.
- * For example, child native stack to know it's inside native tabs.
- * So it doesn't implement features such as `popToTop` that are handled by native tabs.
- *
- * Consumers should not make any assumptions about the shape of the object.
- * It can be different depending on the navigator and may change without notice.
- * This is not intended to be used by application code.
- */
-export const NavigationMetaContext = /*#__PURE__*/React.createContext(undefined);
-//# sourceMappingURL=NavigationMetaContext.js.map

package/lib/module/NavigationMetaContext.js.map

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

package/lib/module/checkSerializable.js

@@ -1,46 +0,0 @@
-"use strict";
-
-const checkSerializableWithoutCircularReference = (o, seen, location) => {
-  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(seen), [...location, i]);
-      if (!childResult.serializable) {
-        return childResult;
-      }
-    }
-  } else {
-    for (const key in o) {
-      const childResult = checkSerializableWithoutCircularReference(o[key], new Set(seen), [...location, key]);
-      if (!childResult.serializable) {
-        return childResult;
-      }
-    }
-  }
-  return {
-    serializable: true
-  };
-};
-export function checkSerializable(o) {
-  return checkSerializableWithoutCircularReference(o, new Set(), []);
-}
-//# sourceMappingURL=checkSerializable.js.map

package/lib/module/checkSerializable.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["checkSerializableWithoutCircularReference","o","seen","location","undefined","serializable","Object","prototype","toString","call","Array","isArray","reason","String","has","add","i","length","childResult","Set","key","checkSerializable"],"sourceRoot":"../../src","sources":["checkSerializable.tsx"],"mappings":";;AAAA,MAAMA,yCAAyC,GAAGA,CAChDC,CAAyB,EACzBC,IAAc,EACdC,QAA6B,KAOtB;EACP,IACEF,CAAC,KAAKG,SAAS,IACfH,CAAC,KAAK,IAAI,IACV,OAAOA,CAAC,KAAK,SAAS,IACtB,OAAOA,CAAC,KAAK,QAAQ,IACrB,OAAOA,CAAC,KAAK,QAAQ,EACrB;IACA,OAAO;MAAEI,YAAY,EAAE;IAAK,CAAC;EAC/B;EAEA,IACEC,MAAM,CAACC,SAAS,CAACC,QAAQ,CAACC,IAAI,CAACR,CAAC,CAAC,KAAK,iBAAiB,IACvD,CAACS,KAAK,CAACC,OAAO,CAACV,CAAC,CAAC,EACjB;IACA,OAAO;MACLI,YAAY,EAAE,KAAK;MACnBF,QAAQ;MACRS,MAAM,EAAE,OAAOX,CAAC,KAAK,UAAU,GAAG,UAAU,GAAGY,MAAM,CAACZ,CAAC;IACzD,CAAC;EACH;EAEA,IAAIC,IAAI,CAACY,GAAG,CAACb,CAAC,CAAC,EAAE;IACf,OAAO;MACLI,YAAY,EAAE,KAAK;MACnBO,MAAM,EAAE,oBAAoB;MAC5BT;IACF,CAAC;EACH;EAEAD,IAAI,CAACa,GAAG,CAACd,CAAC,CAAC;EAEX,IAAIS,KAAK,CAACC,OAAO,CAACV,CAAC,CAAC,EAAE;IACpB,KAAK,IAAIe,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGf,CAAC,CAACgB,MAAM,EAAED,CAAC,EAAE,EAAE;MACjC,MAAME,WAAW,GAAGlB,yCAAyC,CAC3DC,CAAC,CAACe,CAAC,CAAC,EACJ,IAAIG,GAAG,CAAMjB,IAAI,CAAC,EAClB,CAAC,GAAGC,QAAQ,EAAEa,CAAC,CACjB,CAAC;MAED,IAAI,CAACE,WAAW,CAACb,YAAY,EAAE;QAC7B,OAAOa,WAAW;MACpB;IACF;EACF,CAAC,MAAM;IACL,KAAK,MAAME,GAAG,IAAInB,CAAC,EAAE;MACnB,MAAMiB,WAAW,GAAGlB,yCAAyC,CAC3DC,CAAC,CAACmB,GAAG,CAAC,EACN,IAAID,GAAG,CAAMjB,IAAI,CAAC,EAClB,CAAC,GAAGC,QAAQ,EAAEiB,GAAG,CACnB,CAAC;MAED,IAAI,CAACF,WAAW,CAACb,YAAY,EAAE;QAC7B,OAAOa,WAAW;MACpB;IACF;EACF;EAEA,OAAO;IAAEb,YAAY,EAAE;EAAK,CAAC;AAC/B,CAAC;AAED,OAAO,SAASgB,iBAAiBA,CAACpB,CAAyB,EAAE;EAC3D,OAAOD,yCAAyC,CAACC,CAAC,EAAE,IAAIkB,GAAG,CAAM,CAAC,EAAE,EAAE,CAAC;AACzE","ignoreList":[]}

package/lib/module/useComponent.js

@@ -1,34 +0,0 @@
-"use strict";
-
-import * as React from 'react';
-import { jsx as _jsx } from "react/jsx-runtime";
-const NavigationContent = ({
-  render,
-  children
-}) => {
-  return render(children);
-};
-export function useComponent(render) {
-  const renderRef = React.useRef(render);
-
-  // Normally refs shouldn't be mutated in render
-  // But we return a component which will be rendered
-  // So it's just for immediate consumption
-  renderRef.current = render;
-  React.useEffect(() => {
-    renderRef.current = null;
-  });
-  return React.useRef(({
-    children
-  }) => {
-    const render = renderRef.current;
-    if (render === null) {
-      throw new Error('The returned component must be rendered in the same render phase as the hook.');
-    }
-    return /*#__PURE__*/_jsx(NavigationContent, {
-      render: render,
-      children: children
-    });
-  }).current;
-}
-//# sourceMappingURL=useComponent.js.map

package/lib/module/useComponent.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["React","jsx","_jsx","NavigationContent","render","children","useComponent","renderRef","useRef","current","useEffect","Error"],"sourceRoot":"../../src","sources":["useComponent.tsx"],"mappings":";;AAAA,OAAO,KAAKA,KAAK,MAAM,OAAO;AAAC,SAAAC,GAAA,IAAAC,IAAA;AAS/B,MAAMC,iBAAiB,GAAGA,CAAC;EAAEC,MAAM;EAAEC;AAAgB,CAAC,KAAK;EACzD,OAAOD,MAAM,CAACC,QAAQ,CAAC;AACzB,CAAC;AAED,OAAO,SAASC,YAAYA,CAACF,MAAc,EAAE;EAC3C,MAAMG,SAAS,GAAGP,KAAK,CAACQ,MAAM,CAAgBJ,MAAM,CAAC;;EAErD;EACA;EACA;EACAG,SAAS,CAACE,OAAO,GAAGL,MAAM;EAE1BJ,KAAK,CAACU,SAAS,CAAC,MAAM;IACpBH,SAAS,CAACE,OAAO,GAAG,IAAI;EAC1B,CAAC,CAAC;EAEF,OAAOT,KAAK,CAACQ,MAAM,CAAC,CAAC;IAAEH;EAAwC,CAAC,KAAK;IACnE,MAAMD,MAAM,GAAGG,SAAS,CAACE,OAAO;IAEhC,IAAIL,MAAM,KAAK,IAAI,EAAE;MACnB,MAAM,IAAIO,KAAK,CACb,+EACF,CAAC;IACH;IAEA,oBAAOT,IAAA,CAACC,iBAAiB;MAACC,MAAM,EAAEA,MAAO;MAAAC,QAAA,EAAEA;IAAQ,CAAoB,CAAC;EAC1E,CAAC,CAAC,CAACI,OAAO;AACZ","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"}