@symbiote-native/navigation 1.0.0

package/build/angular/drawer-screen.directive.js

@@ -0,0 +1,87 @@
+// [symbioteDrawerScreen]: Drawer's twin of screen.directive.ts's ScreenDirective - a declarative
+// marker read via @ContentChildren to build the static name -> {component, options} registry, then
+// Drawer mounts the FOCUSED route's component. Mirrors react/drawer-screen.ts (Drawer's twin) and
+// tab-screen.directive.ts (the closer sibling - both are fixed-route-list, no-push navigators).
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { Directive, Input } from '@angular/core';
+let DrawerScreenDirective = (() => {
+    let _classDecorators = [Directive({
+            selector: 'ng-template[symbioteDrawerScreen]',
+            standalone: true,
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _name_decorators;
+    let _name_initializers = [];
+    let _name_extraInitializers = [];
+    let _component_decorators;
+    let _component_initializers = [];
+    let _component_extraInitializers = [];
+    let _options_decorators;
+    let _options_initializers = [];
+    let _options_extraInitializers = [];
+    let _initialParams_decorators;
+    let _initialParams_initializers = [];
+    let _initialParams_extraInitializers = [];
+    var DrawerScreenDirective = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _name_decorators = [Input({ required: true })];
+            _component_decorators = [Input({ required: true })];
+            _options_decorators = [Input()];
+            _initialParams_decorators = [Input()];
+            __esDecorate(null, null, _name_decorators, { kind: "field", name: "name", static: false, private: false, access: { has: obj => "name" in obj, get: obj => obj.name, set: (obj, value) => { obj.name = value; } }, metadata: _metadata }, _name_initializers, _name_extraInitializers);
+            __esDecorate(null, null, _component_decorators, { kind: "field", name: "component", static: false, private: false, access: { has: obj => "component" in obj, get: obj => obj.component, set: (obj, value) => { obj.component = value; } }, metadata: _metadata }, _component_initializers, _component_extraInitializers);
+            __esDecorate(null, null, _options_decorators, { kind: "field", name: "options", static: false, private: false, access: { has: obj => "options" in obj, get: obj => obj.options, set: (obj, value) => { obj.options = value; } }, metadata: _metadata }, _options_initializers, _options_extraInitializers);
+            __esDecorate(null, null, _initialParams_decorators, { kind: "field", name: "initialParams", static: false, private: false, access: { has: obj => "initialParams" in obj, get: obj => obj.initialParams, set: (obj, value) => { obj.initialParams = value; } }, metadata: _metadata }, _initialParams_initializers, _initialParams_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            DrawerScreenDirective = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        name = __runInitializers(this, _name_initializers, void 0);
+        component = (__runInitializers(this, _name_extraInitializers), __runInitializers(this, _component_initializers, void 0));
+        options = (__runInitializers(this, _component_extraInitializers), __runInitializers(this, _options_initializers, void 0));
+        initialParams = (__runInitializers(this, _options_extraInitializers), __runInitializers(this, _initialParams_initializers, void 0));
+        constructor() {
+            __runInitializers(this, _initialParams_extraInitializers);
+        }
+    };
+    return DrawerScreenDirective = _classThis;
+})();
+export { DrawerScreenDirective };

package/build/angular/index.d.ts

@@ -0,0 +1,23 @@
+import '../register';
+export { Stack } from './stack';
+export type { INavigatorHandle } from './stack';
+export { ScreenDirective } from './screen.directive';
+export type { IAngularScreenOptions, IAngularSearchBarOptions, IScreenOptionsArgs, IScreenOptionsResolver, } from './screen.directive';
+export type { IScreenOptions, IStackAnimation, IStackPresentation } from '../core';
+export { injectNavigation, injectStackNavigation, injectTabNavigation, injectDrawerNavigation, injectRoute, injectIsFocused, injectFocusEffect, injectNavigationState, } from './injectors';
+export type { INavigationHandle, IStackNavigationHandle, ITabNavigationHandle, IDrawerNavigationHandle, IFocusEffectCallback, } from './injectors';
+export { NavigationContextService } from './navigation-context.service';
+export type { IAnyNavigatorHandle } from './navigation-context.service';
+export { NavigationScopeDirective } from './navigation-scope.directive';
+export { injectLinkingIntegration } from './linking';
+export type { ILinkingConfig, IScreenLinkingConfig } from '../core';
+export { Tab } from './tabs';
+export type { ITabNavigatorHandle } from './tabs';
+export { TabScreenDirective } from './tab-screen.directive';
+export type { ITabScreenOptionsArgs, ITabScreenOptionsResolver } from './tab-screen.directive';
+export type { ITabOptions, ITabBarIcon } from '../core';
+export { Drawer } from './drawer';
+export type { IDrawerNavigatorHandle, IDrawerDescriptorMap, IDrawerContentContext } from './drawer';
+export { DrawerScreenDirective } from './drawer-screen.directive';
+export type { IDrawerScreenOptionsArgs, IDrawerScreenOptionsResolver, } from './drawer-screen.directive';
+export type { IDrawerOptions, IDrawerScreenOptions, IDrawerType, IDrawerPosition } from '../core';

package/build/angular/index.js

@@ -0,0 +1,22 @@
+// @symbiote-native/navigation/angular: the Angular 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/Tab/Drawer with their Screen
+// directives and navigator handles. Mirrors react/index.ts's barrel shape.
+import '../register';
+export { Stack } from './stack/index.js';
+export { ScreenDirective } from './screen.directive.js';
+export { injectNavigation, injectStackNavigation, injectTabNavigation, injectDrawerNavigation, injectRoute, injectIsFocused, injectFocusEffect, injectNavigationState, } from './injectors/index.js';
+export { NavigationContextService } from './navigation-context.service.js';
+export { NavigationScopeDirective } from './navigation-scope.directive.js';
+export { injectLinkingIntegration } 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 { TabScreenDirective } from './tab-screen.directive.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 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 { DrawerScreenDirective } from './drawer-screen.directive.js';

package/build/angular/injectors/index.d.ts

@@ -0,0 +1,13 @@
+export { injectNavigation } from './inject-navigation';
+export type { INavigationHandle } from './inject-navigation';
+export { injectStackNavigation } from './inject-stack-navigation';
+export type { IStackNavigationHandle } from './inject-stack-navigation';
+export { injectTabNavigation } from './inject-tab-navigation';
+export type { ITabNavigationHandle } from './inject-tab-navigation';
+export { injectDrawerNavigation } from './inject-drawer-navigation';
+export type { IDrawerNavigationHandle } from './inject-drawer-navigation';
+export { injectRoute } from './inject-route';
+export { injectIsFocused } from './inject-is-focused';
+export { injectFocusEffect } from './inject-focus-effect';
+export type { IFocusEffectCallback } from './inject-focus-effect';
+export { injectNavigationState } from './inject-navigation-state';

package/build/angular/injectors/index.js

@@ -0,0 +1,8 @@
+export { injectNavigation } from './inject-navigation.js';
+export { injectStackNavigation } from './inject-stack-navigation.js';
+export { injectTabNavigation } from './inject-tab-navigation.js';
+export { injectDrawerNavigation } from './inject-drawer-navigation.js';
+export { injectRoute } from './inject-route.js';
+export { injectIsFocused } from './inject-is-focused.js';
+export { injectFocusEffect } from './inject-focus-effect.js';
+export { injectNavigationState } from './inject-navigation-state.js';

package/build/angular/injectors/inject-drawer-navigation.d.ts

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

package/build/angular/injectors/inject-drawer-navigation.js

@@ -0,0 +1,12 @@
+// Twin of inject-stack-navigation.ts, narrowing to a Drawer handle instead.
+import { isDrawerNavigatorHandle } from '../../core/index.js';
+import { injectNavigation } from './inject-navigation.js';
+export function injectDrawerNavigation() {
+    const navigation = injectNavigation();
+    if (!isDrawerNavigatorHandle(navigation)) {
+        throw new Error('injectDrawerNavigation() was called from a component whose nearest navigator is not a ' +
+            'Drawer. Use injectNavigation() instead if this component can render under more than one ' +
+            'navigator kind.');
+    }
+    return navigation;
+}

package/build/angular/injectors/inject-focus-effect.d.ts

@@ -0,0 +1,2 @@
+export type IFocusEffectCallback = () => (() => void) | void;
+export declare function injectFocusEffect(effect: IFocusEffectCallback): void;

package/build/angular/injectors/inject-focus-effect.js

@@ -0,0 +1,29 @@
+// Angular injection function: runs `effect` while the route is focused and runs its own returned
+// cleanup on blur - exactly a plain effect's contract, just re-armed on every focus/blur pair
+// instead of once on construction - mirrors @react-navigation's useFocusEffect. Named `effect` for
+// API parity with the React/Vue twins, NOT Angular's own `effect()` reactive primitive (this
+// callback re-runs on focus/blur events, not on a signal dependency change) - callers should keep
+// `effect` referentially stable across calls they don't intend to change (this function is called
+// once per component construction, nothing here re-subscribes automatically otherwise).
+import { DestroyRef, inject } from '@angular/core';
+import { NAVIGATION_EVENT_BLUR, NAVIGATION_EVENT_FOCUS } from '../../core/index.js';
+import { requireNavigationContext } from '../navigation-context.service.js';
+export function injectFocusEffect(effect) {
+    const context = requireNavigationContext('injectFocusEffect');
+    const destroyRef = inject(DestroyRef);
+    let cleanup;
+    const runEffect = () => {
+        cleanup = effect();
+    };
+    const runCleanup = () => {
+        cleanup?.();
+        cleanup = undefined;
+    };
+    const unsubscribeFocus = context.emitter.addListener(NAVIGATION_EVENT_FOCUS, runEffect);
+    const unsubscribeBlur = context.emitter.addListener(NAVIGATION_EVENT_BLUR, runCleanup);
+    destroyRef.onDestroy(() => {
+        unsubscribeFocus();
+        unsubscribeBlur();
+        runCleanup();
+    });
+}

package/build/angular/injectors/inject-is-focused.d.ts

@@ -0,0 +1,2 @@
+import { type Signal } from '@angular/core';
+export declare function injectIsFocused(): Signal<boolean>;

package/build/angular/injectors/inject-is-focused.js

@@ -0,0 +1,20 @@
+// Angular injection function: subscribes to the route's focus/blur pair and returns a Signal of
+// whether it's currently focused - mirrors @react-navigation's useIsFocused. Starts `false` rather
+// than guessing from stack position: a route's emitter only fires 'focus' once the navigator's own
+// appear/mount signal lands (Stack: RNSScreen's native onAppear; Tab/Drawer: the synthesized
+// mount-time emit), so a screen genuinely isn't focused yet at the instant it's constructed.
+import { DestroyRef, inject, signal } from '@angular/core';
+import { NAVIGATION_EVENT_BLUR, NAVIGATION_EVENT_FOCUS } from '../../core/index.js';
+import { requireNavigationContext } from '../navigation-context.service.js';
+export function injectIsFocused() {
+    const context = requireNavigationContext('injectIsFocused');
+    const destroyRef = inject(DestroyRef);
+    const isFocused = signal(false);
+    const unsubscribeFocus = context.emitter.addListener(NAVIGATION_EVENT_FOCUS, () => isFocused.set(true));
+    const unsubscribeBlur = context.emitter.addListener(NAVIGATION_EVENT_BLUR, () => isFocused.set(false));
+    destroyRef.onDestroy(() => {
+        unsubscribeFocus();
+        unsubscribeBlur();
+    });
+    return isFocused.asReadonly();
+}

package/build/angular/injectors/inject-navigation-state.d.ts

@@ -0,0 +1,3 @@
+import { type Signal } from '@angular/core';
+import type { INavigatorState } from '../../core';
+export declare function injectNavigationState<TResult>(selector: (state: INavigatorState) => TResult): Signal<TResult>;

package/build/angular/injectors/inject-navigation-state.js

@@ -0,0 +1,35 @@
+// Angular injection function: subscribes to the router's `state` broadcast (stack.ts's `dispatch`
+// re-emits the full INavigatorState to every route's emitter after each change) and returns a
+// Signal of `selector(state)`, updating only when the emitted state changes - mirrors
+// @react-navigation's useNavigationState. The reducer/dispatch machinery it selects over lives in
+// core/navigator-state.ts; this function only wires the subscription.
+//
+// Seeded from a single-route snapshot ({ routes: [route] }) rather than left undefined: the real
+// broadcast lands after the FIRST dispatch, so a selector reading e.g. `state.routes.at(-1)?.name`
+// still resolves correctly before any navigation action for the common single-route case, closing
+// the same async gap injectIsFocused documents.
+import { DestroyRef, inject, signal } from '@angular/core';
+import { NAVIGATION_EVENT_STATE } from '../../core/index.js';
+import { requireNavigationContext } from '../navigation-context.service.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isNavigatorState(value) {
+    return isRecord(value) && Array.isArray(value.routes);
+}
+export function injectNavigationState(selector) {
+    const context = requireNavigationContext('injectNavigationState');
+    const destroyRef = inject(DestroyRef);
+    const route = context.route();
+    if (route === undefined) {
+        throw new Error("injectNavigationState: no route has been assigned to this screen's navigation scope yet");
+    }
+    const result = signal(selector({ routes: [route] }));
+    const unsubscribe = context.emitter.addListener(NAVIGATION_EVENT_STATE, (state) => {
+        if (!isNavigatorState(state))
+            return;
+        result.set(selector(state));
+    });
+    destroyRef.onDestroy(unsubscribe);
+    return result.asReadonly();
+}

package/build/angular/injectors/inject-navigation.d.ts

@@ -0,0 +1,7 @@
+import type { INavigationEventListener, INavigationEventName } from '../../core';
+import { type IAnyNavigatorHandle } from '../navigation-context.service';
+export type INavigationHandle = IAnyNavigatorHandle & {
+    addListener: (event: INavigationEventName, listener: INavigationEventListener) => () => void;
+    getParent: () => IAnyNavigatorHandle | undefined;
+};
+export declare function injectNavigation(): INavigationHandle;

package/build/angular/injectors/inject-navigation.js

@@ -0,0 +1,16 @@
+// Angular injection function (calls `inject()`, so it must run in an injection context - a
+// component/directive constructor or field initializer, same requirement `inject()` itself has).
+// Returns the current screen's navigator handle (push/pop/replace/... for a Stack screen,
+// jumpTo/setParams for a Tab screen, openDrawer/... for a Drawer screen) plus addListener bound to
+// that route's own emitter - mirrors @react-navigation's `navigation.addListener('focus', cb)`
+// surface. All pub/sub logic lives in ../../core/navigation-events; this function only reads
+// NavigationContextService and binds identity.
+import { requireNavigationContext } from '../navigation-context.service.js';
+export function injectNavigation() {
+    const context = requireNavigationContext('injectNavigation');
+    return {
+        ...context.navigation,
+        addListener: context.emitter.addListener,
+        getParent: () => context.parent?.navigation,
+    };
+}

package/build/angular/injectors/inject-route.d.ts

@@ -0,0 +1,3 @@
+import { type Signal } from '@angular/core';
+import type { IRoute } from '../../core';
+export declare function injectRoute(): Signal<IRoute<unknown>>;

package/build/angular/injectors/inject-route.js

@@ -0,0 +1,20 @@
+// Angular injection function: returns the current screen's route as a live Signal - mirrors
+// @react-navigation's useRoute, reactive rather than a one-shot read because a setParams call
+// swaps in a new route object (same key) while the screen stays mounted (see
+// navigation-context.service.ts's comment on why `route` is a signal there). Zero logic of its
+// own beyond that signal read.
+import { computed } from '@angular/core';
+import { requireNavigationContext } from '../navigation-context.service.js';
+export function injectRoute() {
+    const context = requireNavigationContext('injectRoute');
+    // A `computed` (not the raw context.route signal) so the return type narrows to
+    // `IRoute<unknown>` structurally - NavigationScopeDirective always assigns a route before any
+    // content (and therefore any injectRoute() caller) exists, so this only ever throws on misuse.
+    return computed(() => {
+        const current = context.route();
+        if (current === undefined) {
+            throw new Error("injectRoute: no route has been assigned to this screen's navigation scope yet");
+        }
+        return current;
+    });
+}

package/build/angular/injectors/inject-stack-navigation.d.ts

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

package/build/angular/injectors/inject-stack-navigation.js

@@ -0,0 +1,15 @@
+// injectNavigation() 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, this injector narrows that union ONCE, here, so call sites never write their own
+// 'push' in navigation check. Angular twin of react/hooks/use-stack-navigation.ts.
+import { isStackNavigatorHandle } from '../../core/index.js';
+import { injectNavigation } from './inject-navigation.js';
+export function injectStackNavigation() {
+    const navigation = injectNavigation();
+    if (!isStackNavigatorHandle(navigation)) {
+        throw new Error('injectStackNavigation() was called from a component whose nearest navigator is not a ' +
+            'Stack. Use injectNavigation() instead if this component can render under more than one ' +
+            'navigator kind.');
+    }
+    return navigation;
+}

package/build/angular/injectors/inject-tab-navigation.d.ts

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

package/build/angular/injectors/inject-tab-navigation.js

@@ -0,0 +1,11 @@
+// Twin of inject-stack-navigation.ts, narrowing to a Tab handle instead.
+import { isTabNavigatorHandle } from '../../core/index.js';
+import { injectNavigation } from './inject-navigation.js';
+export function injectTabNavigation() {
+    const navigation = injectNavigation();
+    if (!isTabNavigatorHandle(navigation)) {
+        throw new Error('injectTabNavigation() was called from a component whose nearest navigator is not a Tab. ' +
+            'Use injectNavigation() instead if this component can render under more than one navigator kind.');
+    }
+    return navigation;
+}

package/build/angular/linking.d.ts

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

package/build/angular/linking.js

@@ -0,0 +1,43 @@
+// injectLinkingIntegration: wires the framework-agnostic linking config (../core's
+// resolveRouteFromUrl) onto an existing Stack's INavigatorHandle. Deliberately NOT called from
+// inside stack.ts - app code owns the wiring (call this from the component hosting `<Stack #nav>`,
+// passing `nav` itself, since Stack now implements INavigatorHandle directly), the same
+// top-level-prop shape @react-navigation keeps `linking` in on NavigationContainer rather than
+// baking it into the router itself. Mirrors react/linking.ts's useLinkingIntegration; Angular
+// needs none of its `configRef`/`handleRef` staleness workaround - this function runs its
+// subscription ONCE per call (the natural `inject()` call-site convention), and Stack's methods
+// already read live `this` state off the component instance, so there is no stale-closure risk to
+// guard against here.
+import { DestroyRef, inject } from '@angular/core';
+import { Linking, dlog } from '@symbiote-native/engine';
+import { resolveRouteFromUrl } from '../core/index.js';
+export function injectLinkingIntegration(config, navigatorHandle) {
+    const destroyRef = inject(DestroyRef);
+    function applyRoute(url, dispatch) {
+        const route = resolveRouteFromUrl(config, url);
+        if (route === null) {
+            dlog(`injectLinkingIntegration: no route resolved for "${url}"`);
+            return;
+        }
+        dispatch(route.name, route.params);
+    }
+    let cancelled = false;
+    Linking.getInitialURL()
+        .then(url => {
+        if (cancelled || url === null)
+            return;
+        dlog(`injectLinkingIntegration: initial URL "${url}"`);
+        applyRoute(url, navigatorHandle.replace);
+    })
+        .catch((error) => {
+        dlog(`injectLinkingIntegration: getInitialURL failed: ${String(error)}`);
+    });
+    const subscription = Linking.addEventListener('url', (event) => {
+        dlog(`injectLinkingIntegration: url event "${event.url}"`);
+        applyRoute(event.url, navigatorHandle.push);
+    });
+    destroyRef.onDestroy(() => {
+        cancelled = true;
+        subscription.remove();
+    });
+}

package/build/angular/navigation-context.service.d.ts

@@ -0,0 +1,13 @@
+import { type Signal } from '@angular/core';
+import type { INavigationEmitter, IRoute, IAnyNavigatorHandle } from '../core';
+export type { IAnyNavigatorHandle } from '../core';
+export declare class NavigationContextService {
+    private readonly ambientParent;
+    private readonly routeSignal;
+    readonly route: Signal<IRoute<unknown> | undefined>;
+    navigation: IAnyNavigatorHandle;
+    emitter: INavigationEmitter;
+    get parent(): NavigationContextService | undefined;
+    setRoute(route: IRoute<unknown>): void;
+}
+export declare function requireNavigationContext(injectorName: string): NavigationContextService;

package/build/angular/navigation-context.service.js

@@ -0,0 +1,105 @@
+// The lifecycle half of the framework-agnostic emitter (../core/navigation-events), Angular's
+// twin of react/navigation-context.ts's NavigationContext. React re-scopes a plain Context per
+// screen via NavigationContext.Provider; Angular's equivalent of "nearest-provider lookup" is
+// hierarchical DI - NavigationScopeDirective (./navigation-scope.directive) re-`providers: [...]`
+// a fresh NavigationContextService instance per route, and this service's own constructor injects
+// its PARENT instance (`@Optional() @SkipSelf()`), which Angular resolves to the nearest ANCESTOR
+// provider automatically - the exact `parent` linked list react/navigation-context.ts builds by
+// hand via `ambientContext`. A screen nested inside e.g. a Stack-screen-renders-a-Tab composition
+// reaches the enclosing Stack the same way a React screen does: one hop up `parent`.
+//
+// Every navigator kind a screen might be rendered under; consumers narrow the union themselves
+// ('push' in handle picks out a Stack handle) - mirrors react/navigation-context.ts's
+// IAnyNavigatorHandle exactly, minus the React-specific import cycle avoidance (Angular's `inject`
+// resolves this service by TOKEN, so no circular value import exists here at all - only the
+// type-only imports below, erased at compile time).
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { Injectable, inject, signal } from '@angular/core';
+// NOT `providedIn: 'root'` - deliberately component-scoped (see CLAUDE.md's design note for this
+// package): every NavigationScopeDirective usage re-provides this token, so DI naturally mints one
+// instance per route/screen, exactly like a fresh React Context value per screen.
+let NavigationContextService = (() => {
+    let _classDecorators = [Injectable()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var NavigationContextService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            NavigationContextService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        ambientParent = inject(NavigationContextService, {
+            optional: true,
+            skipSelf: true,
+        });
+        // `route` is the one field that legitimately changes over a mounted screen's lifetime (a
+        // setParams call swaps in a new route OBJECT with the same key/name) while the screen itself
+        // stays mounted - a plain field would go stale the moment a consumer reads it once (e.g. in a
+        // constructor, the natural `inject()` call site). A signal lets `injectRoute()`
+        // (./injectors/inject-route) hand back a live, reactive value with zero per-consumer
+        // subscription plumbing, matching this
+        // package's zoneless/signals-first convention. `navigation`/`emitter` are stable for a screen's
+        // whole lifetime, so they stay plain fields - no reactivity needed there.
+        routeSignal = signal(undefined);
+        route = this.routeSignal.asReadonly();
+        navigation;
+        emitter;
+        get parent() {
+            return this.ambientParent ?? undefined;
+        }
+        setRoute(route) {
+            this.routeSignal.set(route);
+        }
+    };
+    return NavigationContextService = _classThis;
+})();
+export { NavigationContextService };
+// Every injectX function (./injectors/*) opens with the same optional-inject-then-throw guard;
+// this centralizes it so the "must be used within a screen rendered by..." message stays
+// identical everywhere instead of six independently-typed copies. Must be called from an
+// injection context, same requirement `inject()` itself has - every call site is the first line
+// of an injectX function, which callers already only invoke from their own injection context.
+export function requireNavigationContext(injectorName) {
+    const context = inject(NavigationContextService, { optional: true });
+    if (!context) {
+        throw new Error(`${injectorName} must be used within a screen rendered by <Stack>, <Tab>, or <Drawer>`);
+    }
+    return context;
+}

package/build/angular/navigation-scope.directive.d.ts

@@ -0,0 +1,10 @@
+import { type OnChanges } from '@angular/core';
+import type { INavigationEmitter, IRoute } from '../core';
+import { type IAnyNavigatorHandle } from './navigation-context.service';
+export declare class NavigationScopeDirective implements OnChanges {
+    route: IRoute<unknown>;
+    navigation: IAnyNavigatorHandle;
+    emitter: INavigationEmitter;
+    private readonly context;
+    ngOnChanges(): void;
+}