@octane-xplat/ui 0.5.0 → 0.7.0

package/dist/native/refresh.js

@@ -0,0 +1,177 @@
+import { dampenPull } from "./refresh-metrics.js";
+import { isIOS } from "@nativescript/core";
+//#region src/refresh.ts
+var PAN_ENDED = /* @__PURE__ */ new Set([0, 3]);
+var DOCK_ANIM_MS = 180;
+function makeInsets(top, left, bottom, right) {
+	const make = globalThis.UIEdgeInsetsMake;
+	if (make) return make(top, left, bottom, right);
+	return {
+		top,
+		left,
+		bottom,
+		right
+	};
+}
+/** Pan-driven pull-to-refresh over any NS scrollable (scrollview or
+*  listview). Two mechanics, one visual:
+*
+*  iOS — UIScrollView's own bounce supplies the content displacement
+*  (NS gesture delegates allow simultaneous recognition, so our pan on
+*  the scroller observes alongside the scroll pan). The handler reads
+*  `contentOffset` for the live gap and docks with
+*  `contentInset.top += H` — the exact mechanics UIRefreshControl uses.
+*
+*  Android — there is no overscroll; the scroller box itself is
+*  translated inside the clipping wrapper while the damped drag
+*  accumulates. Docking holds the translate at H. Edge glow is disabled
+*  (OVER_SCROLL_NEVER) so no OS chrome leaks into the pixels.
+*
+*  Releasing past `threshold` fires `onRefresh` once per pull and holds
+*  the docked gap; the controlled `refreshing` prop keeps it docked.
+*  A short grace window collapses the dock if `refreshing` never comes —
+*  props land a render after `onRefresh` fires. */
+function createPullToRefresh(host) {
+	const { scroller, indicator, isAtTop, cfg } = host;
+	if (!scroller || !indicator) return {
+		sync: () => {},
+		detach: () => {}
+	};
+	let docked = false;
+	let pullAcc = 0;
+	let prevDy = 0;
+	let touching = false;
+	let grace = null;
+	let baseInsetTop = null;
+	let lastTy = NaN;
+	const threshold = () => cfg.current.threshold ?? 64;
+	/** Resting gap: the strip stays docked while the gesture docked it OR
+	*  the controlled `refreshing` prop holds it open. */
+	const held = () => docked || !!cfg.current.refreshing;
+	const iosOverscroll = () => {
+		const sv = scroller.ios;
+		if (!sv?.contentOffset) return 0;
+		return Math.max(0, -(sv.contentOffset.y + sv.contentInset.top));
+	};
+	const applyReveal = (reveal) => {
+		const ty = reveal - 64;
+		if (ty !== lastTy) {
+			lastTy = ty;
+			indicator.translateY = ty;
+			if (!isIOS) scroller.translateY = reveal;
+		}
+	};
+	const settle = (reveal) => {
+		lastTy = NaN;
+		if (isIOS) animateTo(indicator, reveal - 64);
+		else {
+			animateTo(scroller, reveal);
+			animateTo(indicator, reveal - 64);
+		}
+	};
+	const setInset = (on) => {
+		const sv = scroller.ios;
+		if (!sv?.contentInset) return;
+		if (on && baseInsetTop == null) baseInsetTop = sv.contentInset.top;
+		const next = (baseInsetTop ?? 0) + (on ? 64 : 0);
+		if (Math.abs(sv.contentInset.top - next) < .5) return;
+		const apply = () => {
+			sv.contentInset = makeInsets(next, sv.contentInset.left, sv.contentInset.bottom, sv.contentInset.right);
+		};
+		const UIView = globalThis.UIView;
+		if (UIView?.animateWithDurationAnimations) UIView.animateWithDurationAnimations(DOCK_ANIM_MS / 1e3, apply);
+		else apply();
+	};
+	function animateTo(view, y) {
+		view?.animate?.({
+			translate: {
+				x: 0,
+				y
+			},
+			duration: DOCK_ANIM_MS
+		});
+	}
+	const dock = () => {
+		docked = true;
+		pullAcc = 0;
+		if (isIOS) setInset(true);
+		settle(64);
+	};
+	const collapse = () => {
+		docked = false;
+		pullAcc = 0;
+		if (isIOS) setInset(false);
+		settle(0);
+	};
+	/** `extra` is pull beyond the held baseline — a release only fires
+	*  `onRefresh` when the user actually pulled (a resting release inside
+	*  the dock re-fires nothing). */
+	const release = (extra) => {
+		const reveal = extra + (held() ? 64 : 0);
+		if (extra > 0 && reveal >= threshold()) {
+			cfg.current.onRefresh?.();
+			dock();
+			clearTimeout(grace);
+			grace = setTimeout(() => {
+				if (!cfg.current.refreshing) collapse();
+			}, 350);
+		} else if (held()) {
+			docked = true;
+			pullAcc = 0;
+			if (isIOS) setInset(true);
+			settle(64);
+		} else collapse();
+	};
+	const onPan = (e) => {
+		if (isIOS) {
+			const extra = iosOverscroll();
+			if (PAN_ENDED.has(e.state)) {
+				touching = false;
+				release(extra);
+			} else {
+				touching = true;
+				applyReveal(extra + (held() ? 64 : 0));
+			}
+			return;
+		}
+		if (e.state === 1) {
+			touching = true;
+			prevDy = e.deltaY;
+			pullAcc = 0;
+			return;
+		}
+		if (PAN_ENDED.has(e.state)) {
+			touching = false;
+			release(pullAcc);
+			pullAcc = 0;
+			return;
+		}
+		const inc = e.deltaY - prevDy;
+		prevDy = e.deltaY;
+		if (!isAtTop()) return;
+		pullAcc = Math.max(0, pullAcc + dampenPull(inc));
+		applyReveal(pullAcc + (held() ? 64 : 0));
+	};
+	scroller.on("pan", onPan);
+	if (!isIOS) scroller.android?.setOverScrollMode?.(2);
+	return {
+		sync: () => {
+			if (cfg.current.refreshing) {
+				clearTimeout(grace);
+				if (!docked && !touching) dock();
+			} else if (docked && !touching) collapse();
+		},
+		detach: () => {
+			clearTimeout(grace);
+			scroller.off("pan", onPan);
+			if (docked) {
+				docked = false;
+				if (isIOS) setInset(false);
+				else scroller.translateY = 0;
+				indicator.translateY = -64;
+			}
+		}
+	};
+}
+//#endregion
+export { createPullToRefresh };

package/dist/native/{ui34.js → root-layout.mobile.js}

@@ -1,5 +1,5 @@
 import { RootLayout, getRootLayout } from "@nativescript/core";
-//#region src/root-layout.native.ts
+//#region src/root-layout.mobile.ts
 var registry = [];
 /** Called by the Screen leaf's <rootlayout> onLoaded/onUnloaded. */
 function registerRootLayout(rl) {
@@ -17,7 +17,7 @@ function topRootLayout() {
 	return registry[registry.length - 1] ?? getRootLayout();
 }
 /** Resolve the RootLayout enclosing `view` by walking the native parent
-*  chain — the screen shell is a RootLayout (Screen.native), so the first
+*  chain — the screen shell is a RootLayout (Screen), so the first
 *  RootLayout ancestor IS the current page's overlay host. Falls back to
 *  the top registry entry when the component renders outside any Screen. */
 function rootLayoutFor(view) {
@@ -26,13 +26,18 @@ function rootLayoutFor(view) {
 }
 /** Search every registered rootlayout for a view by id — overlays/sheets/
 *  toasts land on different rootlayouts depending on which screen's shell
-*  mounted last. */
+*  mounted last. Unloaded subtrees are skipped: a covered page unloads its
+*  views (NativeScript detaches their native recognizers while the JS views
+*  stay parented), so an unloaded match is a dead twin that can swallow
+*  interaction probes — the live view either doesn't exist here yet or sits
+*  under a loaded branch. */
 function findInRootLayouts(id) {
 	const walk = (view) => {
 		if (!view) return null;
 		if (view.id === id) return view;
 		let hit = null;
 		view.eachChildView?.((c) => {
+			if (c?.isLoaded === false) return true;
 			const found = walk(c);
 			if (found) {
 				hit = found;

package/dist/native/route-host.mobile.js

@@ -0,0 +1,2 @@
+import { RouteHost, screenParamsFor } from "./RouteHost.mobile.tsrx.js";
+export { RouteHost, screenParamsFor };

package/dist/native/{ui19.js → route-table.js}

@@ -1,13 +1,12 @@
 //#region src/route-table.ts
 var EXT = /\.(tsrx|tsx|ts|mts|cts|js|mjs|cjs|jsx)$/;
-var SUFFIX = /\.(web|native|ios|android)$/;
+var SUFFIX = /\.(web|mobile|ios|android|macos|windows|linux)$/;
 var PARAM = /^\[(.+)\]$/;
 var PRESENT = /\+(modal|fade|push)$/;
 /** Internal error carrier used by the public `redirect()` helper. Keeping
 * this in the shared route table gives both platform leaves the same guard
 * behavior without importing a platform runtime. */
 var RouteRedirect = class extends Error {
-	route;
 	constructor(route) {
 		super("route redirect");
 		this.route = route;
@@ -102,7 +101,109 @@ function deriveRouteManifest(files, prefer, dir = "app") {
 		routes.push(meta);
 		if (meta.loader) loaders[meta.name] = meta.loader;
 	}
-	routes.sort((a, b) => b.segments.reduce((n, s) => n + (s.startsWith(":") ? 1 : 2), 0) - a.segments.reduce((n, s) => n + (s.startsWith(":") ? 1 : 2), 0) || a.name.localeCompare(b.name));
+	routes.sort(bySpecificity);
+	return {
+		screens,
+		routes,
+		layouts,
+		loaders
+	};
+}
+/** Match-order comparator: static segments (2) outrank params (1), ties
+*  break alphabetically so ordering is total and stable across merges. */
+function bySpecificity(a, b) {
+	return b.segments.reduce((n, s) => n + (s.startsWith(":") ? 1 : 2), 0) - a.segments.reduce((n, s) => n + (s.startsWith(":") ? 1 : 2), 0) || a.name.localeCompare(b.name);
+}
+/** Normalize a programmatic `path` into manifest segments using the
+*  route-dir vocabulary: `'docs/[slug]'` and `'docs/:slug'` are the same
+*  pattern, a trailing `index` drops, `''`/`'index'` name the root route. */
+function specSegments(path) {
+	const segs = path.split("/").filter(Boolean).map((s) => {
+		const p = PARAM.exec(s);
+		return p ? ":" + p[1] : s;
+	});
+	if (segs[segs.length - 1] === "index") segs.pop();
+	return segs;
+}
+var mergeWarned = /* @__PURE__ */ new Set();
+/** Build a manifest from app data rather than the route dir — the
+*  programmatic half of the route contract (host frameworks derive specs
+*  from their own sources, e.g. `readdirSync` over a content dir). Each
+*  spec's `path` uses the route-dir vocabulary; `layouts` keys are path
+*  prefixes playing the `_layout` role. Same-name duplicates inside the
+*  set keep the later entry with a warn, matching merge precedence. */
+function defineRoutes(input) {
+	const set = Array.isArray(input) ? { routes: input } : input;
+	const specs = set.routes;
+	const extra = set.layouts;
+	const screens = {};
+	const layouts = {};
+	const metas = /* @__PURE__ */ new Map();
+	const warned = /* @__PURE__ */ new Set();
+	for (const [key, layout] of Object.entries(extra ?? {})) {
+		const dir = key.replace(/^\/+|\/+$/g, "");
+		if (dir !== key) console.warn(`[octane-xplat] layout key '${key}' normalized to '${dir}'`);
+		layouts[dir] = layout;
+	}
+	for (const spec of specs) {
+		const segments = specSegments(spec.path);
+		const name = segments.join("/") || "index";
+		const meta = {
+			name,
+			segments,
+			params: segments.filter((s) => s.startsWith(":")).map((s) => s.slice(1)),
+			file: spec.source ?? `programmatic:${spec.path}`,
+			presentation: spec.presentation
+		};
+		if (spec.loader) meta.loader = spec.loader;
+		if (spec.beforeLoad) meta.beforeLoad = spec.beforeLoad;
+		if (spec.head) meta.head = spec.head;
+		if (metas.has(name) && !warned.has(name)) {
+			warned.add(name);
+			console.warn(`[octane-xplat] route '${name}' is defined twice — keeping the later spec (${meta.file})`);
+		}
+		if (typeof spec.screen !== "function") {
+			console.warn(`[octane-xplat] route '${name}' has no component — 'screen' must be a component function, not a module`);
+			continue;
+		}
+		metas.set(name, meta);
+		screens[name] = spec.screen;
+	}
+	const routes = [...metas.values()].sort(bySpecificity);
+	const loaders = {};
+	for (const meta of routes) if (meta.loader) loaders[meta.name] = meta.loader;
+	return {
+		screens,
+		routes,
+		layouts,
+		loaders
+	};
+}
+/** Compose manifests into one — file-derived base plus any number of
+*  programmatic sets (`registerRoutes(mergeRouteManifests(fromDir, dynamic))`).
+*  Registration order is precedence: on a same-name collision the later
+*  manifest's route wins and the loser's loader/beforeLoad/head go with it —
+*  a warn fires once per colliding name. `layouts` merge key-wise the same
+*  way. `matchRoute` order is rebuilt by specificity after the merge. */
+function mergeRouteManifests(...manifests) {
+	const screens = {};
+	const layouts = {};
+	const winners = /* @__PURE__ */ new Map();
+	for (const m of manifests) {
+		Object.assign(layouts, m.layouts);
+		Object.assign(screens, m.screens);
+		for (const meta of m.routes) {
+			const prev = winners.get(meta.name);
+			if (prev && !mergeWarned.has(meta.name)) {
+				mergeWarned.add(meta.name);
+				console.warn(`[octane-xplat] route '${meta.name}' is defined by both ${prev.file} and ${meta.file} — keeping ${meta.file}`);
+			}
+			winners.set(meta.name, meta);
+		}
+	}
+	const routes = [...winners.values()].sort(bySpecificity);
+	const loaders = {};
+	for (const meta of routes) if (meta.loader) loaders[meta.name] = meta.loader;
 	return {
 		screens,
 		routes,
@@ -246,4 +347,4 @@ function layoutChain(layouts, name) {
 	return chain;
 }
 //#endregion
-export { RouteRedirect, buildRoutePath, deriveRouteManifest, layoutChain, linkPath, matchRoute, matchUrl, parseQueryString };
+export { RouteRedirect, buildRoutePath, defineRoutes, deriveRouteManifest, layoutChain, linkPath, matchRoute, matchUrl, mergeRouteManifests, parseQueryString };

package/dist/native/{ui21.js → route.js}

@@ -1,10 +1,12 @@
-import { getStack, onStackRegistered, stackEntries } from "./ui18.js";
-import { RouteRedirect, buildRoutePath, layoutChain, linkPath, matchUrl } from "./ui19.js";
-import { RouteHost } from "./ui20.js";
+import { getStack, onStackRegistered, stackEntries } from "./stacks.js";
+import { RouteRedirect, buildRoutePath, layoutChain, linkPath, matchUrl, mergeRouteManifests } from "./route-table.js";
+import { RouteHost } from "./RouteHost.mobile.tsrx.js";
+import "./route-host.mobile.js";
+import { modalPresenter } from "./modal-presenter.mobile.js";
 import { createNativeScriptRoot } from "@nativescript-community/octane";
 import { Application, GridLayout, Page } from "@nativescript/core";
-import { hookSlots as hookSlots$1, useSyncExternalStore as useSyncExternalStore$1 } from "octane";
-//#region src/route.native.ts
+import { hookSlots as hookSlots$1, useSyncExternalStore as useSyncExternalStore$1 } from "octane/universal/native";
+//#region src/route.ts
 /** Native twin of route.web — same Route contract over Frame/Page stacks.
 *  `pushRoute` resolves a stack ('root' = the app's root Frame — an
 *  explicit registerStack('root') or, by default, the Frame returned by
@@ -21,10 +23,24 @@ import { hookSlots as hookSlots$1, useSyncExternalStore as useSyncExternalStore$
 *  - named stacks register via `TabSpec.stack` or `registerStack`.
 *  Every drop path warns loudly — silent no-ops are how apps ship a
 *  default route on native while working fine on web. */
+var baseManifest = {
+	screens: {},
+	routes: [],
+	layouts: {}
+};
+var dynamicManifests = [];
 var screens = {};
 var routes = [];
 var routeLayouts = {};
 var routeLoaders = {};
+function rebuildRegistry() {
+	const merged = mergeRouteManifests(baseManifest, ...dynamicManifests);
+	screens = merged.screens;
+	routes = merged.routes;
+	routeLayouts = merged.layouts;
+	routeLoaders = merged.loaders ?? {};
+	emit();
+}
 /** Register the app's name → screen table (call once, from the shared
 *  routes module). Native `pushRoute` resolves `route.name` through it;
 *  on web the table feeds `screenFor` for outlets without a
@@ -32,15 +48,28 @@ var routeLoaders = {};
 *  for parity — the web leaf matches URLs through it; native navigation
 *  is name+params and only needs the table. */
 function registerScreens(table, manifest) {
-	screens = table;
-	routes = manifest ?? [];
+	baseManifest = {
+		...baseManifest,
+		screens: table,
+		routes: manifest ?? []
+	};
+	rebuildRegistry();
+	ensureBackWired();
 }
 /** One-call registration for route-dir apps — screens + URL patterns +
 *  layouts all come from deriveRouteManifest. */
 function registerRoutes(manifest) {
-	registerScreens(manifest.screens, manifest.routes);
-	routeLayouts = manifest.layouts ?? {};
-	routeLoaders = manifest.loaders ?? {};
+	baseManifest = manifest;
+	rebuildRegistry();
+	ensureBackWired();
+}
+/** Layer a programmatic manifest (from `defineRoutes`) over the registered
+*  routes — same-name entries win over the base with a warn, so a host
+*  framework can override a file route deliberately. Registered layers
+*  survive later registerRoutes re-registration (e.g. routes.gen HMR). */
+function addRoutes(manifest) {
+	dynamicManifests.push(manifest);
+	rebuildRegistry();
 }
 function layoutsForRoute(name) {
 	return layoutChain(routeLayouts, name);
@@ -69,20 +98,104 @@ function warnOnce(key, msg) {
 function trackFrame(frame) {
 	if (tracked.has(frame)) return;
 	tracked.add(frame);
-	frame.on("navigatedTo", emit);
+	frame.on("navigatedTo", () => {
+		const page = frame.currentPage;
+		if (page && page.isLoaded === false) page.callLoaded?.();
+		emit();
+	});
 }
 function resolveStack(stack) {
 	const frame = getStack(stack);
 	if (frame) trackFrame(frame);
 	return frame;
 }
+/** TabViewItem-hosted frames report isLoaded=false after tab-selection
+*  lifecycle churn; without re-arming, the nav queue defers pushes AND pops
+*  forever (iOS strand of #11444 — goBack also gates on isLoaded via
+*  _processNextNavigationEntry). callLoaded is idempotent once the flag
+*  holds, so run it before every navigate/goBack on a registered frame. */
+function rearmFrameLoaded(frame) {
+	if (!frame.isLoaded) frame.callLoaded?.();
+}
 onStackRegistered((_name, frame) => {
 	trackFrame(frame);
+	ensureBackWired();
 	emit();
 });
 var modalHosts = [];
 var swapTabRoutes = /* @__PURE__ */ new Map();
 var swapTabOrder = [];
+/** App-supplied interceptors, consulted most-recent-first before the
+*  framework's default stack pop. Return true to consume the press. */
+var backInterceptors = [];
+var backWired = false;
+/** Register an Android hardware-back interceptor. Interceptors run
+*  most-recent-first (so the topmost mounted screen wins) before the
+*  framework's default pop; returning true consumes the press. Returns
+*  an unsubscribe. iOS has no hardware back — interceptors simply never
+*  fire there. */
+function addBackInterceptor(fn) {
+	backInterceptors.push(fn);
+	return () => {
+		const i = backInterceptors.indexOf(fn);
+		if (i !== -1) backInterceptors.splice(i, 1);
+	};
+}
+/** Framework-owned default: the newest open modal, then the root stack's
+*  pushed page (a root push covers the shell), then the most recently
+*  used swap-pane stack, then any registered named stack that can pop.
+*  Returns false at the base of everything — the press falls through to
+*  the system (app exit). NS's own default pops `Frame.topmost()` — the
+*  innermost frame — which is wrong once nested stacks exist, so this
+*  ordering is deliberate. */
+function defaultBackPress() {
+	const modal = modalHosts[modalHosts.length - 1];
+	if (modal) {
+		popRoute(modal.route.stack);
+		return true;
+	}
+	if (canGoBack("root")) {
+		popRoute("root");
+		return true;
+	}
+	for (const name of [...swapTabOrder].reverse()) if (canGoBack(name)) {
+		popRoute(name);
+		return true;
+	}
+	for (const [name] of [...stackEntries()].reverse()) {
+		if (name === "root") continue;
+		if (canGoBack(name)) {
+			popRoute(name);
+			return true;
+		}
+	}
+	return false;
+}
+/** Install the Android activityBackPressed listener once. Called from
+*  registerScreens and from stack registration, so any app shape that
+*  can navigate (screens or stacks registered) is covered without a
+*  module-import-time read of Application.android. The subscription is
+*  singletoned on the Application object: under vite HMR this module's
+*  state resets but the listener must not duplicate — the press handler
+*  delegates through a slot so a reloaded module graph swaps in its fresh
+*  closures instead of double-popping. */
+function ensureBackWired() {
+	if (backWired || !Application.android) return;
+	backWired = true;
+	const app = Application;
+	app.__octaneXplatBackPress = (e) => {
+		for (let i = backInterceptors.length - 1; i >= 0; i--) if (backInterceptors[i]()) {
+			e.cancel = true;
+			return;
+		}
+		if (defaultBackPress()) e.cancel = true;
+	};
+	if (app.__octaneXplatBackWired) return;
+	app.__octaneXplatBackWired = true;
+	Application.android.on(Application.AndroidApplication.activityBackPressedEvent, (e) => {
+		app.__octaneXplatBackPress?.(e);
+	});
+}
 function presentationFor(name) {
 	return routes.find((m) => m.name === name)?.presentation;
 }
@@ -164,7 +277,7 @@ function commitRoute(r) {
 		else warnOnce("modal:" + r.name, `modal route '${r.name}' dropped — no loaded presenter Frame.`);
 		return;
 	}
-	if (Application.android && r.stack !== "root") {
+	if (r.stack !== "root" && (Application.android || !resolveStack(r.stack))) {
 		const entries = swapTabRoutes.get(r.stack) ?? [];
 		entries.push({
 			...r,
@@ -185,7 +298,7 @@ function commitRoute(r) {
 		warnOnce("stack:" + r.stack, r.stack === "root" ? `pushRoute('${r.name}') dropped — no root Frame. Boot with a Frame as the app root (Application.run create() returning new Frame) or call registerStack('root', frame).` : `pushRoute('${r.name}') dropped — no stack '${r.stack}' is registered. Named stacks come from TabSpec.stack on <Tabs> or registerStack('${r.stack}', frame).`);
 		return;
 	}
-	if (!frame.isLoaded) frame.callLoaded?.();
+	rearmFrameLoaded(frame);
 	const props = {
 		...r.params,
 		...contextFor(r),
@@ -236,7 +349,13 @@ function pushModal(frame, r, C) {
 		modalHosts.splice(i, 1);
 		emit();
 	};
-	const presenter = frame.currentPage ?? frame;
+	const presenter = modalPresenter(frame);
+	if (!presenter) {
+		warnOnce("modal-presenter:" + r.name, `modal route '${r.name}' dropped — no live presenter. The stack's currentPage is mid-navigation; retry once the transition settles.`);
+		entry.dismiss();
+		root.unmount?.();
+		return;
+	}
 	try {
 		modalHosts.push(entry);
 		const params = {
@@ -276,7 +395,7 @@ function popRoute(stack = "root") {
 		modal.host.closeModal?.();
 		return;
 	}
-	if (Application.android && stack !== "root") {
+	if (stack !== "root" && (Application.android || !resolveStack(stack))) {
 		const entries = swapTabRoutes.get(stack);
 		if (entries?.length) {
 			entries.pop();
@@ -294,11 +413,12 @@ function popRoute(stack = "root") {
 		warnOnce("pop:" + stack, `popRoute('${stack}') dropped — no such stack is registered.`);
 		return;
 	}
+	rearmFrameLoaded(frame);
 	frame.goBack();
 }
 /** Route stamped on a stack's current page, or null at its base page. */
 function routeFor(stack) {
-	if (Application.android && stack !== "root") {
+	if (stack !== "root" && (Application.android || !resolveStack(stack))) {
 		const entries = swapTabRoutes.get(stack);
 		if (entries?.length) return entries[entries.length - 1];
 	}
@@ -325,7 +445,7 @@ function currentRoute() {
 }
 /** Named stacks containing routes, including Android's swap-pane stacks. */
 function routeStacks() {
-	return Application.android ? [.../* @__PURE__ */ new Set([...swapTabOrder, ...[...stackEntries()].map(([name]) => name)])] : [...stackEntries()].map(([name]) => name);
+	return [.../* @__PURE__ */ new Set([...swapTabOrder, ...[...stackEntries()].map(([name]) => name)])];
 }
 /** The modal route currently open, if any — parity with the web leaf. */
 function currentModalRoute() {
@@ -359,8 +479,8 @@ function useRoute(stack) {
 * entry) that can be popped. The modal root is also a back affordance. */
 function canGoBack(stack = "root") {
 	if (modalHosts[modalHosts.length - 1]?.route.stack === stack) return true;
-	if (Application.android && stack !== "root") return !!swapTabRoutes.get(stack)?.length;
-	return !!resolveStack(stack)?.canGoBack?.();
+	if (stack !== "root" && (Application.android || !resolveStack(stack))) return !!swapTabRoutes.get(stack)?.length;
+	return !!resolveStack(stack)?.backStack?.length;
 }
 function useCanGoBack(stack = "root") {
 	return useSyncExternalStore$1((cb) => {
@@ -380,4 +500,4 @@ var _h$0 = /* @__PURE__ */ Symbol(_hs$);
 var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
 var _h$2 = /* @__PURE__ */ Symbol(_hs$ + 2);
 //#endregion
-export { canGoBack, currentModalRoute, currentRoute, hrefFor, layoutsForRoute, popRoute, pushDeepLink, pushRoute, redirect, registerRoutes, registerScreens, routeFor, routeStacks, screenFor, useCanGoBack, useModalRoute, useRoute };
+export { addBackInterceptor, addRoutes, canGoBack, currentModalRoute, currentRoute, hrefFor, layoutsForRoute, popRoute, pushDeepLink, pushRoute, redirect, registerRoutes, registerScreens, routeFor, routeStacks, screenFor, useCanGoBack, useModalRoute, useRoute };

package/dist/native/safeAreaInsets.tsrx.js

@@ -0,0 +1,67 @@
+import { hookSlots, useEffect, useState } from "@nativescript-community/octane";
+import { Application, Screen } from "@nativescript/core";
+//#region src/safeAreaInsets.tsrx
+var _hs$ = /* @__PURE__ */ hookSlots(2);
+var _h$0 = /* @__PURE__ */ Symbol(_hs$);
+var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
+function androidActivity() {
+	return Application.android?.foregroundActivity ?? Application.android?.startActivity;
+}
+function readAndroidInsets() {
+	const insets = (androidActivity()?.getWindow?.()?.getDecorView?.())?.getRootWindowInsets?.();
+	if (!insets) return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	};
+	const scale = Screen.mainScreen.scale || 1;
+	if (android.os.Build.VERSION.SDK_INT >= 30) {
+		const systemBars = android.view.WindowInsets.Type.systemBars() | android.view.WindowInsets.Type.displayCutout();
+		const i = insets.getInsets(systemBars);
+		return {
+			top: i.top / scale,
+			right: i.right / scale,
+			bottom: i.bottom / scale,
+			left: i.left / scale
+		};
+	}
+	return {
+		top: insets.getSystemWindowInsetTop() / scale,
+		right: insets.getSystemWindowInsetRight() / scale,
+		bottom: insets.getSystemWindowInsetBottom() / scale,
+		left: insets.getSystemWindowInsetLeft() / scale
+	};
+}
+function measure() {
+	const insets = (Application.ios?.rootController?.view)?.safeAreaInsets;
+	if (insets) return {
+		top: insets.top,
+		right: insets.right,
+		bottom: insets.bottom,
+		left: insets.left
+	};
+	if (Application.android) return readAndroidInsets();
+	return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	};
+}
+function useSafeAreaInsets() {
+	const [insets, setInsets] = useState(measure, _h$0);
+	useEffect(() => {
+		const update = () => setInsets(measure());
+		Application.on(Application.orientationChangedEvent, update);
+		Application.on(Application.resumeEvent, update);
+		update();
+		return () => {
+			Application.off(Application.orientationChangedEvent, update);
+			Application.off(Application.resumeEvent, update);
+		};
+	}, [], _h$1);
+	return insets;
+}
+//#endregion
+export { useSafeAreaInsets };