@react-navigation/core 8.0.0-alpha.33 → 8.0.0-alpha.35

package/src/useNavigationState.tsx

@@ -6,6 +6,7 @@ import type { NavigationListForNested, RootNavigator } from './types';
 type NavigationStateEvent = 'update' | 'commit';
 
 type NavigationStateListener = {
+  initialStateContext: React.Context<NavigationState<ParamListBase>>;
   getState: () => NavigationState<ParamListBase>;
   getSnapshot: () => NavigationState<ParamListBase>;
   subscribe: (callback: (event: NavigationStateEvent) => void) => () => void;
@@ -83,6 +84,25 @@ export function useNavigationState(...args: unknown[]): unknown {
 
   const { getState, getSnapshot, subscribe } = listener;
 
+  const initialRef = React.useRef(true);
+
+  // We read the initial state from context on mount instead of using getState
+  // This ensures that we get proper state for the current render,
+  // even if the external store has been updated.
+  // We conditionally use `use` to avoid more unnecessary re-renders after first mount.
+  // The context subscription is removed on the next render, which can cause one extra render.
+  const initialState = initialRef.current
+    ? React.use(listener.initialStateContext)
+    : undefined;
+
+  // We track the last committed reducer entry, navigation state, and selector,
+  // so we can check if an update changes the value the component last committed.
+  const committedRef = React.useRef<{
+    entry: NavigationStateEntry | null;
+    state: NavigationState<ParamListBase>;
+    select: (state: NavigationState<ParamListBase>) => unknown;
+  }>({ entry: null, state: initialState ?? getSnapshot(), select });
+
   // The store can contain state from a transition that hasn't committed yet.
   // Reading it during render can show state that doesn't match the navigator in that render.
   // The reducer lets React process state in the same render lane as the navigator.
@@ -92,11 +112,28 @@ export function useNavigationState(...args: unknown[]): unknown {
       // Reading here ensures the processed event uses the state for that render.
       const state = event === 'update' ? getState() : getSnapshot();
 
+      // If we're processing the same reducer entry as the last commit,
+      // we compare against the state last committed by the component.
+      // We keep the reducer entry to avoid re-renders for unchanged selections.
+      // This means the reducer entry can still hold older navigation state.
+      // If a parent causes another render,
+      // we use the latest snapshot so the selector doesn't read stale state.
+      // We leave the reducer entry unchanged to avoid an extra render.
+      // We save that snapshot in committedRef when the render commits,
+      // so later updates compare against the state we actually rendered,
+      // including when the selector changed.
+      // If the reducer entry is different, we use its own navigation state,
+      // so comparisons include updates already processed in the pending render.
+      const previousState =
+        previous === committedRef.current.entry
+          ? committedRef.current.state
+          : previous.state;
+
       if (
         previous.listener === listener &&
-        (previous.state === state ||
+        (previousState === state ||
           (event === 'update' &&
-            Object.is(select(previous.state), select(state))))
+            Object.is(select(previousState), select(state))))
       ) {
         return previous;
       }
@@ -104,37 +141,24 @@ export function useNavigationState(...args: unknown[]): unknown {
       return { listener, state };
     },
     undefined,
-    () => ({ listener, state: getState() })
+    () => ({ listener, state: initialState ?? getSnapshot() })
   );
 
-  let state = entry.state;
-
-  const committedRef = React.useRef<{
-    entry: NavigationStateEntry | null;
-    state: NavigationState<ParamListBase>;
-    select: (state: NavigationState<ParamListBase>) => unknown;
-  }>({ entry: null, state, select });
+  const state =
+    // A different listener means the state belongs to another navigator.
+    // This can happen when the passed route name changes.
+    entry.listener !== listener ||
+    // An entry that advanced past the last commit is at least as new as the snapshot.
+    // An entry that didn't advance while the committed state changed is older.
+    entry === committedRef.current.entry
+      ? getSnapshot()
+      : entry.state;
 
   React.useInsertionEffect(() => {
+    initialRef.current = false;
     committedRef.current = { entry, state, select };
   });
 
-  const snapshot = getSnapshot();
-
-  const behind =
-    state !== snapshot &&
-    // A different listener means the state belongs to another navigator.
-    // This can happen when the passed route name changes.
-    (entry.listener !== listener ||
-      // An entry that advanced past the last commit is at least as new as the snapshot.
-      // An entry that didn't advance while the committed state changed is older.
-      entry === committedRef.current.entry);
-
-  if (behind) {
-    state = snapshot;
-    dispatch('commit');
-  }
-
   React.useLayoutEffect(() => {
     const check = (event: NavigationStateEvent) => {
       const { state, select } = committedRef.current;
@@ -173,6 +197,10 @@ export function NavigationStateListenerProvider({
   subscribe: (callback: () => void) => () => void;
   children: React.ReactNode;
 }) {
+  const [InitialStateContext] = React.useState(() =>
+    React.createContext(state)
+  );
+
   const [listeners] = React.useState(
     () => new Set<(event: NavigationStateEvent) => void>()
   );
@@ -195,6 +223,7 @@ export function NavigationStateListenerProvider({
 
   const context = React.useMemo(
     () => ({
+      initialStateContext: InitialStateContext,
       getState,
       getSnapshot: () => nextState ?? snapshotRef.current,
       subscribe: (callback: (event: NavigationStateEvent) => void) => {
@@ -208,12 +237,14 @@ export function NavigationStateListenerProvider({
         };
       },
     }),
-    [getState, listeners, nextState, subscribe]
+    [InitialStateContext, getState, listeners, nextState, subscribe]
   );
 
   return (
     <NavigationStateListenerContext.Provider value={context}>
-      {children}
+      <InitialStateContext.Provider value={state}>
+        {children}
+      </InitialStateContext.Provider>
     </NavigationStateListenerContext.Provider>
   );
 }
@@ -229,7 +260,7 @@ export function NamedNavigationStateListenerProvider({
 
   if (listener == null) {
     throw new Error(
-      "Couldn't find a navigation state listener. This is likely because the navigator doesn't render its content under 'NavigationContent'."
+      "Couldn't find a navigation state listener. This is likely a bug in the navigator.\n\nIf you're using a custom navigator, make sure that the navigator content is wrapped by the 'render' function returned by 'useNavigationBuilder'."
     );
   }
 

package/src/useOnAction.tsx

@@ -12,7 +12,7 @@ import { getLoaderForStateChange } from './DataLoading';
 import {
   type ChildActionListener,
   type ChildBeforeRemoveListener,
-  NavigationBuilderContext,
+  useNavigationBuilderContext,
 } from './NavigationBuilderContext';
 import { StaticTreeContext } from './StaticTreeContext';
 import type { EventMapCore } from './types';
@@ -55,7 +55,7 @@ export function useOnAction<State extends NavigationState>({
     addListener: addListenerParent,
     onDispatchAction,
     flushUpdates,
-  } = React.use(NavigationBuilderContext);
+  } = useNavigationBuilderContext();
 
   const tree = React.use(StaticTreeContext);
   const consumedParams = React.use(ConsumedParamsContext);
@@ -95,9 +95,10 @@ export function useOnAction<State extends NavigationState>({
         );
 
         // If a target is specified and set to current navigator, the action shouldn't bubble
-        // So instead of `null`, we use the state object for such cases to signal that action was handled
-        result =
-          result === null && action.target === state.key ? state : result;
+        // So we immediately return `false` to mark it as unhandled
+        if (result === null && action.target === state.key) {
+          return false;
+        }
 
         if (result !== null && result.stale !== false) {
           // Some actions (e.g. `RESET`) may return a stale state from the router

package/src/useOnGetNavigation.tsx

@@ -1,7 +1,7 @@
 import type { ParamListBase } from '@react-navigation/routers';
 import * as React from 'react';
 
-import { NavigationBuilderContext } from './NavigationBuilderContext';
+import { useNavigationBuilderContext } from './NavigationBuilderContext';
 import { NavigationRouteContext } from './NavigationProvider';
 import type { NavigationHelpers } from './types';
 
@@ -14,7 +14,8 @@ type Options = {
  * It's used for the navigation object returned by `useNavigation` outside a screen.
  */
 export function useOnGetNavigation({ navigation }: Options) {
-  const { addKeyedListener } = React.use(NavigationBuilderContext);
+  const { addKeyedListener } = useNavigationBuilderContext();
+
   const route = React.use(NavigationRouteContext);
 
   React.useInsertionEffect(() => {

package/src/useOnGetState.tsx

@@ -4,7 +4,7 @@ import * as React from 'react';
 import { isArrayEqual } from './isArrayEqual';
 import {
   type GetStateListener,
-  NavigationBuilderContext,
+  useNavigationBuilderContext,
 } from './NavigationBuilderContext';
 import { NavigationRouteContext } from './NavigationProvider';
 
@@ -14,8 +14,10 @@ type Options = {
 };
 
 export function useOnGetState({ getState, getStateListeners }: Options) {
-  const { addKeyedListener } = React.use(NavigationBuilderContext);
+  const { addKeyedListener } = useNavigationBuilderContext();
+
   const route = React.use(NavigationRouteContext);
+
   const key = route ? route.key : 'root';
 
   const getRehydratedState = React.useCallback(() => {

package/src/useOnPreventRemove.tsx

@@ -9,7 +9,7 @@ import * as React from 'react';
 
 import {
   type ChildBeforeRemoveListener,
-  NavigationBuilderContext,
+  useNavigationBuilderContext,
 } from './NavigationBuilderContext';
 import { NavigationRouteContext } from './NavigationProvider';
 import type { EventMapCore } from './types';
@@ -107,8 +107,10 @@ export function useOnPreventRemove({
   emitter,
   beforeRemoveListeners,
 }: Options) {
-  const { addKeyedListener } = React.use(NavigationBuilderContext);
+  const { addKeyedListener } = useNavigationBuilderContext();
+
   const route = React.use(NavigationRouteContext);
+
   const routeKey = route?.key;
 
   React.useInsertionEffect(() => {

package/src/useOnRouteFocus.tsx

@@ -5,7 +5,7 @@ import type {
 } from '@react-navigation/routers';
 import * as React from 'react';
 
-import { NavigationBuilderContext } from './NavigationBuilderContext';
+import { useNavigationBuilderContext } from './NavigationBuilderContext';
 
 type Options<State extends NavigationState, Action extends NavigationAction> = {
   router: Router<State, Action>;
@@ -23,9 +23,7 @@ export function useOnRouteFocus<
   State extends NavigationState,
   Action extends NavigationAction,
 >({ router, getState, key: sourceRouteKey, setState }: Options<State, Action>) {
-  const { onRouteFocus: onRouteFocusParent } = React.use(
-    NavigationBuilderContext
-  );
+  const { onRouteFocus: onRouteFocusParent } = useNavigationBuilderContext();
 
   return React.useCallback(
     (key: string) => {

package/src/useOptionsGetters.tsx

@@ -1,45 +1,40 @@
-import type { ParamListBase } from '@react-navigation/routers';
 import * as React from 'react';
 
 import { NavigationBuilderContext } from './NavigationBuilderContext';
 import { NavigationStateContext } from './NavigationStateContext';
-import type { NavigationProp } from './types';
+import { IsFocusedContext } from './useIsFocused';
 
 type Options = {
   key?: string;
-  navigation?: NavigationProp<ParamListBase>;
   options?: object | undefined;
+  getFocusedRouteKey?: () => string | undefined;
 };
 
-export function useOptionsGetters({ key, options, navigation }: Options) {
+export function useOptionsGetters({
+  key,
+  options,
+  getFocusedRouteKey,
+}: Options) {
+  const isFocused = React.use(IsFocusedContext) ?? true;
+
   const optionsRef = React.useRef<object | undefined>(options);
   const optionsGettersFromChildRef = React.useRef<
     Record<string, () => object | undefined | null>
   >({});
 
-  const { onOptionsChange } = React.use(NavigationBuilderContext);
+  const onOptionsChange = React.use(NavigationBuilderContext)?.onOptionsChange;
+
   const { addOptionsGetter: parentAddOptionsGetter } = React.use(
     NavigationStateContext
   );
 
-  const optionsChangeListener = React.useCallback(() => {
-    const isFocused = navigation?.isFocused() ?? true;
-    const hasChildren = Object.keys(optionsGettersFromChildRef.current).length;
-
-    if (isFocused && !hasChildren) {
-      onOptionsChange(optionsRef.current ?? {});
-    }
-  }, [navigation, onOptionsChange]);
-
   React.useInsertionEffect(() => {
     optionsRef.current = options;
   }, [options]);
 
   React.useEffect(() => {
-    optionsChangeListener();
-
-    return navigation?.addListener('focus', optionsChangeListener);
-  }, [navigation, options, optionsChangeListener]);
+    onOptionsChange?.();
+  }, [isFocused, onOptionsChange, options]);
 
   const getOptionsFromListener = React.useCallback(() => {
     for (const key in optionsGettersFromChildRef.current) {
@@ -57,9 +52,11 @@ export function useOptionsGetters({ key, options, navigation }: Options) {
   }, []);
 
   const getCurrentOptions = React.useCallback(() => {
-    const isFocused = navigation?.isFocused() ?? true;
-
-    if (!isFocused) {
+    // We use focused route key from the navigator instead of `isFocused`
+    // Because `isFocused` may reflect the value the screen last rendered with,
+    // e.g. if `Activity` hides the screen before it rendered the new value,
+    // it updates at a lower priority, so it may be delayed.
+    if (key != null && getFocusedRouteKey?.() !== key) {
       return null;
     }
 
@@ -70,7 +67,7 @@ export function useOptionsGetters({ key, options, navigation }: Options) {
     }
 
     return optionsRef.current;
-  }, [navigation, getOptionsFromListener]);
+  }, [key, getFocusedRouteKey, getOptionsFromListener]);
 
   React.useInsertionEffect(() => {
     // We don't have a parent at the root
@@ -82,15 +79,19 @@ export function useOptionsGetters({ key, options, navigation }: Options) {
   const addOptionsGetter = React.useCallback(
     (key: string, getter: () => object | undefined | null) => {
       optionsGettersFromChildRef.current[key] = getter;
-      optionsChangeListener();
 
       return () => {
         // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
         delete optionsGettersFromChildRef.current[key];
-        optionsChangeListener();
+
+        // Other getters and the focused route may still change during cleanup.
+        // Wait until the commit finishes before reporting the remaining options.
+        if (onOptionsChange !== undefined) {
+          queueMicrotask(onOptionsChange);
+        }
       };
     },
-    [optionsChangeListener]
+    [onOptionsChange]
   );
 
   return {

package/src/usePreventRemoveContext.tsx

@@ -7,7 +7,7 @@ export function usePreventRemoveContext() {
 
   if (value == null) {
     throw new Error(
-      "Couldn't find the prevent remove context. Is your component inside NavigationContent?"
+      "Couldn't find the prevent remove context. This is likely a bug in the navigator.\n\nIf you're using a custom navigator, make sure that the navigator content is wrapped by the 'render' function returned by 'useNavigationBuilder'."
     );
   }
 

package/src/useRouteCache.tsx

@@ -11,6 +11,10 @@ import type { RouteProp } from './types';
  */
 export const CHILD_STATE = Symbol('CHILD_STATE');
 
+type CachedRoute = RouteProp<ParamListBase> & {
+  [CHILD_STATE]?: NavigationState;
+};
+
 /**
  * Hook to cache route props for each screen in the navigator.
  * This lets add warnings and modifications to the route object but keep references between renders.
@@ -20,38 +24,58 @@ export function useRouteCache<State extends NavigationState>(
 ) {
   // Cache object which holds route objects for each screen
   const cache = React.useMemo(
-    () => ({ current: new Map<string, RouteProp<ParamListBase>>() }),
+    () => ({ current: new Map<string, CachedRoute>() }),
     []
   );
 
-  const next = routes.reduce((acc, route) => {
-    const previous = cache.current.get(route.key);
-    const { state, ...routeWithoutState } = route;
+  const next = React.useMemo(() => {
+    return routes.reduce((acc, route) => {
+      const previous = cache.current.get(route.key);
 
-    let proxy;
+      const { state: _, ...routeWithoutState } = route;
 
-    if (previous && isRecordEqual(previous, routeWithoutState)) {
-      // If a cached route object already exists, reuse it
-      proxy = previous;
-    } else {
-      proxy = routeWithoutState;
-    }
+      let proxy: CachedRoute;
 
-    if (process.env.NODE_ENV !== 'production' && proxy !== previous) {
-      // FIXME: since the state is updated with mutation, the route object cannot be frozen
-      // As a workaround, loop through the object and make the properties readonly
-      // Only needed once per proxy - skip if we're reusing a previously-frozen one
-      for (const [key, value] of Object.entries(proxy)) {
-        Object.defineProperty(proxy, key, {
-          enumerable: true,
-          configurable: true,
-          writable: false,
-          value,
-        });
+      if (previous && isRecordEqual(previous, routeWithoutState)) {
+        // If a cached route object already exists, reuse it
+        proxy = previous;
+      } else {
+        proxy = routeWithoutState;
+
+        if (process.env.NODE_ENV !== 'production') {
+          // FIXME: since the state is updated with mutation, the route object cannot be frozen
+          // As a workaround, loop through the object and make the properties readonly
+          // Only needed once per proxy - skip if we're reusing a previously-frozen one
+          for (const [key, value] of Object.entries(proxy)) {
+            Object.defineProperty(proxy, key, {
+              enumerable: true,
+              configurable: true,
+              writable: false,
+              value,
+            });
+          }
+        }
       }
-    }
 
-    // @ts-expect-error: this isn't in type definitions coz we want this private
+      acc.set(route.key, proxy);
+
+      return acc;
+    }, new Map<string, CachedRoute>());
+  }, [cache, routes]);
+
+  React.useInsertionEffect(() => {
+    cache.current = next;
+  });
+
+  // Update child state on every render, including when the memo is reused.
+  // This restores the previous child state when a pending render is canceled.
+  return Array.from(next.values(), (proxy, index) => {
+    const state = routes[index]?.state;
+
+    // FIXME: We mutate the child state without replacing the cached route object,
+    // so nested navigation doesn't re-render the parent screen.
+    // This is not concurrent render safe, pending renders mutate this shared child state.
+    // Then `getFocusedRouteNameFromRoute` can expose it before the render commits.
     if (proxy[CHILD_STATE] !== state) {
       Object.defineProperty(proxy, CHILD_STATE, {
         enumerable: false,
@@ -60,14 +84,6 @@ export function useRouteCache<State extends NavigationState>(
       });
     }
 
-    acc.set(route.key, proxy);
-
-    return acc;
-  }, new Map<string, RouteProp<ParamListBase>>());
-
-  React.useInsertionEffect(() => {
-    cache.current = next;
+    return proxy;
   });
-
-  return Array.from(next.values());
 }

package/src/useScheduleUpdate.tsx

@@ -1,6 +1,7 @@
 import * as React from 'react';
+import useLatestCallback from 'use-latest-callback';
 
-import { NavigationBuilderContext } from './NavigationBuilderContext';
+import { useNavigationBuilderContext } from './NavigationBuilderContext';
 
 /**
  * When screen config changes, we want to update the navigator in the same update phase.
@@ -11,10 +12,12 @@ import { NavigationBuilderContext } from './NavigationBuilderContext';
  * This lets nested updates be applied from the root down without clobbering each other.
  */
 export function useScheduleUpdate(callback: () => void) {
-  const { scheduleUpdate, flushUpdates } = React.use(NavigationBuilderContext);
+  const { scheduleUpdate, flushUpdates } = useNavigationBuilderContext();
+
+  const latestCallback = useLatestCallback(callback);
 
   React.useInsertionEffect(() => {
-    scheduleUpdate(callback);
+    scheduleUpdate(latestCallback);
   });
 
   React.useLayoutEffect(flushUpdates);

package/src/useSyncState.tsx

@@ -108,25 +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(() => {
-        // 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.
-        pendingUpdates.reverse();
-
-        for (const update of pendingUpdates) {
+        for (const update of callbacks) {
           update();
         }
       });

package/src/utilities.tsx

@@ -120,9 +120,11 @@ 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 }
@@ -146,6 +148,7 @@ 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> =

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/typescript/src/useComponent.d.ts

@@ -1,7 +0,0 @@
-import * as React from 'react';
-type Render = (children: React.ReactNode) => React.JSX.Element;
-export declare function useComponent(render: Render): ({ children }: {
-    children: React.ReactNode;
-}) => React.JSX.Element;
-export {};
-//# sourceMappingURL=useComponent.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"useComponent.d.ts","sourceRoot":"","sources":["../../../src/useComponent.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,KAAK,MAAM,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC,SAAS,KAAK,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC;AAW/D,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,kBAYN;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,uBAWjE"}