@ng-native/router 0.0.1 → 0.1.1

package/dist/provide-native-router.js

@@ -0,0 +1,151 @@
+/**
+ * Angular's Router, on native navigation: `provideRouter` and the native pieces under it, in one
+ * call.
+ *
+ * `provideNativeRouter(routes, withComponentInputBinding())` takes the same routes and the same
+ * router features as `provideRouter` - it calls it - and adds what native needs on top: a
+ * `PlatformLocation` over an in-memory history, a `RouteReuseStrategy` that detaches a pushed-away
+ * screen instead of destroying it, and `NativeNavigation`. Those come after `provideRouter`'s own
+ * providers, so they win over the web defaults without the app having to order anything.
+ *
+ * Deep links and Android's back button come from `@ng-native/device` and need no wiring: off a
+ * device both report nothing, and navigation works either way. The native options - `withLinkParent`,
+ * `withHeaderDefaults` and `withTabDefaults` - are passed like any other feature.
+ */
+import { PlatformLocation } from '@angular/common';
+import { NavigationCancel, NavigationEnd, NavigationError, RouteReuseStrategy, Router, provideRouter, } from '@angular/router';
+import { computed, inject, makeEnvironmentProviders, provideEnvironmentInitializer, } from '@angular/core';
+import { ColorScheme, DeepLinks } from '@ng-native/device';
+import { NATIVE_HEADER_DEFAULTS, NATIVE_TAB_DEFAULTS, } from "./native-bar-defaults.js";
+import { followLink, linkAncestry } from "./native-links.js";
+import { NativeNavigation } from "./native-navigation.js";
+import { NativePlatformLocation } from "./native-platform-location.js";
+import { NativeStackReuseStrategy } from "./native-stack-reuse-strategy.js";
+import { registerScreenComponents } from "./screens.js";
+/**
+ * The page a deep link opens on top of, or null to open it alone. Without it a link to
+ * `/settings/notifications` opens that page with no Back. See native-links.ts.
+ */
+export function withLinkParent(parentOf) {
+    return { ɵnativeRouter: { linkParent: parentOf } };
+}
+/**
+ * How every `<native-header>` looks when it does not say: its colours, blur, shadow, fonts and
+ * light or dark style. A header's own binding always wins.
+ *
+ * ```ts
+ * provideNativeRouter(
+ *   routes,
+ *   withHeaderDefaults((scheme) => ({
+ *     backgroundColor: scheme === 'dark' ? '#101014' : '#f4f4f7',
+ *     titleColor: scheme === 'dark' ? '#ffffff' : '#101014',
+ *     color: '#3b6ef5',
+ *   })),
+ * );
+ * ```
+ *
+ * Colours it leaves out still come from `NATIVE_HEADER_PALETTE`.
+ */
+export function withHeaderDefaults(defaults) {
+    return { ɵnativeRouter: { providers: [bySchemeProvider(NATIVE_HEADER_DEFAULTS, defaults)] } };
+}
+/**
+ * How every `<native-tabs-outlet>` and `<native-tab>` looks when it does not say: the tint, the
+ * background behind the tabs, the light or dark style, and each tab's bar appearance. An outlet's
+ * or a tab's own binding always wins.
+ */
+export function withTabDefaults(defaults) {
+    return { ɵnativeRouter: { providers: [bySchemeProvider(NATIVE_TAB_DEFAULTS, defaults)] } };
+}
+/** One signal for the whole app, rather than every bar calling the function again. */
+function bySchemeProvider(token, defaults) {
+    return {
+        provide: token,
+        useFactory: () => {
+            if (typeof defaults !== 'function')
+                return computed(() => defaults);
+            const scheme = inject(ColorScheme);
+            return computed(() => defaults(scheme.current()));
+        },
+    };
+}
+function isNative(feature) {
+    return 'ɵnativeRouter' in feature;
+}
+export function provideNativeRouter(routes, ...features) {
+    const angular = features.filter((feature) => !isNative(feature));
+    const native = features.filter(isNative).map((feature) => feature.ɵnativeRouter);
+    const parentOf = native.find((feature) => feature.linkParent)?.linkParent;
+    return makeEnvironmentProviders([
+        provideRouter(routes, ...angular),
+        ...nativeProviders(parentOf),
+        ...native.flatMap((feature) => feature.providers ?? []),
+    ]);
+}
+function nativeProviders(parentOf) {
+    // The engine needs the element-to-view-name mapping before the first navigation renders.
+    registerScreenComponents();
+    const shared = [
+        // Without this the router never detaches, so a pushed-away screen is destroyed and rebuilt.
+        { provide: RouteReuseStrategy, useClass: NativeStackReuseStrategy },
+        NativeNavigation,
+    ];
+    if (!parentOf) {
+        return [
+            {
+                provide: PlatformLocation,
+                useFactory: () => new NativePlatformLocation(inject(DeepLinks)),
+            },
+            ...shared,
+        ];
+    }
+    return [
+        {
+            provide: PlatformLocation,
+            // The app launches on the page the link belongs under; the link follows once it is shown.
+            // Links while running go through the router below rather than straight into history.
+            useFactory: () => {
+                const initial = inject(DeepLinks).initialUrl();
+                return new NativePlatformLocation({
+                    initialUrl: () => (initial && linkAncestry(initial, parentOf)[0]) || initial,
+                    subscribe: () => () => { },
+                });
+            },
+        },
+        provideEnvironmentInitializer(() => {
+            const router = inject(Router);
+            const links = inject(DeepLinks);
+            const initial = links.initialUrl();
+            if (initial && parentOf(initial)) {
+                const first = router.events.subscribe((event) => {
+                    if (!(event instanceof NavigationEnd))
+                        return;
+                    first.unsubscribe();
+                    void followLink(router, initial, parentOf);
+                });
+            }
+            // A launch link arrives the way any other does, once `getInitialURL()` settles, which is
+            // usually while the router's first navigation is still going: following it then cancels that
+            // navigation, and the app opens with no root screen under the link. So links wait for it.
+            const settled = new Promise((resolve) => {
+                if (router.navigated)
+                    return resolve();
+                const first = router.events.subscribe((event) => {
+                    if (!isEnd(event))
+                        return;
+                    first.unsubscribe();
+                    resolve();
+                });
+            });
+            links.subscribe((url) => void settled.then(() => followLink(router, url, parentOf)));
+        }),
+        ...shared,
+    ];
+}
+/** A navigation's last event, whichever way it went. */
+function isEnd(event) {
+    return (event instanceof NavigationEnd ||
+        event instanceof NavigationCancel ||
+        event instanceof NavigationError);
+}
+//# sourceMappingURL=provide-native-router.js.map

package/dist/provide-native-router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provide-native-router.js","sourceRoot":"","sources":["../src/provide-native-router.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Angular's Router, on native navigation: `provideRouter` and the native pieces under it, in one\n * call.\n *\n * `provideNativeRouter(routes, withComponentInputBinding())` takes the same routes and the same\n * router features as `provideRouter` - it calls it - and adds what native needs on top: a\n * `PlatformLocation` over an in-memory history, a `RouteReuseStrategy` that detaches a pushed-away\n * screen instead of destroying it, and `NativeNavigation`. Those come after `provideRouter`'s own\n * providers, so they win over the web defaults without the app having to order anything.\n *\n * Deep links and Android's back button come from `@ng-native/device` and need no wiring: off a\n * device both report nothing, and navigation works either way. The native options - `withLinkParent`,\n * `withHeaderDefaults` and `withTabDefaults` - are passed like any other feature.\n */\nimport { PlatformLocation } from '@angular/common';\nimport {\n  NavigationCancel,\n  NavigationEnd,\n  NavigationError,\n  RouteReuseStrategy,\n  Router,\n  provideRouter,\n  type RouterFeatures,\n  type Routes,\n} from '@angular/router';\nimport {\n  computed,\n  inject,\n  makeEnvironmentProviders,\n  provideEnvironmentInitializer,\n  type EnvironmentProviders,\n  type InjectionToken,\n  type Provider,\n  type Signal,\n} from '@angular/core';\nimport { ColorScheme, DeepLinks, type Scheme } from '@ng-native/device';\nimport {\n  NATIVE_HEADER_DEFAULTS,\n  NATIVE_TAB_DEFAULTS,\n  type HeaderDefaults,\n  type SchemeDefaults,\n  type TabDefaults,\n} from './native-bar-defaults.ts';\nimport { followLink, linkAncestry, type LinkParent } from './native-links.ts';\nimport { NativeNavigation } from './native-navigation.ts';\nimport { NativePlatformLocation } from './native-platform-location.ts';\nimport { NativeStackReuseStrategy } from './native-stack-reuse-strategy.ts';\nimport { registerScreenComponents } from './screens.ts';\n\n/** A native-only router option, passed to `provideNativeRouter` beside Angular's own features. */\nexport interface NativeRouterFeature {\n  readonly ɵnativeRouter: { readonly linkParent?: LinkParent; readonly providers?: Provider[] };\n}\n\n/**\n * The page a deep link opens on top of, or null to open it alone. Without it a link to\n * `/settings/notifications` opens that page with no Back. See native-links.ts.\n */\nexport function withLinkParent(parentOf: LinkParent): NativeRouterFeature {\n  return { ɵnativeRouter: { linkParent: parentOf } };\n}\n\n/**\n * How every `<native-header>` looks when it does not say: its colours, blur, shadow, fonts and\n * light or dark style. A header's own binding always wins.\n *\n * ```ts\n * provideNativeRouter(\n *   routes,\n *   withHeaderDefaults((scheme) => ({\n *     backgroundColor: scheme === 'dark' ? '#101014' : '#f4f4f7',\n *     titleColor: scheme === 'dark' ? '#ffffff' : '#101014',\n *     color: '#3b6ef5',\n *   })),\n * );\n * ```\n *\n * Colours it leaves out still come from `NATIVE_HEADER_PALETTE`.\n */\nexport function withHeaderDefaults(defaults: SchemeDefaults<HeaderDefaults>): NativeRouterFeature {\n  return { ɵnativeRouter: { providers: [bySchemeProvider(NATIVE_HEADER_DEFAULTS, defaults)] } };\n}\n\n/**\n * How every `<native-tabs-outlet>` and `<native-tab>` looks when it does not say: the tint, the\n * background behind the tabs, the light or dark style, and each tab's bar appearance. An outlet's\n * or a tab's own binding always wins.\n */\nexport function withTabDefaults(defaults: SchemeDefaults<TabDefaults>): NativeRouterFeature {\n  return { ɵnativeRouter: { providers: [bySchemeProvider(NATIVE_TAB_DEFAULTS, defaults)] } };\n}\n\n/** One signal for the whole app, rather than every bar calling the function again. */\nfunction bySchemeProvider<T>(\n  token: InjectionToken<Signal<T>>,\n  defaults: SchemeDefaults<T>,\n): Provider {\n  return {\n    provide: token,\n    useFactory: () => {\n      if (typeof defaults !== 'function') return computed(() => defaults);\n      const scheme = inject(ColorScheme);\n      return computed(() => (defaults as (scheme: Scheme) => T)(scheme.current()));\n    },\n  };\n}\n\nfunction isNative(feature: RouterFeatures | NativeRouterFeature): feature is NativeRouterFeature {\n  return 'ɵnativeRouter' in feature;\n}\n\nexport function provideNativeRouter(\n  routes: Routes,\n  ...features: (RouterFeatures | NativeRouterFeature)[]\n): EnvironmentProviders {\n  const angular = features.filter((feature): feature is RouterFeatures => !isNative(feature));\n  const native = features.filter(isNative).map((feature) => feature.ɵnativeRouter);\n  const parentOf = native.find((feature) => feature.linkParent)?.linkParent;\n  return makeEnvironmentProviders([\n    provideRouter(routes, ...angular),\n    ...nativeProviders(parentOf),\n    ...native.flatMap((feature) => feature.providers ?? []),\n  ]);\n}\n\nfunction nativeProviders(parentOf: LinkParent | undefined): (Provider | EnvironmentProviders)[] {\n  // The engine needs the element-to-view-name mapping before the first navigation renders.\n  registerScreenComponents();\n\n  const shared = [\n    // Without this the router never detaches, so a pushed-away screen is destroyed and rebuilt.\n    { provide: RouteReuseStrategy, useClass: NativeStackReuseStrategy },\n    NativeNavigation,\n  ];\n  if (!parentOf) {\n    return [\n      {\n        provide: PlatformLocation,\n        useFactory: () => new NativePlatformLocation(inject(DeepLinks)),\n      },\n      ...shared,\n    ];\n  }\n\n  return [\n    {\n      provide: PlatformLocation,\n      // The app launches on the page the link belongs under; the link follows once it is shown.\n      // Links while running go through the router below rather than straight into history.\n      useFactory: () => {\n        const initial = inject(DeepLinks).initialUrl();\n        return new NativePlatformLocation({\n          initialUrl: () => (initial && linkAncestry(initial, parentOf)[0]) || initial,\n          subscribe: () => () => {},\n        });\n      },\n    },\n    provideEnvironmentInitializer(() => {\n      const router = inject(Router);\n      const links = inject(DeepLinks);\n      const initial = links.initialUrl();\n      if (initial && parentOf(initial)) {\n        const first = router.events.subscribe((event) => {\n          if (!(event instanceof NavigationEnd)) return;\n          first.unsubscribe();\n          void followLink(router, initial, parentOf);\n        });\n      }\n      // A launch link arrives the way any other does, once `getInitialURL()` settles, which is\n      // usually while the router's first navigation is still going: following it then cancels that\n      // navigation, and the app opens with no root screen under the link. So links wait for it.\n      const settled = new Promise<void>((resolve) => {\n        if (router.navigated) return resolve();\n        const first = router.events.subscribe((event) => {\n          if (!isEnd(event)) return;\n          first.unsubscribe();\n          resolve();\n        });\n      });\n      links.subscribe((url) => void settled.then(() => followLink(router, url, parentOf)));\n    }),\n    ...shared,\n  ];\n}\n\n/** A navigation's last event, whichever way it went. */\nfunction isEnd(event: unknown): boolean {\n  return (\n    event instanceof NavigationEnd ||\n    event instanceof NavigationCancel ||\n    event instanceof NavigationError\n  );\n}\n"]}

package/dist/screen-presentation.d.ts

@@ -0,0 +1,69 @@
+/**
+ * How a screen arrives, which is the part of mobile navigation a URL cannot express.
+ *
+ * Every field is a prop on `RNSScreen`, spelled exactly as the codegen spec spells it, so the
+ * outlet forwards the object key by key rather than translating it. Anything here rides in
+ * history state (ADR 0003), so going back to a screen restores the presentation it was opened
+ * with.
+ */
+/** How the screen is mounted on the stack. */
+export type StackPresentation = 'push' | 'modal' | 'transparentModal' | 'fullScreenModal' | 'formSheet' | 'pageSheet' | 'containedModal' | 'containedTransparentModal';
+/** The transition it animates in with. `default` is the platform's own. */
+export type StackAnimation = 'default' | 'flip' | 'simple_push' | 'none' | 'fade' | 'slide_from_right' | 'slide_from_left' | 'slide_from_bottom' | 'fade_from_bottom' | 'ios_from_right' | 'ios_from_left';
+/** Which way the dismiss gesture runs. Vertical is what a sheet wants. */
+export type SwipeDirection = 'vertical' | 'horizontal';
+/** Whether replacing a screen animates as a push or a pop. */
+export type ReplaceAnimation = 'pop' | 'push';
+/** How far from the edge a dismiss gesture is recognised, in points. */
+export interface GestureResponseDistance {
+    readonly start?: number;
+    readonly end?: number;
+    readonly top?: number;
+    readonly bottom?: number;
+}
+export interface ScreenPresentation {
+    readonly stackPresentation?: StackPresentation;
+    readonly stackAnimation?: StackAnimation;
+    /** Milliseconds. Only read when `stackAnimation` is not `default`. */
+    readonly transitionDuration?: number;
+    readonly replaceAnimation?: ReplaceAnimation;
+    /** Swipe back, or drag a sheet down. On by default. */
+    readonly gestureEnabled?: boolean;
+    /** iOS: allow the swipe to start anywhere on the screen, not just its edge. */
+    readonly fullScreenSwipeEnabled?: boolean;
+    readonly fullScreenSwipeShadowEnabled?: boolean;
+    readonly swipeDirection?: SwipeDirection;
+    readonly gestureResponseDistance?: GestureResponseDistance;
+    /** Run the screen's own animation while swiping rather than the platform's. */
+    readonly customAnimationOnSwipe?: boolean;
+    /** Dismiss the keyboard when the gesture starts. */
+    readonly hideKeyboardOnSwipe?: boolean;
+    /**
+     * Refuse a native dismissal outright. The screen still reports the attempt, which is how a
+     * "discard your changes?" prompt is built.
+     */
+    readonly preventNativeDismiss?: boolean;
+    /** Heights the sheet snaps to, as fractions of the screen. */
+    readonly sheetAllowedDetents?: number[];
+    /** Index of the largest detent that leaves the screen behind undimmed; -1 dims at every one. */
+    readonly sheetLargestUndimmedDetent?: number;
+    readonly sheetGrabberVisible?: boolean;
+    /** Corner radius in points; -1 is the system default. */
+    readonly sheetCornerRadius?: number;
+    readonly sheetExpandsWhenScrolledToEdge?: boolean;
+    /** Which detent it opens at. */
+    readonly sheetInitialDetent?: number;
+    /** Android elevation. */
+    readonly sheetElevation?: number;
+    readonly sheetShouldOverflowTopInset?: boolean;
+    readonly statusBarHidden?: boolean;
+    readonly statusBarStyle?: string;
+    readonly statusBarColor?: string | number;
+    readonly statusBarAnimation?: string;
+    readonly statusBarTranslucent?: boolean;
+    readonly navigationBarColor?: string | number;
+    readonly navigationBarHidden?: boolean;
+    readonly navigationBarTranslucent?: boolean;
+    readonly homeIndicatorHidden?: boolean;
+    readonly screenOrientation?: string;
+}

package/dist/screen-presentation.js

@@ -0,0 +1,10 @@
+/**
+ * How a screen arrives, which is the part of mobile navigation a URL cannot express.
+ *
+ * Every field is a prop on `RNSScreen`, spelled exactly as the codegen spec spells it, so the
+ * outlet forwards the object key by key rather than translating it. Anything here rides in
+ * history state (ADR 0003), so going back to a screen restores the presentation it was opened
+ * with.
+ */
+export {};
+//# sourceMappingURL=screen-presentation.js.map

package/dist/screen-presentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen-presentation.js","sourceRoot":"","sources":["../src/screen-presentation.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG","sourcesContent":["/**\n * How a screen arrives, which is the part of mobile navigation a URL cannot express.\n *\n * Every field is a prop on `RNSScreen`, spelled exactly as the codegen spec spells it, so the\n * outlet forwards the object key by key rather than translating it. Anything here rides in\n * history state (ADR 0003), so going back to a screen restores the presentation it was opened\n * with.\n */\n\n/** How the screen is mounted on the stack. */\nexport type StackPresentation =\n  | 'push'\n  | 'modal'\n  | 'transparentModal'\n  | 'fullScreenModal'\n  | 'formSheet'\n  | 'pageSheet'\n  | 'containedModal'\n  | 'containedTransparentModal';\n\n/** The transition it animates in with. `default` is the platform's own. */\nexport type StackAnimation =\n  | 'default'\n  | 'flip'\n  | 'simple_push'\n  | 'none'\n  | 'fade'\n  | 'slide_from_right'\n  | 'slide_from_left'\n  | 'slide_from_bottom'\n  | 'fade_from_bottom'\n  | 'ios_from_right'\n  | 'ios_from_left';\n\n/** Which way the dismiss gesture runs. Vertical is what a sheet wants. */\nexport type SwipeDirection = 'vertical' | 'horizontal';\n\n/** Whether replacing a screen animates as a push or a pop. */\nexport type ReplaceAnimation = 'pop' | 'push';\n\n/** How far from the edge a dismiss gesture is recognised, in points. */\nexport interface GestureResponseDistance {\n  readonly start?: number;\n  readonly end?: number;\n  readonly top?: number;\n  readonly bottom?: number;\n}\n\nexport interface ScreenPresentation {\n  readonly stackPresentation?: StackPresentation;\n  readonly stackAnimation?: StackAnimation;\n  /** Milliseconds. Only read when `stackAnimation` is not `default`. */\n  readonly transitionDuration?: number;\n  readonly replaceAnimation?: ReplaceAnimation;\n\n  // --- the dismiss gesture -------------------------------------------------------------\n\n  /** Swipe back, or drag a sheet down. On by default. */\n  readonly gestureEnabled?: boolean;\n  /** iOS: allow the swipe to start anywhere on the screen, not just its edge. */\n  readonly fullScreenSwipeEnabled?: boolean;\n  readonly fullScreenSwipeShadowEnabled?: boolean;\n  readonly swipeDirection?: SwipeDirection;\n  readonly gestureResponseDistance?: GestureResponseDistance;\n  /** Run the screen's own animation while swiping rather than the platform's. */\n  readonly customAnimationOnSwipe?: boolean;\n  /** Dismiss the keyboard when the gesture starts. */\n  readonly hideKeyboardOnSwipe?: boolean;\n  /**\n   * Refuse a native dismissal outright. The screen still reports the attempt, which is how a\n   * \"discard your changes?\" prompt is built.\n   */\n  readonly preventNativeDismiss?: boolean;\n\n  // --- sheets (formSheet and pageSheet) --------------------------------------------------\n\n  /** Heights the sheet snaps to, as fractions of the screen. */\n  readonly sheetAllowedDetents?: number[];\n  /** Index of the largest detent that leaves the screen behind undimmed; -1 dims at every one. */\n  readonly sheetLargestUndimmedDetent?: number;\n  readonly sheetGrabberVisible?: boolean;\n  /** Corner radius in points; -1 is the system default. */\n  readonly sheetCornerRadius?: number;\n  readonly sheetExpandsWhenScrolledToEdge?: boolean;\n  /** Which detent it opens at. */\n  readonly sheetInitialDetent?: number;\n  /** Android elevation. */\n  readonly sheetElevation?: number;\n  readonly sheetShouldOverflowTopInset?: boolean;\n\n  // --- system chrome ---------------------------------------------------------------------\n\n  readonly statusBarHidden?: boolean;\n  readonly statusBarStyle?: string;\n  readonly statusBarColor?: string | number;\n  readonly statusBarAnimation?: string;\n  readonly statusBarTranslucent?: boolean;\n  readonly navigationBarColor?: string | number;\n  readonly navigationBarHidden?: boolean;\n  readonly navigationBarTranslucent?: boolean;\n  readonly homeIndicatorHidden?: boolean;\n  readonly screenOrientation?: string;\n}\n"]}

package/dist/screens.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Element name -> codegen'd Fabric component name, and the base style that component's React
+ * wrapper would have applied in JS. Element names are lowercase, because the compiler silently
+ * empties a template containing a capitalized one.
+ *
+ * The header's styles are `ScreenStackHeaderConfig.tsx`'s own, and the absolute positioning is
+ * load-bearing: without it the config view takes part in the screen's flex layout and every page
+ * renders a header's height too far down. `alignItems` is iOS-only there; it is harmless on
+ * Android, where the native side lays the bar out itself.
+ */
+export declare const SCREEN_VIEW_NAMES: Record<string, [viewName: string, defaults?: object]>;
+/**
+ * How visible a screen is. The native stack keeps every screen mounted and reads this rather
+ * than adding and removing views, which is what preserves a pushed-away screen's native state.
+ *
+ * `Screen.tsx` throws if this ever *decreases* while in a native stack, so a screen goes
+ * 0 -> 2 on push and is removed outright on pop rather than walked back down.
+ */
+export declare const ActivityState: {
+    /** Off screen, and a candidate for freezing. */
+    readonly Inactive: 0;
+    /** Mid transition: on screen but not the target. */
+    readonly Transitioning: 1;
+    /** The screen the user is on. */
+    readonly Active: 2;
+};
+export type ActivityStateValue = (typeof ActivityState)[keyof typeof ActivityState];
+/**
+ * Call once at startup, before the first navigation.
+ *
+ * The app must also have `react-native-screens` installed so the native side registers these
+ * components; this only teaches the engine the element-to-view-name mapping. A name the native
+ * side does not know renders as `UnimplementedNativeView`, not an error. None of its JavaScript
+ * is imported - Expo Go happens to bundle the native half, which is why the canary worked before
+ * it declared the dependency at all, and why an app that forgets it fails only once it ships.
+ */
+export declare function registerScreenComponents(): void;

package/dist/screens.js

@@ -0,0 +1,108 @@
+/**
+ * react-native-screens, driven directly.
+ *
+ * The native half of navigation already exists as codegen'd Fabric components. We register their
+ * names and drive them with `createNode`; their React components are unreachable (hooks) and
+ * `react-navigation` is not a dependency.
+ *
+ * No decorators here on purpose: tests import these at runtime, and Node's type stripping
+ * refuses decorators.
+ */
+import { registerHoist, registerViewName } from '@ng-native/fabric';
+/**
+ * Element name -> codegen'd Fabric component name, and the base style that component's React
+ * wrapper would have applied in JS. Element names are lowercase, because the compiler silently
+ * empties a template containing a capitalized one.
+ *
+ * The header's styles are `ScreenStackHeaderConfig.tsx`'s own, and the absolute positioning is
+ * load-bearing: without it the config view takes part in the screen's flex layout and every page
+ * renders a header's height too far down. `alignItems` is iOS-only there; it is harmless on
+ * Android, where the native side lays the bar out itself.
+ */
+export const SCREEN_VIEW_NAMES = {
+    // NativeStackOutlet's own host element is the stack.
+    'native-stack-outlet': ['RNSScreenStack'],
+    // Created by the outlet, one per activated route; nobody writes this in a template.
+    screen: ['RNSScreen'],
+    'native-header': [
+        'RNSScreenStackHeaderConfig',
+        {
+            position: 'absolute',
+            width: '100%',
+            flexDirection: 'row',
+            justifyContent: 'space-between',
+            alignItems: 'center',
+        },
+    ],
+    // Placed in a `<native-header-item type="searchBar">`, as react-native-screens places its own.
+    'native-search-bar': ['RNSSearchBar'],
+    'native-header-item': [
+        'RNSScreenStackHeaderSubview',
+        { flexDirection: 'row', alignItems: 'center', justifyContent: 'center' },
+    ],
+    // Insets by what the screen it is in says is covered, the tab bar included. See
+    // `tab-safe-area-view.ts`. The same name on both platforms.
+    'tab-safe-area-view': ['RNSSafeAreaView'],
+};
+/**
+ * The tabs half, which react-native-screens names per platform rather than sharing one component:
+ * `RNSTabsHostIOS` wraps a `UITabBarController`, `RNSTabsHostAndroid` a bottom navigation bar,
+ * and their props differ enough that the codegen specs are separate files.
+ *
+ * The fills are `TabsHost.ios.tsx`'s and `TabsScreen.ios.tsx`'s own. A tab screen is positioned
+ * absolutely because it is one of several occupying the same space, only one of which is visible.
+ */
+const TAB_VIEW_NAMES = {
+    'native-tabs-outlet': [
+        'RNSTabsHostIOS',
+        'RNSTabsHostAndroid',
+        { flex: 1, width: '100%', height: '100%' },
+    ],
+    'native-tab': [
+        'RNSTabsScreenIOS',
+        'RNSTabsScreenAndroid',
+        { position: 'absolute', flex: 1, width: '100%', height: '100%' },
+    ],
+};
+/**
+ * How visible a screen is. The native stack keeps every screen mounted and reads this rather
+ * than adding and removing views, which is what preserves a pushed-away screen's native state.
+ *
+ * `Screen.tsx` throws if this ever *decreases* while in a native stack, so a screen goes
+ * 0 -> 2 on push and is removed outright on pop rather than walked back down.
+ */
+export const ActivityState = {
+    /** Off screen, and a candidate for freezing. */
+    Inactive: 0,
+    /** Mid transition: on screen but not the target. */
+    Transitioning: 1,
+    /** The screen the user is on. */
+    Active: 2,
+};
+/**
+ * Call once at startup, before the first navigation.
+ *
+ * The app must also have `react-native-screens` installed so the native side registers these
+ * components; this only teaches the engine the element-to-view-name mapping. A name the native
+ * side does not know renders as `UnimplementedNativeView`, not an error. None of its JavaScript
+ * is imported - Expo Go happens to bundle the native half, which is why the canary worked before
+ * it declared the dependency at all, and why an app that forgets it fails only once it ships.
+ */
+export function registerScreenComponents() {
+    for (const [element, [viewName, defaults]] of Object.entries(SCREEN_VIEW_NAMES)) {
+        registerViewName(element, viewName, defaults);
+    }
+    // By platform, chosen when the view is looked up: this runs as the app's config is imported,
+    // before its `main.ts` has reported the platform.
+    // A window of its own on iOS; see `full-window-overlay.ts`. Its fill is the component's.
+    registerViewName('full-window-overlay', { ios: 'RNSFullWindowOverlay', android: 'RCTView' });
+    for (const [element, [ios, android, defaults]] of Object.entries(TAB_VIEW_NAMES)) {
+        registerViewName(element, { ios, android }, defaults);
+    }
+    // `findHeaderConfig` in `RNSScreen.mm` looks at the screen's direct children and no deeper, so
+    // a header a page wrote inside a `safe-area-view` or a component of its own commits beside it.
+    // Nothing in `RNSScreen.mm` updates the bar when its config is unmounted, so a header an `@if`
+    // takes away leaves a config behind that hides the bar, and one that comes back adopts it.
+    registerHoist('native-header', 'screen', { standIn: { hidden: true } });
+}
+//# sourceMappingURL=screens.js.map

package/dist/screens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screens.js","sourceRoot":"","sources":["../src/screens.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAEpE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAA0D;IACtF,qDAAqD;IACrD,qBAAqB,EAAE,CAAC,gBAAgB,CAAC;IACzC,oFAAoF;IACpF,MAAM,EAAE,CAAC,WAAW,CAAC;IACrB,eAAe,EAAE;QACf,4BAA4B;QAC5B;YACE,QAAQ,EAAE,UAAU;YACpB,KAAK,EAAE,MAAM;YACb,aAAa,EAAE,KAAK;YACpB,cAAc,EAAE,eAAe;YAC/B,UAAU,EAAE,QAAQ;SACrB;KACF;IACD,+FAA+F;IAC/F,mBAAmB,EAAE,CAAC,cAAc,CAAC;IACrC,oBAAoB,EAAE;QACpB,6BAA6B;QAC7B,EAAE,aAAa,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,EAAE,QAAQ,EAAE;KACzE;IACD,gFAAgF;IAChF,4DAA4D;IAC5D,oBAAoB,EAAE,CAAC,iBAAiB,CAAC;CAC1C,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,cAAc,GAAsE;IACxF,oBAAoB,EAAE;QACpB,gBAAgB;QAChB,oBAAoB;QACpB,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE;KAC3C;IACD,YAAY,EAAE;QACZ,kBAAkB;QAClB,sBAAsB;QACtB,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE;KACjE;CACF,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,gDAAgD;IAChD,QAAQ,EAAE,CAAC;IACX,oDAAoD;IACpD,aAAa,EAAE,CAAC;IAChB,iCAAiC;IACjC,MAAM,EAAE,CAAC;CACD,CAAC;AAIX;;;;;;;;GAQG;AACH,MAAM,UAAU,wBAAwB;IACtC,KAAK,MAAM,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE,CAAC;QAChF,gBAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,QAA+C,CAAC,CAAC;IACvF,CAAC;IACD,6FAA6F;IAC7F,kDAAkD;IAClD,yFAAyF;IACzF,gBAAgB,CAAC,qBAAqB,EAAE,EAAE,GAAG,EAAE,sBAAsB,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC;IAC7F,KAAK,MAAM,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;QACjF,gBAAgB,CAAC,OAAO,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,QAAmC,CAAC,CAAC;IACnF,CAAC;IACD,+FAA+F;IAC/F,+FAA+F;IAC/F,+FAA+F;IAC/F,2FAA2F;IAC3F,aAAa,CAAC,eAAe,EAAE,QAAQ,EAAE,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;AAC1E,CAAC","sourcesContent":["/**\n * react-native-screens, driven directly.\n *\n * The native half of navigation already exists as codegen'd Fabric components. We register their\n * names and drive them with `createNode`; their React components are unreachable (hooks) and\n * `react-navigation` is not a dependency.\n *\n * No decorators here on purpose: tests import these at runtime, and Node's type stripping\n * refuses decorators.\n */\nimport { registerHoist, registerViewName } from '@ng-native/fabric';\n\n/**\n * Element name -> codegen'd Fabric component name, and the base style that component's React\n * wrapper would have applied in JS. Element names are lowercase, because the compiler silently\n * empties a template containing a capitalized one.\n *\n * The header's styles are `ScreenStackHeaderConfig.tsx`'s own, and the absolute positioning is\n * load-bearing: without it the config view takes part in the screen's flex layout and every page\n * renders a header's height too far down. `alignItems` is iOS-only there; it is harmless on\n * Android, where the native side lays the bar out itself.\n */\nexport const SCREEN_VIEW_NAMES: Record<string, [viewName: string, defaults?: object]> = {\n  // NativeStackOutlet's own host element is the stack.\n  'native-stack-outlet': ['RNSScreenStack'],\n  // Created by the outlet, one per activated route; nobody writes this in a template.\n  screen: ['RNSScreen'],\n  'native-header': [\n    'RNSScreenStackHeaderConfig',\n    {\n      position: 'absolute',\n      width: '100%',\n      flexDirection: 'row',\n      justifyContent: 'space-between',\n      alignItems: 'center',\n    },\n  ],\n  // Placed in a `<native-header-item type=\"searchBar\">`, as react-native-screens places its own.\n  'native-search-bar': ['RNSSearchBar'],\n  'native-header-item': [\n    'RNSScreenStackHeaderSubview',\n    { flexDirection: 'row', alignItems: 'center', justifyContent: 'center' },\n  ],\n  // Insets by what the screen it is in says is covered, the tab bar included. See\n  // `tab-safe-area-view.ts`. The same name on both platforms.\n  'tab-safe-area-view': ['RNSSafeAreaView'],\n};\n\n/**\n * The tabs half, which react-native-screens names per platform rather than sharing one component:\n * `RNSTabsHostIOS` wraps a `UITabBarController`, `RNSTabsHostAndroid` a bottom navigation bar,\n * and their props differ enough that the codegen specs are separate files.\n *\n * The fills are `TabsHost.ios.tsx`'s and `TabsScreen.ios.tsx`'s own. A tab screen is positioned\n * absolutely because it is one of several occupying the same space, only one of which is visible.\n */\nconst TAB_VIEW_NAMES: Record<string, [ios: string, android: string, defaults?: object]> = {\n  'native-tabs-outlet': [\n    'RNSTabsHostIOS',\n    'RNSTabsHostAndroid',\n    { flex: 1, width: '100%', height: '100%' },\n  ],\n  'native-tab': [\n    'RNSTabsScreenIOS',\n    'RNSTabsScreenAndroid',\n    { position: 'absolute', flex: 1, width: '100%', height: '100%' },\n  ],\n};\n\n/**\n * How visible a screen is. The native stack keeps every screen mounted and reads this rather\n * than adding and removing views, which is what preserves a pushed-away screen's native state.\n *\n * `Screen.tsx` throws if this ever *decreases* while in a native stack, so a screen goes\n * 0 -> 2 on push and is removed outright on pop rather than walked back down.\n */\nexport const ActivityState = {\n  /** Off screen, and a candidate for freezing. */\n  Inactive: 0,\n  /** Mid transition: on screen but not the target. */\n  Transitioning: 1,\n  /** The screen the user is on. */\n  Active: 2,\n} as const;\n\nexport type ActivityStateValue = (typeof ActivityState)[keyof typeof ActivityState];\n\n/**\n * Call once at startup, before the first navigation.\n *\n * The app must also have `react-native-screens` installed so the native side registers these\n * components; this only teaches the engine the element-to-view-name mapping. A name the native\n * side does not know renders as `UnimplementedNativeView`, not an error. None of its JavaScript\n * is imported - Expo Go happens to bundle the native half, which is why the canary worked before\n * it declared the dependency at all, and why an app that forgets it fails only once it ships.\n */\nexport function registerScreenComponents(): void {\n  for (const [element, [viewName, defaults]] of Object.entries(SCREEN_VIEW_NAMES)) {\n    registerViewName(element, viewName, defaults as Record<string, unknown> | undefined);\n  }\n  // By platform, chosen when the view is looked up: this runs as the app's config is imported,\n  // before its `main.ts` has reported the platform.\n  // A window of its own on iOS; see `full-window-overlay.ts`. Its fill is the component's.\n  registerViewName('full-window-overlay', { ios: 'RNSFullWindowOverlay', android: 'RCTView' });\n  for (const [element, [ios, android, defaults]] of Object.entries(TAB_VIEW_NAMES)) {\n    registerViewName(element, { ios, android }, defaults as Record<string, unknown>);\n  }\n  // `findHeaderConfig` in `RNSScreen.mm` looks at the screen's direct children and no deeper, so\n  // a header a page wrote inside a `safe-area-view` or a component of its own commits beside it.\n  // Nothing in `RNSScreen.mm` updates the bar when its config is unmounted, so a header an `@if`\n  // takes away leaves a config behind that hides the bar, and one that comes back adopts it.\n  registerHoist('native-header', 'screen', { standIn: { hidden: true } });\n}\n"]}

package/dist/tab-routes.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Which route configs are tabs.
+ *
+ * The reuse strategy has to know, because a tab is detached whole rather than by its leaf, and it
+ * has nothing but an `ActivatedRouteSnapshot` to go on. Tabs are declared in a template now, so
+ * there is nothing on the route config to read: the outlet marks the config it matched each
+ * `<native-tab>` to, and the strategy asks here.
+ *
+ * A `WeakSet` rather than a flag written onto the config, so nothing an app can read changes, and
+ * so a lazily loaded config that goes away takes its entry with it.
+ */
+import type { Route } from '@angular/router';
+export declare function markTabRoute(route: Route): void;
+export declare function isTabRoute(route: Route | null | undefined): boolean;
+export declare function markScreenRoute(route: Route): void;
+export declare function isScreenRoute(route: Route | null | undefined): boolean;

package/dist/tab-routes.js

@@ -0,0 +1,24 @@
+const TAB_ROUTES = new WeakSet();
+export function markTabRoute(route) {
+    TAB_ROUTES.add(route);
+}
+export function isTabRoute(route) {
+    return route != null && TAB_ROUTES.has(route);
+}
+/**
+ * Route configs a native stack has put on screen.
+ *
+ * A stack's screen is usually a leaf, but not always: an app's root stack whose first screen is
+ * the tab bar shows a route with children. When something is presented over it - a sheet opened
+ * from inside a tab - that route has to be kept like any other screen below, or the router
+ * destroys the whole tab bar and the sheet has nothing to sit on. The stack outlet marks what it
+ * activates, so the strategy can tell a screen with children from a parent that is only layout.
+ */
+const SCREEN_ROUTES = new WeakSet();
+export function markScreenRoute(route) {
+    SCREEN_ROUTES.add(route);
+}
+export function isScreenRoute(route) {
+    return route != null && SCREEN_ROUTES.has(route);
+}
+//# sourceMappingURL=tab-routes.js.map

package/dist/tab-routes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-routes.js","sourceRoot":"","sources":["../src/tab-routes.ts"],"names":[],"mappings":"AAaA,MAAM,UAAU,GAAG,IAAI,OAAO,EAAS,CAAC;AAExC,MAAM,UAAU,YAAY,CAAC,KAAY;IACvC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,KAA+B;IACxD,OAAO,KAAK,IAAI,IAAI,IAAI,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AAChD,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,aAAa,GAAG,IAAI,OAAO,EAAS,CAAC;AAE3C,MAAM,UAAU,eAAe,CAAC,KAAY;IAC1C,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AAC3B,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,KAA+B;IAC3D,OAAO,KAAK,IAAI,IAAI,IAAI,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AACnD,CAAC","sourcesContent":["/**\n * Which route configs are tabs.\n *\n * The reuse strategy has to know, because a tab is detached whole rather than by its leaf, and it\n * has nothing but an `ActivatedRouteSnapshot` to go on. Tabs are declared in a template now, so\n * there is nothing on the route config to read: the outlet marks the config it matched each\n * `<native-tab>` to, and the strategy asks here.\n *\n * A `WeakSet` rather than a flag written onto the config, so nothing an app can read changes, and\n * so a lazily loaded config that goes away takes its entry with it.\n */\nimport type { Route } from '@angular/router';\n\nconst TAB_ROUTES = new WeakSet<Route>();\n\nexport function markTabRoute(route: Route): void {\n  TAB_ROUTES.add(route);\n}\n\nexport function isTabRoute(route: Route | null | undefined): boolean {\n  return route != null && TAB_ROUTES.has(route);\n}\n\n/**\n * Route configs a native stack has put on screen.\n *\n * A stack's screen is usually a leaf, but not always: an app's root stack whose first screen is\n * the tab bar shows a route with children. When something is presented over it - a sheet opened\n * from inside a tab - that route has to be kept like any other screen below, or the router\n * destroys the whole tab bar and the sheet has nothing to sit on. The stack outlet marks what it\n * activates, so the strategy can tell a screen with children from a parent that is only layout.\n */\nconst SCREEN_ROUTES = new WeakSet<Route>();\n\nexport function markScreenRoute(route: Route): void {\n  SCREEN_ROUTES.add(route);\n}\n\nexport function isScreenRoute(route: Route | null | undefined): boolean {\n  return route != null && SCREEN_ROUTES.has(route);\n}\n"]}

package/dist/tab-safe-area-view.d.ts

@@ -0,0 +1,15 @@
+import * as i0 from "@angular/core";
+/** The edges of the screen. */
+export type TabSafeAreaEdge = 'top' | 'right' | 'bottom' | 'left';
+export declare class TabSafeAreaView {
+    constructor();
+    /** Which edges to inset: usually `['bottom']`. Absent insets all four. */
+    readonly edges: import("@angular/core").InputSignal<readonly TabSafeAreaEdge[] | undefined>;
+    /**
+     * Native takes all four edges every time, as booleans; a partial record leaves the missing
+     * ones at whatever they were.
+     */
+    protected readonly resolvedEdges: import("@angular/core").Signal<Record<TabSafeAreaEdge, boolean>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TabSafeAreaView, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TabSafeAreaView, "tab-safe-area-view", never, { "edges": { "alias": "edges"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}

package/dist/tab-safe-area-view.js

@@ -0,0 +1,63 @@
+/**
+ * A view that keeps its content clear of the tab bar, as well as the home indicator and the
+ * system bars.
+ *
+ * ```html
+ * <view class="panel absolute bottom-0 left-0 right-0">
+ *   <tab-safe-area-view [edges]="['bottom']">…</tab-safe-area-view>
+ * </view>
+ * ```
+ *
+ * `<safe-area-view>` cannot do this. Its insets come from the nearest `<safe-area-provider>`,
+ * which sits at the root of the app, above the tab bar, and so measures only the window's own
+ * unsafe areas: inside a tab its bottom inset is the home indicator, and anything pinned to the
+ * bottom of a tab ends up under the bar. On iOS 26 the bar floats over the screen's content, and
+ * on Android the bottom navigation bar overlays it, so there is no layout that avoids it either.
+ *
+ * This is react-native-screens' own `RNSSafeAreaView`, which asks the screen it is in instead.
+ * On iOS that is the tab screen's `safeAreaInsets`, which UIKit extends by the tab bar - floating
+ * or not, and with the gap under a floating one - on top of the home indicator; a stack inside a
+ * tab passes the same insets down to its pages. On Android it is the larger of the bottom
+ * navigation bar's height and the system bars. Both follow the bar as it changes, rotates, or is
+ * hidden.
+ *
+ * **The insets are applied as margin, not padding.** Whatever is beneath the inset shows through
+ * it, so a panel whose background has to reach the bottom of the screen puts that background on
+ * a parent and this inside it, as above: the parent grows by the margin and paints behind the
+ * bar, and the content ends where the bar begins.
+ *
+ * It has to be inside a tab, or a page of a stack inside one. On iOS, with no screen above it, it
+ * insets by nothing.
+ */
+import { Component, ElementRef, computed, inject, input } from '@angular/core';
+import { ownHost } from "./own-host.js";
+import * as i0 from "@angular/core";
+const ALL = ['top', 'right', 'bottom', 'left'];
+export class TabSafeAreaView {
+    constructor() {
+        ownHost(inject(ElementRef).nativeElement, this.constructor);
+    }
+    /** Which edges to inset: usually `['bottom']`. Absent insets all four. */
+    edges = input(/* @ts-ignore */
+    ...(ngDevMode ? [undefined, { debugName: "edges" }] : /* istanbul ignore next */ []));
+    /**
+     * Native takes all four edges every time, as booleans; a partial record leaves the missing
+     * ones at whatever they were.
+     */
+    resolvedEdges = computed(() => {
+        const edges = this.edges() ?? ALL;
+        return Object.fromEntries(ALL.map((edge) => [edge, edges.includes(edge)]));
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "resolvedEdges" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: TabSafeAreaView, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "22.2.0", type: TabSafeAreaView, isStandalone: true, selector: "tab-safe-area-view", inputs: { edges: { classPropertyName: "edges", publicName: "edges", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "edges": "resolvedEdges()" } }, ngImport: i0, template: '<ng-content />', isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.2.0", ngImport: i0, type: TabSafeAreaView, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'tab-safe-area-view',
+                    template: '<ng-content />',
+                    host: { '[edges]': 'resolvedEdges()' },
+                }]
+        }], ctorParameters: () => [], propDecorators: { edges: [{ type: i0.Input, args: [{ isSignal: true, alias: "edges", required: false }] }] } });
+//# sourceMappingURL=tab-safe-area-view.js.map

package/dist/tab-safe-area-view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-safe-area-view.js","sourceRoot":"","sources":["../src/tab-safe-area-view.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE/E,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;;AAKxC,MAAM,GAAG,GAA+B,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;AAO3E,MAAM,OAAO,eAAe;IAC1B;QACE,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,aAA2B,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;IAC5E,CAAC;IAED,0EAA0E;IACjE,KAAK,GAAG,KAAK;yFAA8B,CAAC;IAErD;;;OAGG;IACgB,aAAa,GAAG,QAAQ,CAAC,GAAG,EAAE;QAC/C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,EAAE,IAAI,GAAG,CAAC;QAClC,OAAO,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAGxE,CAAC;IACJ,CAAC;sFAAC,CAAC;uGAlBQ,eAAe;2FAAf,eAAe,wQAHhB,gBAAgB;;2FAGf,eAAe;kBAL3B,SAAS;mBAAC;oBACT,QAAQ,EAAE,oBAAoB;oBAC9B,QAAQ,EAAE,gBAAgB;oBAC1B,IAAI,EAAE,EAAE,SAAS,EAAE,iBAAiB,EAAE;iBACvC","sourcesContent":["/**\n * A view that keeps its content clear of the tab bar, as well as the home indicator and the\n * system bars.\n *\n * ```html\n * <view class=\"panel absolute bottom-0 left-0 right-0\">\n *   <tab-safe-area-view [edges]=\"['bottom']\">…</tab-safe-area-view>\n * </view>\n * ```\n *\n * `<safe-area-view>` cannot do this. Its insets come from the nearest `<safe-area-provider>`,\n * which sits at the root of the app, above the tab bar, and so measures only the window's own\n * unsafe areas: inside a tab its bottom inset is the home indicator, and anything pinned to the\n * bottom of a tab ends up under the bar. On iOS 26 the bar floats over the screen's content, and\n * on Android the bottom navigation bar overlays it, so there is no layout that avoids it either.\n *\n * This is react-native-screens' own `RNSSafeAreaView`, which asks the screen it is in instead.\n * On iOS that is the tab screen's `safeAreaInsets`, which UIKit extends by the tab bar - floating\n * or not, and with the gap under a floating one - on top of the home indicator; a stack inside a\n * tab passes the same insets down to its pages. On Android it is the larger of the bottom\n * navigation bar's height and the system bars. Both follow the bar as it changes, rotates, or is\n * hidden.\n *\n * **The insets are applied as margin, not padding.** Whatever is beneath the inset shows through\n * it, so a panel whose background has to reach the bottom of the screen puts that background on\n * a parent and this inside it, as above: the parent grows by the margin and paints behind the\n * bar, and the content ends where the bar begins.\n *\n * It has to be inside a tab, or a page of a stack inside one. On iOS, with no screen above it, it\n * insets by nothing.\n */\nimport { Component, ElementRef, computed, inject, input } from '@angular/core';\nimport type { EngineNode } from '@ng-native/fabric';\nimport { ownHost } from './own-host.ts';\n\n/** The edges of the screen. */\nexport type TabSafeAreaEdge = 'top' | 'right' | 'bottom' | 'left';\n\nconst ALL: readonly TabSafeAreaEdge[] = ['top', 'right', 'bottom', 'left'];\n\n@Component({\n  selector: 'tab-safe-area-view',\n  template: '<ng-content />',\n  host: { '[edges]': 'resolvedEdges()' },\n})\nexport class TabSafeAreaView {\n  constructor() {\n    ownHost(inject(ElementRef).nativeElement as EngineNode, this.constructor);\n  }\n\n  /** Which edges to inset: usually `['bottom']`. Absent insets all four. */\n  readonly edges = input<readonly TabSafeAreaEdge[]>();\n\n  /**\n   * Native takes all four edges every time, as booleans; a partial record leaves the missing\n   * ones at whatever they were.\n   */\n  protected readonly resolvedEdges = computed(() => {\n    const edges = this.edges() ?? ALL;\n    return Object.fromEntries(ALL.map((edge) => [edge, edges.includes(edge)])) as Record<\n      TabSafeAreaEdge,\n      boolean\n    >;\n  });\n}\n"]}

package/dist/transforms.d.ts

@@ -0,0 +1,2 @@
+export declare function optionalBoolean(value: unknown): boolean | undefined;
+export declare function optionalNumber(value: unknown): number | undefined;

package/dist/transforms.js

@@ -0,0 +1,13 @@
+/**
+ * Input transforms that keep an unset prop unset, so a header that never mentions `largeTitle`
+ * sends nothing rather than `false`. The same pair exists in the components package; see
+ * `own-host.ts` for why it is copied rather than imported.
+ */
+import { booleanAttribute, numberAttribute } from '@angular/core';
+export function optionalBoolean(value) {
+    return value === undefined ? undefined : booleanAttribute(value);
+}
+export function optionalNumber(value) {
+    return value === undefined ? undefined : numberAttribute(value);
+}
+//# sourceMappingURL=transforms.js.map

package/dist/transforms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transforms.js","sourceRoot":"","sources":["../src/transforms.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAElE,MAAM,UAAU,eAAe,CAAC,KAAc;IAC5C,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;AACnE,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;AAClE,CAAC","sourcesContent":["/**\n * Input transforms that keep an unset prop unset, so a header that never mentions `largeTitle`\n * sends nothing rather than `false`. The same pair exists in the components package; see\n * `own-host.ts` for why it is copied rather than imported.\n */\nimport { booleanAttribute, numberAttribute } from '@angular/core';\n\nexport function optionalBoolean(value: unknown): boolean | undefined {\n  return value === undefined ? undefined : booleanAttribute(value);\n}\n\nexport function optionalNumber(value: unknown): number | undefined {\n  return value === undefined ? undefined : numberAttribute(value);\n}\n"]}