@symbiote-native/navigation 1.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"inject-focus-effect.js","sourceRoot":"","sources":["../../../src/angular/injectors/inject-focus-effect.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,8FAA8F;AAC9F,mGAAmG;AACnG,6FAA6F;AAC7F,kGAAkG;AAClG,kGAAkG;AAClG,wFAAwF;AAExF,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAIzE,MAAM,UAAU,iBAAiB,CAAC,MAA4B;IAC5D,MAAM,OAAO,GAAG,wBAAwB,CAAC,mBAAmB,CAAC,CAAC;IAC9D,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IAEtC,IAAI,OAAyC,CAAC;IAE9C,MAAM,SAAS,GAAG,GAAS,EAAE;QAC3B,OAAO,GAAG,MAAM,EAAE,CAAC;IACrB,CAAC,CAAC;IACF,MAAM,UAAU,GAAG,GAAS,EAAE;QAC5B,OAAO,EAAE,EAAE,CAAC;QACZ,OAAO,GAAG,SAAS,CAAC;IACtB,CAAC,CAAC;IAEF,MAAM,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,sBAAsB,EAAE,SAAS,CAAC,CAAC;IACxF,MAAM,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,qBAAqB,EAAE,UAAU,CAAC,CAAC;IAEvF,UAAU,CAAC,SAAS,CAAC,GAAG,EAAE;QACxB,gBAAgB,EAAE,CAAC;QACnB,eAAe,EAAE,CAAC;QAClB,UAAU,EAAE,CAAC;IACf,CAAC,CAAC,CAAC;AACL,CAAC"}

package/build-ngc/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-ngc/angular/injectors/inject-is-focused.js

@@ -0,0 +1,22 @@
+// 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';
+import { requireNavigationContext } from '../navigation-context.service';
+export function injectIsFocused() {
+    const context = requireNavigationContext('injectIsFocused');
+    const destroyRef = inject(DestroyRef);
+    const isFocused = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "isFocused" }] : /* istanbul ignore next */ []));
+    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();
+}
+//# sourceMappingURL=inject-is-focused.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inject-is-focused.js","sourceRoot":"","sources":["../../../src/angular/injectors/inject-is-focused.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAChG,mGAAmG;AACnG,mGAAmG;AACnG,6FAA6F;AAC7F,6FAA6F;AAE7F,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AACxE,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,MAAM,UAAU,eAAe;IAC7B,MAAM,OAAO,GAAG,wBAAwB,CAAC,iBAAiB,CAAC,CAAC;IAC5D,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IACtC,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK;kFAAC,CAAC;IAEhC,MAAM,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,sBAAsB,EAAE,GAAG,EAAE,CAChF,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CACpB,CAAC;IACF,MAAM,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,qBAAqB,EAAE,GAAG,EAAE,CAC9E,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CACrB,CAAC;IACF,UAAU,CAAC,SAAS,CAAC,GAAG,EAAE;QACxB,gBAAgB,EAAE,CAAC;QACnB,eAAe,EAAE,CAAC;IACpB,CAAC,CAAC,CAAC;IAEH,OAAO,SAAS,CAAC,UAAU,EAAE,CAAC;AAChC,CAAC"}

package/build-ngc/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-ngc/angular/injectors/inject-navigation-state.js

@@ -0,0 +1,37 @@
+// 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';
+import { requireNavigationContext } from '../navigation-context.service';
+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] }), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "result" }] : /* istanbul ignore next */ []));
+    const unsubscribe = context.emitter.addListener(NAVIGATION_EVENT_STATE, (state) => {
+        if (!isNavigatorState(state))
+            return;
+        result.set(selector(state));
+    });
+    destroyRef.onDestroy(unsubscribe);
+    return result.asReadonly();
+}
+//# sourceMappingURL=inject-navigation-state.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inject-navigation-state.js","sourceRoot":"","sources":["../../../src/angular/injectors/inject-navigation-state.ts"],"names":[],"mappings":"AAAA,kGAAkG;AAClG,8FAA8F;AAC9F,sFAAsF;AACtF,kGAAkG;AAClG,sEAAsE;AACtE,EAAE;AACF,iGAAiG;AACjG,mGAAmG;AACnG,kGAAkG;AAClG,gDAAgD;AAEhD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AACxE,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAEpD,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,SAAS,QAAQ,CAAC,KAAc;IAC9B,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,CAAC;AACrD,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAc;IACtC,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;AACxD,CAAC;AAED,MAAM,UAAU,qBAAqB,CACnC,QAA6C;IAE7C,MAAM,OAAO,GAAG,wBAAwB,CAAC,uBAAuB,CAAC,CAAC;IAClE,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IACtC,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IAC9B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CACb,yFAAyF,CAC1F,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;+EAAC,CAAC;IAErD,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,sBAAsB,EAAE,CAAC,KAAc,EAAE,EAAE;QACzF,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC;YAAE,OAAO;QACrC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;IAC9B,CAAC,CAAC,CAAC;IACH,UAAU,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;IAElC,OAAO,MAAM,CAAC,UAAU,EAAE,CAAC;AAC7B,CAAC"}

package/build-ngc/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-ngc/angular/injectors/inject-navigation.js

@@ -0,0 +1,17 @@
+// 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';
+export function injectNavigation() {
+    const context = requireNavigationContext('injectNavigation');
+    return {
+        ...context.navigation,
+        addListener: context.emitter.addListener,
+        getParent: () => context.parent?.navigation,
+    };
+}
+//# sourceMappingURL=inject-navigation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inject-navigation.js","sourceRoot":"","sources":["../../../src/angular/injectors/inject-navigation.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,iGAAiG;AACjG,0FAA0F;AAC1F,mGAAmG;AACnG,+FAA+F;AAC/F,6FAA6F;AAC7F,+CAA+C;AAG/C,OAAO,EAAE,wBAAwB,EAA4B,MAAM,+BAA+B,CAAC;AASnG,MAAM,UAAU,gBAAgB;IAC9B,MAAM,OAAO,GAAG,wBAAwB,CAAC,kBAAkB,CAAC,CAAC;IAC7D,OAAO;QACL,GAAG,OAAO,CAAC,UAAU;QACrB,WAAW,EAAE,OAAO,CAAC,OAAO,CAAC,WAAW;QACxC,SAAS,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,MAAM,EAAE,UAAU;KAC5C,CAAC;AACJ,CAAC"}

package/build-ngc/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-ngc/angular/injectors/inject-route.js

@@ -0,0 +1,21 @@
+// 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';
+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;
+    });
+}
+//# sourceMappingURL=inject-route.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inject-route.js","sourceRoot":"","sources":["../../../src/angular/injectors/inject-route.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,8FAA8F;AAC9F,6EAA6E;AAC7E,+FAA+F;AAC/F,+BAA+B;AAE/B,OAAO,EAAE,QAAQ,EAAe,MAAM,eAAe,CAAC;AAEtD,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,MAAM,UAAU,WAAW;IACzB,MAAM,OAAO,GAAG,wBAAwB,CAAC,aAAa,CAAC,CAAC;IACxD,gFAAgF;IAChF,8FAA8F;IAC9F,+FAA+F;IAC/F,OAAO,QAAQ,CAAC,GAAG,EAAE;QACnB,MAAM,OAAO,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;QAChC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CACb,+EAA+E,CAChF,CAAC;QACJ,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC,CAAC,CAAC;AACL,CAAC"}

package/build-ngc/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-ngc/angular/injectors/inject-stack-navigation.js

@@ -0,0 +1,16 @@
+// 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';
+import { injectNavigation } from './inject-navigation';
+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;
+}
+//# sourceMappingURL=inject-stack-navigation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inject-stack-navigation.js","sourceRoot":"","sources":["../../../src/angular/injectors/inject-stack-navigation.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,+FAA+F;AAC/F,0FAA0F;AAC1F,mFAAmF;AAGnF,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAMvD,MAAM,UAAU,qBAAqB;IACnC,MAAM,UAAU,GAAG,gBAAgB,EAAE,CAAC;IACtC,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC,EAAE,CAAC;QACxC,MAAM,IAAI,KAAK,CACb,uFAAuF;YACrF,yFAAyF;YACzF,iBAAiB,CACpB,CAAC;IACJ,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC"}

package/build-ngc/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-ngc/angular/injectors/inject-tab-navigation.js

@@ -0,0 +1,12 @@
+// Twin of inject-stack-navigation.ts, narrowing to a Tab handle instead.
+import { isTabNavigatorHandle } from '../../core';
+import { injectNavigation } from './inject-navigation';
+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;
+}
+//# sourceMappingURL=inject-tab-navigation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inject-tab-navigation.js","sourceRoot":"","sources":["../../../src/angular/injectors/inject-tab-navigation.ts"],"names":[],"mappings":"AAAA,yEAAyE;AAGzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAMvD,MAAM,UAAU,mBAAmB;IACjC,MAAM,UAAU,GAAG,gBAAgB,EAAE,CAAC;IACtC,IAAI,CAAC,oBAAoB,CAAC,UAAU,CAAC,EAAE,CAAC;QACtC,MAAM,IAAI,KAAK,CACb,0FAA0F;YACxF,iGAAiG,CACpG,CAAC;IACJ,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC"}

package/build-ngc/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-ngc/angular/linking.js

@@ -0,0 +1,44 @@
+// 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';
+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();
+    });
+}
+//# sourceMappingURL=linking.js.map

package/build-ngc/angular/linking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linking.js","sourceRoot":"","sources":["../../src/angular/linking.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,+FAA+F;AAC/F,mGAAmG;AACnG,wFAAwF;AACxF,+FAA+F;AAC/F,8FAA8F;AAC9F,0FAA0F;AAC1F,gGAAgG;AAChG,kGAAkG;AAClG,sBAAsB;AAEtB,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAI9C,MAAM,UAAU,wBAAwB,CACtC,MAAsB,EACtB,eAAiC;IAEjC,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IAEtC,SAAS,UAAU,CAAC,GAAW,EAAE,QAAkD;QACjF,MAAM,KAAK,GAAG,mBAAmB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAC/C,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,IAAI,CAAC,oDAAoD,GAAG,GAAG,CAAC,CAAC;YACjE,OAAO;QACT,CAAC;QACD,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;IAED,IAAI,SAAS,GAAG,KAAK,CAAC;IAEtB,OAAO,CAAC,aAAa,EAAE;SACpB,IAAI,CAAC,GAAG,CAAC,EAAE;QACV,IAAI,SAAS,IAAI,GAAG,KAAK,IAAI;YAAE,OAAO;QACtC,IAAI,CAAC,0CAA0C,GAAG,GAAG,CAAC,CAAC;QACvD,UAAU,CAAC,GAAG,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;IAC3C,CAAC,CAAC;SACD,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;QACxB,IAAI,CAAC,mDAAmD,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC,CAAC,CAAC;IAEL,MAAM,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC,KAAgB,EAAE,EAAE;QACxE,IAAI,CAAC,wCAAwC,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC;QAC3D,UAAU,CAAC,KAAK,CAAC,GAAG,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC,CAAC,CAAC;IAEH,UAAU,CAAC,SAAS,CAAC,GAAG,EAAE;QACxB,SAAS,GAAG,IAAI,CAAC;QACjB,YAAY,CAAC,MAAM,EAAE,CAAC;IACxB,CAAC,CAAC,CAAC;AACL,CAAC"}

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

@@ -0,0 +1,16 @@
+import { type Signal } from '@angular/core';
+import type { INavigationEmitter, IRoute, IAnyNavigatorHandle } from '../core';
+import * as i0 from "@angular/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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationContextService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationContextService>;
+}
+export declare function requireNavigationContext(injectorName: string): NavigationContextService;

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

@@ -0,0 +1,63 @@
+// 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).
+import { Injectable, inject, signal } from '@angular/core';
+import * as i0 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.
+export class NavigationContextService {
+    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, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "routeSignal" }] : /* istanbul ignore next */ []));
+    route = this.routeSignal.asReadonly();
+    navigation;
+    emitter;
+    get parent() {
+        return this.ambientParent ?? undefined;
+    }
+    setRoute(route) {
+        this.routeSignal.set(route);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: NavigationContextService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: NavigationContextService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: NavigationContextService, decorators: [{
+            type: Injectable
+        }] });
+// 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;
+}
+//# sourceMappingURL=navigation-context.service.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"navigation-context.service.js","sourceRoot":"","sources":["../../src/angular/navigation-context.service.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,+FAA+F;AAC/F,8FAA8F;AAC9F,kGAAkG;AAClG,kGAAkG;AAClG,kGAAkG;AAClG,gGAAgG;AAChG,kGAAkG;AAClG,qFAAqF;AACrF,EAAE;AACF,+FAA+F;AAC/F,sFAAsF;AACtF,mGAAmG;AACnG,4FAA4F;AAC5F,oDAAoD;AAEpD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;;AAKxE,iGAAiG;AACjG,mGAAmG;AACnG,kFAAkF;AAElF,MAAM,OAAO,wBAAwB;IAClB,aAAa,GAAG,MAAM,CAAC,wBAAwB,EAAE;QAChE,QAAQ,EAAE,IAAI;QACd,QAAQ,EAAE,IAAI;KACf,CAAC,CAAC;IAEH,yFAAyF;IACzF,6FAA6F;IAC7F,8FAA8F;IAC9F,gFAAgF;IAChF,qFAAqF;IACrF,uCAAuC;IACvC,gGAAgG;IAChG,0EAA0E;IACzD,WAAW,GAAG,MAAM,CAA8B,SAAS;oFAAC,CAAC;IACrE,KAAK,GAAwC,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;IAEpF,UAAU,CAAuB;IACjC,OAAO,CAAsB;IAE7B,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,aAAa,IAAI,SAAS,CAAC;IACzC,CAAC;IAED,QAAQ,CAAC,KAAsB;QAC7B,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;uGA1BU,wBAAwB;2GAAxB,wBAAwB;;2FAAxB,wBAAwB;kBADpC,UAAU;;AA8BX,+FAA+F;AAC/F,yFAAyF;AACzF,yFAAyF;AACzF,gGAAgG;AAChG,8FAA8F;AAC9F,MAAM,UAAU,wBAAwB,CAAC,YAAoB;IAC3D,MAAM,OAAO,GAAG,MAAM,CAAC,wBAAwB,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IACrE,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,GAAG,YAAY,uEAAuE,CACvF,CAAC;IACJ,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC"}

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

@@ -0,0 +1,13 @@
+import { type OnChanges } from '@angular/core';
+import type { INavigationEmitter, IRoute } from '../core';
+import { type IAnyNavigatorHandle } from './navigation-context.service';
+import * as i0 from "@angular/core";
+export declare class NavigationScopeDirective implements OnChanges {
+    route: IRoute<unknown>;
+    navigation: IAnyNavigatorHandle;
+    emitter: INavigationEmitter;
+    private readonly context;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationScopeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NavigationScopeDirective, "[symbioteNavigationScope]", never, { "route": { "alias": "symbioteNavigationScope"; "required": true; }; "navigation": { "alias": "navigation"; "required": true; }; "emitter": { "alias": "emitter"; "required": true; }; }, {}, never, never, true, never>;
+}

package/build-ngc/angular/navigation-scope.directive.js

@@ -0,0 +1,42 @@
+// The Angular twin of react/navigation-context.ts's `NavigationContext.Provider` usage in
+// stack.ts/tabs.ts/drawer.ts's render loops: one directive instance = one fresh scope. Applying
+// `[symbioteNavigationScope]` to an element re-`providers: [NavigationContextService]`
+// (component/directive-level DI), so every usage mints its OWN service instance - the DI twin of
+// `createElement(NavigationContext.Provider, { value }, content)`. Descendants (a screen's own
+// component tree, reached through `*ngComponentOutlet`) call `inject(NavigationContextService)`
+// and resolve to the NEAREST enclosing instance, exactly like `useContext(NavigationContext)`
+// walks to the nearest Provider.
+import { Directive, Input, inject } from '@angular/core';
+import { NavigationContextService } from './navigation-context.service';
+import * as i0 from "@angular/core";
+export class NavigationScopeDirective {
+    route;
+    navigation;
+    emitter;
+    context = inject(NavigationContextService);
+    ngOnChanges() {
+        this.context.setRoute(this.route);
+        this.context.navigation = this.navigation;
+        this.context.emitter = this.emitter;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: NavigationScopeDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.5", type: NavigationScopeDirective, isStandalone: true, selector: "[symbioteNavigationScope]", inputs: { route: ["symbioteNavigationScope", "route"], navigation: "navigation", emitter: "emitter" }, providers: [NavigationContextService], usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: NavigationScopeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[symbioteNavigationScope]',
+                    standalone: true,
+                    providers: [NavigationContextService],
+                }]
+        }], propDecorators: { route: [{
+                type: Input,
+                args: [{ required: true, alias: 'symbioteNavigationScope' }]
+            }], navigation: [{
+                type: Input,
+                args: [{ required: true }]
+            }], emitter: [{
+                type: Input,
+                args: [{ required: true }]
+            }] } });
+//# sourceMappingURL=navigation-scope.directive.js.map

package/build-ngc/angular/navigation-scope.directive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation-scope.directive.js","sourceRoot":"","sources":["../../src/angular/navigation-scope.directive.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAC1F,gGAAgG;AAChG,uFAAuF;AACvF,iGAAiG;AACjG,+FAA+F;AAC/F,gGAAgG;AAChG,8FAA8F;AAC9F,iCAAiC;AAEjC,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAkB,MAAM,eAAe,CAAC;AAEzE,OAAO,EAAE,wBAAwB,EAA4B,MAAM,8BAA8B,CAAC;;AAOlG,MAAM,OAAO,wBAAwB;IAC0B,KAAK,CAAmB;IAC1D,UAAU,CAAuB;IACjC,OAAO,CAAsB;IAEvC,OAAO,GAAG,MAAM,CAAC,wBAAwB,CAAC,CAAC;IAE5D,WAAW;QACT,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAClC,IAAI,CAAC,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QAC1C,IAAI,CAAC,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;IACtC,CAAC;uGAXU,wBAAwB;2FAAxB,wBAAwB,+KAFxB,CAAC,wBAAwB,CAAC;;2FAE1B,wBAAwB;kBALpC,SAAS;mBAAC;oBACT,QAAQ,EAAE,2BAA2B;oBACrC,UAAU,EAAE,IAAI;oBAChB,SAAS,EAAE,CAAC,wBAAwB,CAAC;iBACtC;;sBAEE,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,yBAAyB,EAAE;;sBAC1D,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;;sBACxB,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE"}

package/build-ngc/angular/screen.directive.d.ts

@@ -0,0 +1,25 @@
+import { type Type } from '@angular/core';
+import type { ISearchBarCommands, ISearchBarOptions, IScreenOptions, IRoute } from '../core';
+import type { INavigatorHandle } from '../core';
+import * as i0 from "@angular/core";
+export type IAngularSearchBarOptions = ISearchBarOptions & {
+    ref?: {
+        current: ISearchBarCommands | null;
+    };
+};
+export type IAngularScreenOptions = Omit<IScreenOptions, 'headerSearchBarOptions'> & {
+    headerSearchBarOptions?: IAngularSearchBarOptions;
+};
+export type IScreenOptionsArgs = {
+    route: IRoute<unknown>;
+    navigation: INavigatorHandle;
+};
+export type IScreenOptionsResolver = (args: IScreenOptionsArgs) => IAngularScreenOptions;
+export declare class ScreenDirective {
+    name: string;
+    component: Type<unknown>;
+    options?: IAngularScreenOptions | IScreenOptionsResolver;
+    initialParams?: unknown;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScreenDirective, "ng-template[symbioteScreen]", never, { "name": { "alias": "name"; "required": true; }; "component": { "alias": "component"; "required": true; }; "options": { "alias": "options"; "required": false; }; "initialParams": { "alias": "initialParams"; "required": false; }; }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,35 @@
+// [symbioteScreen]: a declarative marker, never rendered on its own - Stack reads its inputs via
+// @ContentChildren to build the static name -> {component, options} registry, then mounts the
+// registered component itself for each pushed route. Angular's twin of react/screen.ts's Screen
+// marker component; mirrors Angular Material's own `@ContentChildren(MatTab) tabs: QueryList<MatTab>`
+// pattern (a directive applied to an inert `<ng-template>`, never instantiated as a view - see
+// stack.ts's header for why that's safe: @ContentChildren resolves the light-DOM declaration,
+// independent of whether the template is ever instantiated).
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ScreenDirective {
+    name;
+    component;
+    options;
+    initialParams;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: ScreenDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.5", type: ScreenDirective, isStandalone: true, selector: "ng-template[symbioteScreen]", inputs: { name: "name", component: "component", options: "options", initialParams: "initialParams" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: ScreenDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ng-template[symbioteScreen]',
+                    standalone: true,
+                }]
+        }], propDecorators: { name: [{
+                type: Input,
+                args: [{ required: true }]
+            }], component: [{
+                type: Input,
+                args: [{ required: true }]
+            }], options: [{
+                type: Input
+            }], initialParams: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=screen.directive.js.map

package/build-ngc/angular/screen.directive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen.directive.js","sourceRoot":"","sources":["../../src/angular/screen.directive.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,8FAA8F;AAC9F,gGAAgG;AAChG,sGAAsG;AACtG,+FAA+F;AAC/F,8FAA8F;AAC9F,6DAA6D;AAE7D,OAAO,EAAE,SAAS,EAAE,KAAK,EAAa,MAAM,eAAe,CAAC;;AAkC5D,MAAM,OAAO,eAAe;IACC,IAAI,CAAU;IACd,SAAS,CAAiB;IAC5C,OAAO,CAAkD;IACzD,aAAa,CAAW;uGAJtB,eAAe;2FAAf,eAAe;;2FAAf,eAAe;kBAJ3B,SAAS;mBAAC;oBACT,QAAQ,EAAE,6BAA6B;oBACvC,UAAU,EAAE,IAAI;iBACjB;;sBAEE,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;;sBACxB,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;;sBACxB,KAAK;;sBACL,KAAK"}

package/build-ngc/angular/search-bar-ref.directive.d.ts

@@ -0,0 +1,13 @@
+import { type OnDestroy, type OnInit } from '@angular/core';
+import type { ISearchBarCommands } from '../core';
+import * as i0 from "@angular/core";
+export declare class SearchBarRefDirective implements OnInit, OnDestroy {
+    ref: {
+        current: ISearchBarCommands | null;
+    } | undefined;
+    private readonly elementRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchBarRefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SearchBarRefDirective, "[symbioteSearchBarRef]", never, { "ref": { "alias": "symbioteSearchBarRef"; "required": false; }; }, {}, never, never, true, never>;
+}

package/build-ngc/angular/search-bar-ref.directive.js

@@ -0,0 +1,44 @@
+// Assigns the app-supplied `headerSearchBarOptions.ref` (a plain `{ current }` cell - see
+// screen.directive.ts's IAngularSearchBarOptions) once the RNSSearchBar native node exists.
+// Angular's twin of react/stack.ts's callback `ref` prop on the RNSSearchBar element: a directive
+// applied directly onto the raw `<RNSSearchBar>` tag can `inject(ElementRef)` the same way
+// SymbioteHostPropsDirective does (primitives/shared.ts's own pattern) - ElementRef.nativeElement
+// is the real engine node the moment the element is created (synchronous, no whenCommitted wait
+// needed here: buildSearchBarHandle's own methods are already a LAZY getter over the node,
+// tolerant of the node existing-but-not-yet-committed, same contract every adapter shares).
+import { Directive, Input, inject, ElementRef } from '@angular/core';
+import { isSymbioteNode, dlog, debugNodeId } from '@symbiote-native/engine';
+import { buildSearchBarHandle } from '../core';
+import * as i0 from "@angular/core";
+export class SearchBarRefDirective {
+    ref;
+    elementRef = inject(ElementRef);
+    ngOnInit() {
+        if (!this.ref)
+            return;
+        const node = this.elementRef.nativeElement;
+        if (!isSymbioteNode(node)) {
+            this.ref.current = null;
+            return;
+        }
+        dlog(`SearchBarRefDirective: attached to node=${debugNodeId(node)}`);
+        this.ref.current = buildSearchBarHandle(() => node);
+    }
+    ngOnDestroy() {
+        if (this.ref)
+            this.ref.current = null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: SearchBarRefDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.0.5", type: SearchBarRefDirective, isStandalone: true, selector: "[symbioteSearchBarRef]", inputs: { ref: ["symbioteSearchBarRef", "ref"] }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: SearchBarRefDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[symbioteSearchBarRef]',
+                    standalone: true,
+                }]
+        }], propDecorators: { ref: [{
+                type: Input,
+                args: ['symbioteSearchBarRef']
+            }] } });
+//# sourceMappingURL=search-bar-ref.directive.js.map

package/build-ngc/angular/search-bar-ref.directive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-bar-ref.directive.js","sourceRoot":"","sources":["../../src/angular/search-bar-ref.directive.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAC1F,4FAA4F;AAC5F,kGAAkG;AAClG,2FAA2F;AAC3F,kGAAkG;AAClG,gGAAgG;AAChG,2FAA2F;AAC3F,4FAA4F;AAE5F,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAA+B,UAAU,EAAE,MAAM,eAAe,CAAC;AAClG,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;;AAO/C,MAAM,OAAO,qBAAqB;IACD,GAAG,CAAqD;IAEtE,UAAU,GAAG,MAAM,CAAsB,UAAU,CAAC,CAAC;IAEtE,QAAQ;QACN,IAAI,CAAC,IAAI,CAAC,GAAG;YAAE,OAAO;QACtB,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC;QAC3C,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;YAC1B,IAAI,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC;YACxB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,2CAA2C,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACrE,IAAI,CAAC,GAAG,CAAC,OAAO,GAAG,oBAAoB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;IACtD,CAAC;IAED,WAAW;QACT,IAAI,IAAI,CAAC,GAAG;YAAE,IAAI,CAAC,GAAG,CAAC,OAAO,GAAG,IAAI,CAAC;IACxC,CAAC;uGAlBU,qBAAqB;2FAArB,qBAAqB;;2FAArB,qBAAqB;kBAJjC,SAAS;mBAAC;oBACT,QAAQ,EAAE,wBAAwB;oBAClC,UAAU,EAAE,IAAI;iBACjB;;sBAEE,KAAK;uBAAC,sBAAsB"}

package/build-ngc/angular/stack/index.d.ts

@@ -0,0 +1,58 @@
+import { type AfterContentInit, type OnDestroy, type Type } from '@angular/core';
+import type { INavigationEmitter, INavigatorHandle, INavigatorState, IRoute, ISearchBarCommands } from '../../core';
+import type { IAngularScreenOptions } from '../screen.directive';
+import * as i0 from "@angular/core";
+export type { INavigatorHandle } from '../../core';
+export declare class Stack implements AfterContentInit, OnDestroy, INavigatorHandle {
+    private readonly screenChildren;
+    initialRouteName?: string;
+    screenOptions?: IAngularScreenOptions;
+    readonly headerSubviewProps: Record<string, unknown>;
+    private readonly routeIdPrefix;
+    private readonly registry;
+    private readonly emitters;
+    private readonly planCache;
+    private routeSequence;
+    private screenChildrenSubscription;
+    private readonly stateSignal;
+    readonly state: import("@angular/core").Signal<Readonly<{
+        routes: readonly Readonly<{
+            key: string;
+            name: string;
+            params: unknown;
+        }>[];
+    }> | undefined>;
+    readonly push: (name: string, params?: unknown) => void;
+    readonly pop: (count?: number) => void;
+    readonly popToTop: () => void;
+    readonly popTo: (key: string) => void;
+    readonly replace: (name: string, params?: unknown) => void;
+    readonly setParams: (params: unknown, key?: string) => void;
+    readonly reset: (nextState: INavigatorState) => void;
+    readonly canGoBack: () => boolean;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    private rebuildRegistry;
+    private initializeState;
+    private createRoute;
+    private dispatch;
+    emitterFor(routeKey: string): INavigationEmitter;
+    private mergedOptionsFor;
+    componentFor(route: IRoute<unknown>): Type<unknown> | null;
+    stackHostProps(): Record<string, unknown>;
+    private planFor;
+    outerScreenIsModal(route: IRoute<unknown>, index: number): boolean;
+    isInModal(route: IRoute<unknown>, index: number): boolean;
+    screenHostProps(route: IRoute<unknown>, index: number): Record<string, unknown>;
+    innerStackProps(): Record<string, unknown>;
+    innerScreenProps(route: IRoute<unknown>, index: number): Record<string, unknown>;
+    contentWrapperProps(route: IRoute<unknown>, index: number): Record<string, unknown>;
+    headerConfigProps(route: IRoute<unknown>, index: number): Record<string, unknown>;
+    hasSearchBar(route: IRoute<unknown>): boolean;
+    searchBarRef(route: IRoute<unknown>): {
+        current: ISearchBarCommands | null;
+    } | undefined;
+    searchBarProps(route: IRoute<unknown>, index: number): Record<string, unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Stack, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Stack, "Stack", never, { "initialRouteName": { "alias": "initialRouteName"; "required": false; }; "screenOptions": { "alias": "screenOptions"; "required": false; }; }, {}, ["screenChildren"], never, true, never>;
+}