@symbiote-native/navigation 2.0.0 → 2.0.1

package/build/react/hooks/use-stack-navigation.js

@@ -1,14 +0,0 @@
-// useNavigation() returns a union (IAnyNavigatorHandle) since it doesn't know which navigator
-// mounted the calling component. When a component genuinely knows it only ever renders under a
-// Stack (the common case for anything nested a few levels below a Stack screen), this hook
-// narrows that union ONCE, here, so call sites never write their own 'push' in navigation check.
-import { isStackNavigatorHandle } from '../../core/index.js';
-import { useNavigation } from './use-navigation.js';
-export function useStackNavigation() {
-    const navigation = useNavigation();
-    if (!isStackNavigatorHandle(navigation)) {
-        throw new Error('useStackNavigation() was called from a component whose nearest navigator is not a Stack. ' +
-            'Use useNavigation() instead if this component can render under more than one navigator kind.');
-    }
-    return navigation;
-}

package/build/react/hooks/use-tab-navigation.d.ts

@@ -1,4 +0,0 @@
-import type { ITabNavigatorHandle } from '../../core';
-import type { INavigationHandle } from './use-navigation';
-export type ITabNavigationHandle = ITabNavigatorHandle & Pick<INavigationHandle, 'addListener' | 'getParent'>;
-export declare function useTabNavigation(): ITabNavigationHandle;

package/build/react/hooks/use-tab-navigation.js

@@ -1,12 +0,0 @@
-// Twin of use-stack-navigation.ts, narrowing to a Tab handle instead. See that file's header for
-// why this exists: it hides the union-narrowing guard inside the library instead of every call site.
-import { isTabNavigatorHandle } from '../../core/index.js';
-import { useNavigation } from './use-navigation.js';
-export function useTabNavigation() {
-    const navigation = useNavigation();
-    if (!isTabNavigatorHandle(navigation)) {
-        throw new Error('useTabNavigation() was called from a component whose nearest navigator is not a Tab. ' +
-            'Use useNavigation() instead if this component can render under more than one navigator kind.');
-    }
-    return navigation;
-}

package/build/react/index.d.ts

@@ -1,24 +0,0 @@
-import '../register';
-export { Stack } from './stack';
-export type { INavigatorHandle, IStackProps } from './stack';
-export { Screen } from './screen';
-export type { IScreenOptionsArgs, IScreenOptionsResolver, IScreenProps } from './screen';
-export type { IScreenOptions, IStackAnimation, IStackPresentation } from '../core';
-export { useNavigation, useRoute, useIsFocused, useFocusEffect, useNavigationState } from './hooks';
-export type { INavigationHandle } from './hooks';
-export { useStackNavigation, useTabNavigation, useDrawerNavigation } from './hooks';
-export type { IStackNavigationHandle, ITabNavigationHandle, IDrawerNavigationHandle, } from './hooks';
-export { NavigationContext } from './navigation-context';
-export type { INavigationContextValue, IAnyNavigatorHandle } from './navigation-context';
-export { useLinkingIntegration } from './linking';
-export type { ILinkingConfig, IScreenLinkingConfig } from '../core';
-export { Tab } from './tabs';
-export type { ITabNavigatorHandle, ITabProps } from './tabs';
-export { TabScreen } from './tab-screen';
-export type { ITabScreenOptionsArgs, ITabScreenOptionsResolver, ITabScreenProps, } from './tab-screen';
-export type { ITabOptions, ITabBarIcon } from '../core';
-export { Drawer } from './drawer';
-export type { IDrawerNavigatorHandle, IDrawerProps, IDrawerDescriptorMap } from './drawer';
-export { DrawerScreen } from './drawer-screen';
-export type { IDrawerScreenOptionsArgs, IDrawerScreenOptionsResolver, IDrawerScreenProps, } from './drawer-screen';
-export type { IDrawerOptions, IDrawerScreenOptions, IDrawerType, IDrawerPosition } from '../core';

package/build/react/index.js

@@ -1,21 +0,0 @@
-// @symbiote-native/navigation/react: the React native-stack navigator over react-native-screens'
-// native view primitives. Importing this barrel first registers the native views' ViewConfigs
-// (../register, a side-effect import of the three codegen specs - never react-native-screens' own
-// React components), then exposes Stack (with Stack.Screen attached) and the navigator handle.
-import '../register';
-export { Stack } from './stack/index.js';
-export { Screen } from './screen.js';
-export { useNavigation, useRoute, useIsFocused, useFocusEffect, useNavigationState } from './hooks/index.js';
-export { useStackNavigation, useTabNavigation, useDrawerNavigation } from './hooks/index.js';
-export { NavigationContext } from './navigation-context.js';
-export { useLinkingIntegration } from './linking.js';
-// Tab: the bottom-tabs navigator, a PURE-JS UI (no react-native-screens views involved, so no
-// extra ViewConfig registration is needed beyond the ../register import above).
-export { Tab } from './tabs/index.js';
-export { TabScreen } from './tab-screen.js';
-// Drawer: the swipeable drawer navigator, a PURE-JS UI (PanResponder + Animated, no
-// react-native-screens views involved, so no extra ViewConfig registration is needed beyond the
-// ../register import above). See react/drawer.ts's header for the feasibility note re:
-// react-native-gesture-handler / react-native-reanimated parity gaps.
-export { Drawer } from './drawer/index.js';
-export { DrawerScreen } from './drawer-screen.js';

package/build/react/linking.d.ts

@@ -1,3 +0,0 @@
-import type { ILinkingConfig } from '../core';
-import type { INavigatorHandle } from '../core';
-export declare function useLinkingIntegration(config: ILinkingConfig, navigatorHandle: INavigatorHandle): void;

package/build/react/linking.js

@@ -1,47 +0,0 @@
-// useLinkingIntegration: wires the framework-agnostic linking config (../core's
-// resolveRouteFromUrl) onto an existing Stack ref's INavigatorHandle. Deliberately NOT called
-// from inside stack.ts - app code owns the wiring (a <Stack ref={...}> plus this hook alongside
-// it), the same top-level-prop shape @react-navigation keeps `linking` in on NavigationContainer
-// rather than baking it into the router itself.
-import { useEffect, useRef } from 'react';
-import { Linking, dlog } from '@symbiote-native/engine';
-import { resolveRouteFromUrl } from '../core/index.js';
-export function useLinkingIntegration(config, navigatorHandle) {
-    // Refs, not effect deps: `navigatorHandle` is re-created by Stack on every push/pop
-    // (see stack.ts's useMemo deps including `state.routes.length`), so depending on it directly
-    // would resubscribe on every navigation instead of once on mount.
-    const configRef = useRef(config);
-    configRef.current = config;
-    const handleRef = useRef(navigatorHandle);
-    handleRef.current = navigatorHandle;
-    useEffect(() => {
-        function applyRoute(url, dispatch) {
-            const route = resolveRouteFromUrl(configRef.current, url);
-            if (route === null) {
-                dlog(`useLinkingIntegration: no route resolved for "${url}"`);
-                return;
-            }
-            dispatch(route.name, route.params);
-        }
-        let cancelled = false;
-        Linking.getInitialURL()
-            .then(url => {
-            if (cancelled || url === null)
-                return;
-            dlog(`useLinkingIntegration: initial URL "${url}"`);
-            applyRoute(url, handleRef.current.replace);
-        })
-            .catch((error) => {
-            dlog(`useLinkingIntegration: getInitialURL failed: ${String(error)}`);
-        });
-        const subscription = Linking.addEventListener('url', (event) => {
-            dlog(`useLinkingIntegration: url event "${event.url}"`);
-            applyRoute(event.url, handleRef.current.push);
-        });
-        return () => {
-            cancelled = true;
-            subscription.remove();
-        };
-        // Mount-once: freshness of config/navigatorHandle is read through the refs above.
-    }, []);
-}

package/build/react/navigation-context.d.ts

@@ -1,10 +0,0 @@
-import type { INavigationEmitter, IRoute, IAnyNavigatorHandle } from '../core';
-export type { IAnyNavigatorHandle } from '../core';
-export type INavigationContextValue = {
-    route: IRoute<unknown>;
-    navigation: IAnyNavigatorHandle;
-    emitter: INavigationEmitter;
-    parent?: INavigationContextValue;
-};
-export declare const NavigationContext: import("react").Context<INavigationContextValue | undefined>;
-export declare function useRequiredNavigationContext(hookName: string): INavigationContextValue;

package/build/react/navigation-context.js

@@ -1,22 +0,0 @@
-// The lifecycle half of the framework-agnostic emitter (../core/navigation-events): a plain
-// React Context so a screen's subtree can read its own route, navigator handle, and per-route
-// emitter without prop-drilling - the same role @react-navigation's NavigationContext /
-// NavigationRouteContext play, collapsed into one context since a symbiote screen only ever needs
-// its OWN route (no per-navigator param-list generics in v1 scope - see screen.ts). Provided
-// per-screen by each of stack.ts/tabs.ts/drawer.ts's render loop, consumed by the hooks in
-// ./hooks. `parent` threads the ambient context a navigator read on ITS OWN mount (undefined at
-// the root) into the value it provides to its own screens, forming a linked list - this is what
-// lets a screen nested inside e.g. a Stack-screen-renders-a-Tab composition reach the enclosing
-// Stack via useNavigation().getParent().
-import { createContext, useContext } from 'react';
-export const NavigationContext = createContext(undefined);
-// Every hook in ./hooks needs the same `useContext(NavigationContext)` + missing-provider throw,
-// so it's co-located here instead of repeated per hook. `hookName` keeps each hook's own name in
-// the thrown message.
-export function useRequiredNavigationContext(hookName) {
-    const context = useContext(NavigationContext);
-    if (!context) {
-        throw new Error(`${hookName} must be used within a screen rendered by <Stack>, <Tab>, or <Drawer>`);
-    }
-    return context;
-}

package/build/react/screen.d.ts

@@ -1,22 +0,0 @@
-import type { FC, ReactElement, RefObject } from 'react';
-import type { IRoute } from '../core';
-import type { ISearchBarCommands, ISearchBarOptions, IScreenOptions } from '../core';
-import type { INavigatorHandle } from '../core';
-export type IReactSearchBarOptions = ISearchBarOptions & {
-    ref?: RefObject<ISearchBarCommands | null>;
-};
-export type IReactScreenOptions = Omit<IScreenOptions, 'headerSearchBarOptions'> & {
-    headerSearchBarOptions?: IReactSearchBarOptions;
-};
-export type IScreenOptionsArgs = {
-    route: IRoute<unknown>;
-    navigation: INavigatorHandle;
-};
-export type IScreenOptionsResolver = (args: IScreenOptionsArgs) => IReactScreenOptions;
-export type IScreenProps = {
-    name: string;
-    component: FC;
-    options?: IReactScreenOptions | IScreenOptionsResolver;
-    initialParams?: unknown;
-};
-export declare function Screen(_props: IScreenProps): ReactElement | null;

package/build/react/screen.js

@@ -1,7 +0,0 @@
-// Stack.Screen: a declarative marker, never rendered on its own - Stack reads its props via
-// React.Children to build the static name -> {component, options} registry, then mounts the
-// registered component itself for each pushed route. Mirrors @react-navigation's JSX-config
-// screens, minus the linking/param-list generics (v1 scope).
-export function Screen(_props) {
-    return null;
-}

package/build/react/stack/index.d.ts

@@ -1,13 +0,0 @@
-import type { ReactNode } from 'react';
-import type { INavigatorHandle } from '../../core';
-import { Screen } from '../screen';
-import type { IReactScreenOptions } from '../screen';
-export type { INavigatorHandle } from '../../core';
-export type IStackProps = {
-    initialRouteName?: string;
-    screenOptions?: IReactScreenOptions;
-    children?: ReactNode;
-};
-export declare const Stack: import("react").ForwardRefExoticComponent<IStackProps & import("react").RefAttributes<INavigatorHandle>> & {
-    Screen: typeof Screen;
-};

package/build/react/stack/index.js

@@ -1,202 +0,0 @@
-// Stack, the React lifecycle half. The route-stack transitions (navigator-state) and the
-// options/props folds (screen-options, render-stack) live in @symbiote-native/navigation core,
-// shared verbatim with the Vue/Angular adapters; here React supplies the lifecycle - useReducer
-// for the pushed-route stack, useId + a ref counter for route-key generation, useImperativeHandle
-// for the push/pop/replace navigator handle - plus the descriptor bridge for the header config
-// leaf. Pushing/popping a route is an ordinary child mount/unmount: RNSScreenStack diffs its
-// RNSScreen children natively, so no imperative native command is needed here at all. Neither
-// this nor the Screen marker imports react-native-screens' own React components (ScreenStack.tsx
-// et al - hooks, crashes a non-React adapter); the native views are driven directly through the
-// ViewConfig ../register registers. See CLAUDE.md <third_party_rn_packages_are_react_only>.
-import { createElement, forwardRef, isValidElement, useCallback, useContext, useEffect, useId, useImperativeHandle, useMemo, useReducer, useRef, } from 'react';
-import { descriptorToReact } from '@symbiote-native/react';
-import { Platform, debugNodeId, dlog } from '@symbiote-native/engine';
-import { NAVIGATION_EVENT_BLUR, NAVIGATION_EVENT_FOCUS, NAVIGATION_EVENT_STATE, RNS_SCREEN_CONTENT_WRAPPER_VIEW_NAME, RNS_SCREEN_STACK_VIEW_NAME, RNS_SCREEN_VIEW_NAME, SCREEN_ON_APPEAR, SCREEN_ON_DISAPPEAR, SCREEN_ON_DISMISSED, SCREEN_ON_HEADER_BACK_BUTTON_CLICKED, SCREEN_ON_WILL_APPEAR, SCREEN_ON_WILL_DISAPPEAR, STACK_ON_FINISH_TRANSITIONING, buildSearchBarHandle, buildSearchBarPassthrough, computeActivityState, createInitialNavigatorState, createNavigationEmitter, navigatorReducer, resolveScreenRenderPlan, resolveStackProps, } from '../../core/index.js';
-import { collectRegistry } from '../collect-registry.js';
-import { NavigationContext } from '../navigation-context.js';
-import { Screen } from '../screen.js';
-// backTitleVisible defaults to `true` on both platforms per the codegen spec's own default
-// (CT.WithDefault<boolean, 'true'>) - no ios/android divergence in v1 scope, so a single constant
-// stands in for the per-platform injection point ISliderPlatform-style adapters use elsewhere.
-const NAVIGATOR_PLATFORM = { defaultHeaderBackTitleVisible: true };
-function isScreenElement(child) {
-    return isValidElement(child) && child.type === Screen;
-}
-function resolveScreenOptions(entry, optionsArgs, screenOptions) {
-    const own = typeof entry.options === 'function' ? entry.options(optionsArgs) : entry.options;
-    return { ...screenOptions, ...own };
-}
-const StackImpl = forwardRef((props, forwardedRef) => {
-    // Read BEFORE establishing this Stack's own Context value below - becomes the `parent` link a
-    // nested screen's useNavigation().getParent() walks (e.g. this Stack rendered as a Tab screen's
-    // content reaches that Tab via this value). undefined when this Stack is the nesting root.
-    const ambientContext = useContext(NavigationContext);
-    const registry = useMemo(() => collectRegistry(props.children, isScreenElement), [props.children]);
-    const routeIdPrefix = useId();
-    const routeSequence = useRef(0);
-    // One emitter per route.key, keyed exactly like routeSequence's counter is scoped - created
-    // lazily the first time a route is rendered, pruned once it's popped off the stack (below).
-    const emitters = useRef(new Map()).current;
-    // Investigation instrumentation (flicker-on-focus bug): route keys whose resolved
-    // transition/animation-timing props have already been logged, so the once-per-mount dump below
-    // doesn't spam on every re-render. Kept behind DEBUG, never removed.
-    const loggedScreenPropKeys = useRef(new Set()).current;
-    const emitterFor = useCallback((routeKey) => {
-        let emitter = emitters.get(routeKey);
-        if (!emitter) {
-            emitter = createNavigationEmitter();
-            emitters.set(routeKey, emitter);
-        }
-        return emitter;
-    }, [emitters]);
-    const createRoute = useCallback((name, params) => {
-        routeSequence.current += 1;
-        return { key: `${routeIdPrefix}-${name}-${routeSequence.current}`, name, params };
-    }, [routeIdPrefix]);
-    const [state, dispatch] = useReducer(navigatorReducer, undefined, () => {
-        const initialRouteName = props.initialRouteName ?? registry.keys().next().value;
-        if (initialRouteName === undefined) {
-            dlog('Stack: no <Stack.Screen> children registered');
-            return createInitialNavigatorState({ key: routeIdPrefix, name: '', params: undefined });
-        }
-        return createInitialNavigatorState(createRoute(initialRouteName, registry.get(initialRouteName)?.initialParams));
-    });
-    const handle = useMemo(() => ({
-        push: (name, params) => dispatch({ type: 'push', route: createRoute(name, params) }),
-        pop: count => dispatch({ type: 'pop', count }),
-        popToTop: () => dispatch({ type: 'popToTop' }),
-        popTo: key => dispatch({ type: 'popTo', key }),
-        replace: (name, params) => dispatch({ type: 'replace', route: createRoute(name, params) }),
-        setParams: (params, key) => dispatch({ type: 'setParams', key, params }),
-        reset: nextState => dispatch({ type: 'reset', state: nextState }),
-        canGoBack: () => state.routes.length > 1,
-    }), [createRoute, state.routes.length]);
-    useImperativeHandle(forwardedRef, () => handle, [handle]);
-    // Broadcasts the router state to every still-live route's emitter (useNavigationState's
-    // source) after each commit, and prunes emitters for routes popped off the stack - mirroring
-    // React's own subscribe-in-effect pattern rather than emitting mid-render, which would call a
-    // descendant's setState while this component is still rendering.
-    useEffect(() => {
-        for (const route of state.routes) {
-            emitterFor(route.key).emit(NAVIGATION_EVENT_STATE, state);
-        }
-        for (const routeKey of emitters.keys()) {
-            if (!state.routes.some(route => route.key === routeKey))
-                emitters.delete(routeKey);
-        }
-    }, [state, emitterFor, emitters]);
-    // Investigation instrumentation (flicker-on-focus bug): STACK_ON_FINISH_TRANSITIONING is the
-    // native signal that the WHOLE push/pop animation has finished (as opposed to onAppear/
-    // onDisappear, which are per-screen) - logging it lets the per-screen appear/disappear
-    // timestamps above be checked against the actual transition-complete moment. Kept behind
-    // DEBUG, never removed.
-    const stackProps = resolveStackProps({
-        passthrough: {
-            [STACK_ON_FINISH_TRANSITIONING]: () => dlog(`Stack: onFinishTransitioning at t=${Date.now()}`),
-        },
-    });
-    const children = state.routes.map((route, index) => {
-        const entry = registry.get(route.name);
-        if (!entry) {
-            dlog(`Stack: no screen registered for route name "${route.name}"`);
-            return null;
-        }
-        const screenOptionsArgs = { route, navigation: handle };
-        const mergedOptions = resolveScreenOptions(entry, screenOptionsArgs, props.screenOptions);
-        const activityState = computeActivityState(index, state.routes.length);
-        // Investigation instrumentation (flicker-on-focus bug): fires on EVERY Stack render, not just
-        // on transitions, so the log stream shows whether a route's activityState/index ever changes
-        // outside of a push/pop dispatch (e.g. from an unrelated re-render racing the native
-        // transition). Kept behind DEBUG per <keep_logs_gate_behind_DEBUG> - never remove.
-        dlog(`Stack: render route "${route.name}" index=${index}/${state.routes.length - 1} ` +
-            `activityState=${activityState} at t=${Date.now()}`);
-        const routeEmitter = emitterFor(route.key);
-        const searchBarOptions = mergedOptions.headerSearchBarOptions;
-        const plan = resolveScreenRenderPlan({
-            screenId: route.key,
-            index,
-            routeCount: state.routes.length,
-            options: mergedOptions,
-            platform: NAVIGATOR_PLATFORM,
-            isAndroid: Platform.OS === 'android',
-            screenPassthrough: {
-                [SCREEN_ON_DISMISSED]: () => dispatch({ type: 'pop', count: 1 }),
-                [SCREEN_ON_HEADER_BACK_BUTTON_CLICKED]: () => dispatch({ type: 'pop', count: 1 }),
-                // onAppear/onDisappear are the definitive visibility boundary (post-transition-animation),
-                // so 'focus'/'blur' fire exactly once per transition; onWillAppear/onWillDisappear fire
-                // BEFORE the animation runs, so wiring them to emit() too would double-invoke
-                // useFocusEffect per transition - they only get a debug log here.
-                [SCREEN_ON_WILL_APPEAR]: () => dlog(`Stack: route "${route.name}" will appear at t=${Date.now()}`),
-                [SCREEN_ON_APPEAR]: () => {
-                    dlog(`Stack: route "${route.name}" appeared (focus) at t=${Date.now()}`);
-                    routeEmitter.emit(NAVIGATION_EVENT_FOCUS);
-                },
-                [SCREEN_ON_WILL_DISAPPEAR]: () => dlog(`Stack: route "${route.name}" will disappear at t=${Date.now()}`),
-                [SCREEN_ON_DISAPPEAR]: () => {
-                    dlog(`Stack: route "${route.name}" disappeared (blur) at t=${Date.now()}`);
-                    routeEmitter.emit(NAVIGATION_EVENT_BLUR);
-                },
-            },
-            searchBarPassthrough: searchBarOptions
-                ? {
-                    ...buildSearchBarPassthrough(searchBarOptions, message => dlog(`Stack: route "${route.name}" ${message}`)),
-                    // The imperative ref (SearchBarCommands): a callback ref attached straight to the
-                    // RNSSearchBar host element via `passthrough.ref` - createElement extracts `ref` from
-                    // a props object same as ScrollView/TextInput's own ref binding (see
-                    // descriptor-to-react's comment), so the host instance IS the ISymbioteNode. Built
-                    // fresh per mount/unmount, never captured eagerly (buildSearchBarHandle's own
-                    // lazy-getter contract is satisfied trivially here since `node` is already resolved).
-                    ref: (node) => {
-                        // Investigation instrumentation (search-bar-ref "node not committed" bug): compare
-                        // this debugNodeId against the mirror.set/dispatchViewCommand logs in commit.ts -
-                        // same id on both sides proves the ref really does hold the committed node; a
-                        // mismatch proves a stale closure instead. Kept behind DEBUG, never removed.
-                        dlog(`Stack: search bar ref callback, node=${node === null ? 'null' : debugNodeId(node)} at t=${Date.now()}`);
-                        const appRef = searchBarOptions.ref;
-                        if (!appRef)
-                            return;
-                        appRef.current = node === null ? null : buildSearchBarHandle(() => node);
-                    },
-                }
-                : undefined,
-        });
-        // Investigation instrumentation (flicker-on-focus bug): the actual timing/z-order-relevant
-        // values resolved onto the native RNSScreen, once per route.key (not every render) - rules a
-        // stackAnimation/transitionDuration mismatch against react-native-screens' own native default
-        // in or out. Kept behind DEBUG, never removed.
-        if (!loggedScreenPropKeys.has(route.key)) {
-            loggedScreenPropKeys.add(route.key);
-            dlog(`Stack: route "${route.name}" resolved screen props ` +
-                `stackAnimation=${String(plan.screenProps.stackAnimation)} ` +
-                `stackPresentation=${String(plan.screenProps.stackPresentation)} ` +
-                `transitionDuration=${String(plan.screenProps.transitionDuration)} ` +
-                `gestureEnabled=${String(plan.screenProps.gestureEnabled)} at t=${Date.now()}`);
-        }
-        // Must not be flattened away (collapsable: false) - react-native-screens' native side
-        // finds THIS specific view type by class check to register a formSheet's content for
-        // sizing (see RNS_SCREEN_CONTENT_WRAPPER_VIEW_NAME's comment in core/constants.ts). A
-        // `push` screen doesn't need it, but a `formSheet` one is otherwise left with no content
-        // ever attached natively.
-        const content = createElement(RNS_SCREEN_CONTENT_WRAPPER_VIEW_NAME, plan.contentWrapperProps, createElement(NavigationContext.Provider, { value: { route, navigation: handle, emitter: routeEmitter, parent: ambientContext } }, createElement(entry.component)));
-        // react-native-screens' own Screen.tsx swaps in a DIFFERENT Fabric component
-        // ('RNSModalScreen') for a modally-presented screen - its native updateLayoutMetrics: relies on
-        // this exact class to know it must NOT apply Yoga's computed frame (see resolveScreenViewName's
-        // comment in core/render-stack.ts). The nested Screen isHeaderInModal adds below is always
-        // plain 'RNSScreen': react-native-screens' own inner Screen never carries a presentation prop
-        // either, since it exists purely to host the header, not to be modally presented itself.
-        // A modal/formSheet screen has no UINavigationController of its own on iOS - nest an inner
-        // RNSScreenStack/RNSScreen purely to host the native header bar (see isHeaderInModal's
-        // comment in core/render-stack.ts). Skipping this leaves RNSScreenStackHeaderConfig with no
-        // navigation controller to attach to, so the header silently never renders.
-        return plan.inModal
-            ? createElement(plan.screenViewName, { key: route.key, ...plan.screenProps }, createElement(RNS_SCREEN_STACK_VIEW_NAME, { style: plan.innerStackStyle }, createElement(RNS_SCREEN_VIEW_NAME, 
-            // activityState mirrors the outer Screen's own value - react-native-screens'
-            // RNSScreen.mm treats an unset/inactive nested screen as not yet pushed, leaving it
-            // parked at its pre-push transition position (off past the bottom edge) instead of
-            // its real, presented frame.
-            { style: plan.innerScreenStyle, activityState: plan.activityState }, descriptorToReact(plan.headerConfig), content)))
-            : createElement(plan.screenViewName, { key: route.key, ...plan.screenProps }, descriptorToReact(plan.headerConfig), content);
-    });
-    return createElement(RNS_SCREEN_STACK_VIEW_NAME, stackProps, ...children);
-});
-export const Stack = Object.assign(StackImpl, { Screen });

package/build/react/tab-screen.d.ts

@@ -1,15 +0,0 @@
-import type { FC, ReactElement } from 'react';
-import type { IRoute, ITabOptions } from '../core';
-import type { ITabNavigatorHandle } from '../core';
-export type ITabScreenOptionsArgs = {
-    route: IRoute<unknown>;
-    navigation: ITabNavigatorHandle;
-};
-export type ITabScreenOptionsResolver = (args: ITabScreenOptionsArgs) => ITabOptions;
-export type ITabScreenProps = {
-    name: string;
-    component: FC;
-    options?: ITabOptions | ITabScreenOptionsResolver;
-    initialParams?: unknown;
-};
-export declare function TabScreen(_props: ITabScreenProps): ReactElement | null;

package/build/react/tab-screen.js

@@ -1,8 +0,0 @@
-// Tab.Screen: a declarative marker, never rendered on its own - Tab reads its props via
-// React.Children to build the static name -> {component, options} registry, then mounts the
-// FOCUSED route's component itself. Mirrors react/screen.ts's Screen (Stack's twin) minus the
-// stack-only concepts (no push/pop lifecycle events to wire); see CLAUDE.md
-// <third_party_rn_packages_are_react_only> - this and Tab import nothing from react-native.
-export function TabScreen(_props) {
-    return null;
-}

package/build/react/tabs/index.d.ts

@@ -1,12 +0,0 @@
-import type { ReactNode } from 'react';
-import type { ITabNavigatorHandle, ITabOptions } from '../../core';
-import { TabScreen } from '../tab-screen';
-export type { ITabNavigatorHandle } from '../../core';
-export type ITabProps = {
-    initialRouteName?: string;
-    screenOptions?: ITabOptions;
-    children?: ReactNode;
-};
-export declare const Tab: import("react").ForwardRefExoticComponent<ITabProps & import("react").RefAttributes<ITabNavigatorHandle>> & {
-    Screen: typeof TabScreen;
-};

package/build/react/tabs/index.js

@@ -1,116 +0,0 @@
-// Tab, the React lifecycle half. The focused-index router (tab-router-state) and the tab-bar
-// Descriptor builder (render-tabs) live in @symbiote-native/navigation core, shared verbatim
-// with the Vue/Angular adapters; here React supplies the lifecycle - useReducer for the focused
-// index, useId for route-key generation, useImperativeHandle for the jumpTo/setParams handle -
-// plus the descriptor bridge for the tab-bar leaf, exactly like Stack bridges its header config
-// (react/stack.ts). Unlike Stack, a bottom-tabs bar is a PURE-JS UI: it paints ordinary
-// `symbiote-view`/`symbiote-text` primitives via the shared render fn, so there is no
-// react-native-screens ViewConfig to register here - Tab needs no `../register` import.
-import { createElement, forwardRef, isValidElement, useCallback, useContext, useEffect, useId, useImperativeHandle, useMemo, useReducer, } from 'react';
-import { descriptorToReact } from '@symbiote-native/react';
-import { dlog } from '@symbiote-native/engine';
-import { NAVIGATION_EVENT_BLUR, NAVIGATION_EVENT_FOCUS, createInitialTabState, createNavigationEmitter, isFocusedRoute, renderTabBar, tabRouterReducer, } from '../../core/index.js';
-import { collectRegistry } from '../collect-registry.js';
-import { NavigationContext } from '../navigation-context.js';
-import { TabScreen } from '../tab-screen.js';
-function isTabScreenElement(child) {
-    return isValidElement(child) && child.type === TabScreen;
-}
-function resolveTabOptions(entry, optionsArgs, screenOptions) {
-    const own = typeof entry.options === 'function' ? entry.options(optionsArgs) : entry.options;
-    return { ...screenOptions, ...own };
-}
-const TAB_CONTENT_STYLE = { flex: 1 };
-const TAB_ROOT_STYLE = { flex: 1 };
-const TabImpl = forwardRef((props, forwardedRef) => {
-    // Read BEFORE establishing this Tab's own Context value below - becomes the `parent` link a
-    // nested screen's useNavigation().getParent() walks (e.g. this Tab rendered as a Stack screen's
-    // content reaches that Stack via this value). undefined when this Tab is the nesting root.
-    const ambientContext = useContext(NavigationContext);
-    const registry = useMemo(() => collectRegistry(props.children, isTabScreenElement), [props.children]);
-    const routeIdPrefix = useId();
-    const routes = useMemo(() => Array.from(registry.entries()).map(([name, entry]) => ({
-        key: `${routeIdPrefix}-${name}`,
-        name,
-        params: entry.initialParams,
-    })), [registry, routeIdPrefix]);
-    const [state, dispatch] = useReducer(tabRouterReducer, undefined, () => createInitialTabState(routes, props.initialRouteName));
-    if (routes.length === 0)
-        dlog('Tab: no <Tab.Screen> children registered');
-    const jumpTo = useCallback((name, params) => dispatch({ type: 'jumpTo', name, params }), []);
-    const setParams = useCallback((params, key) => dispatch({ type: 'setParams', key, params }), []);
-    const handle = useMemo(() => ({ jumpTo, setParams }), [jumpTo, setParams]);
-    useImperativeHandle(forwardedRef, () => handle, [handle]);
-    const focusedRoute = state.routes[state.index];
-    const items = state.routes.map((route, index) => {
-        const entry = registry.get(route.name);
-        const focused = isFocusedRoute(index, state.index);
-        if (!entry) {
-            dlog(`Tab: no screen registered for route name "${route.name}"`);
-            return {
-                key: route.key,
-                focused,
-                label: route.name,
-                passthrough: {},
-            };
-        }
-        const options = resolveTabOptions(entry, { route, navigation: handle }, props.screenOptions);
-        return {
-            key: route.key,
-            focused,
-            label: options.tabBarLabel ?? options.title ?? route.name,
-            icon: options.tabBarIcon,
-            badge: options.tabBarBadge,
-            activeTintColor: options.tabBarActiveTintColor,
-            inactiveTintColor: options.tabBarInactiveTintColor,
-            passthrough: {
-                onPress: () => jumpTo(route.name),
-                accessibilityRole: 'tab',
-                accessibilityState: { selected: focused },
-            },
-        };
-    });
-    const focusedEntry = focusedRoute ? registry.get(focusedRoute.name) : undefined;
-    const focusedOptions = focusedEntry && focusedRoute
-        ? resolveTabOptions(focusedEntry, { route: focusedRoute, navigation: handle }, props.screenOptions)
-        : props.screenOptions;
-    const tabBar = descriptorToReact(renderTabBar({ items, style: focusedOptions?.tabBarStyle, passthrough: {} }));
-    // Only the focused route's screen is ever mounted (unlike Stack, which keeps every pushed route
-    // alive), so a fresh emitter per focus change is sufficient - no per-route emitter map to prune,
-    // because the previous screen's whole subtree (and any listeners it registered) is torn down by
-    // an ordinary React unmount when focus moves on. Keyed on the route KEY rather than the route
-    // object so a setParams-only change (new route object, same key) doesn't spuriously re-fire
-    // focus/blur.
-    const focusedRouteKey = focusedRoute?.key;
-    const routeEmitter = useMemo(() => createNavigationEmitter(), [focusedRouteKey]);
-    // Tab paints its own bar in pure JS - there is no native onAppear/onDisappear to hook (unlike
-    // Stack's RNSScreen), so focus/blur is synthesized here: mount = focus, cleanup = blur, exactly
-    // what an effect keyed on focusedRouteKey already encodes - no diffFocusedRoute indirection
-    // needed (unlike Vue/Angular, which diff real prev/next keys inside an imperative watch/CD
-    // callback that has no mount/cleanup pairing of its own).
-    useEffect(() => {
-        if (focusedRouteKey === undefined)
-            return undefined;
-        dlog(`Tab: route "${focusedRoute?.name}" focused`);
-        routeEmitter.emit(NAVIGATION_EVENT_FOCUS);
-        return () => {
-            dlog(`Tab: route "${focusedRoute?.name}" blurred`);
-            routeEmitter.emit(NAVIGATION_EVENT_BLUR);
-        };
-        // focusedRoute omitted deliberately: only its .key (tracked via focusedRouteKey) should
-        // re-run this effect - see the comment above on focusedRouteKey.
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [routeEmitter, focusedRouteKey]);
-    const content = focusedEntry && focusedRoute
-        ? createElement(NavigationContext.Provider, {
-            value: {
-                route: focusedRoute,
-                navigation: handle,
-                emitter: routeEmitter,
-                parent: ambientContext,
-            },
-        }, createElement(focusedEntry.component))
-        : null;
-    return createElement('symbiote-view', { style: TAB_ROOT_STYLE }, createElement('symbiote-view', { style: TAB_CONTENT_STYLE }, content), tabBar);
-});
-export const Tab = Object.assign(TabImpl, { Screen: TabScreen });

package/build/register.d.ts

@@ -1,7 +0,0 @@
-import 'react-native-screens/src/fabric/ScreenNativeComponent';
-import 'react-native-screens/src/fabric/ModalScreenNativeComponent';
-import 'react-native-screens/src/fabric/ScreenStackNativeComponent';
-import 'react-native-screens/src/fabric/ScreenStackHeaderConfigNativeComponent';
-import 'react-native-screens/src/fabric/ScreenStackHeaderSubviewNativeComponent';
-import 'react-native-screens/src/fabric/SearchBarNativeComponent';
-import 'react-native-screens/src/fabric/ScreenContentWrapperNativeComponent';