@octane-xplat/ui 0.3.0 → 0.4.0

package/dist/native/ui18.js

@@ -1,54 +1,35 @@
-import { createNativeScriptRoot, defineUniversalComponent, hookSlots, universalPlan, universalValue, useEffect, useRef } from "@nativescript-community/octane";
-import { Frame, GridLayout } from "@nativescript/core";
-//#region src/Modal.native.tsrx
-var _hs$ = /* @__PURE__ */ hookSlots(2);
-var _h$0 = /* @__PURE__ */ Symbol(_hs$);
-var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
-var __octaneUniversalPlan0 = universalPlan("nativescript", {
-	"kind": "range",
-	"children": [{
-		"kind": "slot",
-		"slot": 0
-	}]
-});
-var __octaneUniversalPlan1 = universalPlan("nativescript", {
-	"kind": "range",
-	"children": []
-});
-var Panel = defineUniversalComponent("nativescript", function Panel(props) {
-	return universalValue(__octaneUniversalPlan0, [props.children]);
-}, { "module": "@nativescript-community/octane" });
-var Modal = defineUniversalComponent("nativescript", function Modal(props) {
-	const shown = useRef(null, _h$0);
-	useEffect(() => {
-		if (props.open && !shown.current) {
-			const presenter = Frame.topmost()?.currentPage ?? Frame.topmost();
-			if (!presenter) return;
-			const host = new GridLayout();
-			const root = createNativeScriptRoot(host);
-			shown.current = {
-				host,
-				root
-			};
-			if (props.component) root.render(props.component, props.params ?? {});
-			else root.render(Panel, { children: props.children });
-			const fullscreen = props.presentation ? props.presentation === "fullscreen" : props.fullscreen ?? true;
-			presenter.showModal(host, {
-				context: {},
-				closeCallback: (result) => {
-					shown.current = null;
-					props.onClose?.(result);
-				},
-				fullscreen,
-				animated: true
-			});
-		} else if (!props.open && shown.current) {
-			const { host } = shown.current;
-			shown.current = null;
-			host.closeModal();
-		}
-	}, [props.open], _h$1);
-	return universalValue(__octaneUniversalPlan1, []);
-}, { "module": "@nativescript-community/octane" });
+import { Application, Frame } from "@nativescript/core";
+//#region src/stacks.native.ts
+/** Named parallel stacks. A shell (Tabs with `stack` on a spec, the app
+*  entry's root frame) registers its Frame here; `pushRoute` resolves the
+*  target by name. Native-only concept — on web, parallel stacks map to
+*  nested routes (one linear URL stack). 'root' needs no registration:
+*  unregistered, it resolves to the app's root view when that's a
+*  Frame — the standard `Application.run({ create: () => frame })` boot
+*  shape. An explicit registerStack('root', frame) overrides it. */
+var stacks = /* @__PURE__ */ new Map();
+var regListeners = /* @__PURE__ */ new Set();
+function registerStack(name, frame) {
+	stacks.set(name, frame);
+	regListeners.forEach((l) => l(name, frame));
+}
+function getStack(name) {
+	const registered = stacks.get(name);
+	if (registered) return registered;
+	if (name === "root") {
+		const rv = Application.getRootView?.();
+		if (rv instanceof Frame) return rv;
+	}
+}
+/** All registered stacks in registration order — for hardware-back
+*  resolution (pop whichever stack is visibly on top). */
+function stackEntries() {
+	return stacks.entries();
+}
+/** Internal: route.native attaches frame listeners as stacks appear —
+*  named frames can register after a useRoute subscription ran. */
+function onStackRegistered(cb) {
+	regListeners.add(cb);
+}
 //#endregion
-export { Modal };
+export { getStack, onStackRegistered, registerStack, stackEntries };

package/dist/native/ui19.js

@@ -1,35 +1,249 @@
-import { createNativeScriptRoot } from "@nativescript-community/octane";
-import { Frame, GridLayout } from "@nativescript/core";
-//#region src/modal-service.native.ts
-/** Open a component in its own NativeScript modal root and resolve on close. */
-var openModal = (Component, params, options = {}) => new Promise((resolve, reject) => {
-	const presenter = Frame.topmost()?.currentPage ?? Frame.topmost();
-	if (!presenter) {
-		reject(/* @__PURE__ */ new Error("Cannot open modal before a NativeScript page is active"));
-		return;
-	}
-	const host = new GridLayout();
-	const root = createNativeScriptRoot(host);
-	let finished = false;
-	const finish = (result) => {
-		if (finished) return;
-		finished = true;
-		root.unmount?.();
-		host.removeChildren?.();
-		resolve(result);
+//#region src/route-table.ts
+var EXT = /\.(tsrx|tsx|ts|mts|cts|js|mjs|cjs|jsx)$/;
+var SUFFIX = /\.(web|native|ios|android)$/;
+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;
+		this.name = "RouteRedirect";
+	}
+};
+/** Component pick rule for route/layout modules: default export, then a
+*  `screen` named export, then a single function export. Route files use
+*  named exports (decision #13) — a lone component is unambiguous.
+*  route-config exports are reserved metadata, never the screen. */
+function pick(mod, file) {
+	if (typeof mod?.default === "function") return mod.default;
+	if (typeof mod?.screen === "function") return mod.screen;
+	const fns = Object.keys(mod ?? {}).filter((k) => typeof mod[k] === "function" && ![
+		"loader",
+		"beforeLoad",
+		"head"
+	].includes(k));
+	if (fns.length === 1) return mod[fns[0]];
+	console.warn("[octane-xplat] route file " + file + (fns.length ? ` has ${fns.length} component-shaped exports (${fns.join(", ")}) — add a default or 'screen' export` : " has no component export") + " — skipped");
+}
+function deriveRouteManifest(files, prefer, dir = "app") {
+	const prefix = dir.replace(/^\.?\/?/, "").replace(/\/+$/, "") + "/";
+	const seen = /* @__PURE__ */ new Map();
+	const layoutRank = /* @__PURE__ */ new Map();
+	const layouts = {};
+	const loaders = {};
+	const warned = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(files).sort()) {
+		let rel = key.replace(/^\.?\//, "");
+		if (rel.startsWith(prefix)) rel = rel.slice(prefix.length);
+		rel = rel.replace(EXT, "");
+		const parts = rel.split("/");
+		let base = parts[parts.length - 1];
+		const sm = SUFFIX.exec(base);
+		const suffix = sm?.[1];
+		if (sm) base = base.slice(0, base.length - sm[0].length);
+		if (suffix && !prefer.includes(suffix)) continue;
+		const rank = suffix ? prefer.indexOf(suffix) : prefer.length;
+		const pm = PRESENT.exec(base);
+		const presentation = pm?.[1];
+		if (pm) base = base.slice(0, base.length - pm[0].length);
+		if (base === "_layout") {
+			const d = parts.slice(0, -1).join("/");
+			const prev = layoutRank.get(d);
+			if (prev !== void 0 && prev <= rank) continue;
+			const component = pick(files[key], key);
+			if (component) {
+				layouts[d] = component;
+				layoutRank.set(d, rank);
+			}
+			continue;
+		}
+		const segs = parts.slice(0, -1).concat(base);
+		if (segs[segs.length - 1] === "index") segs.pop();
+		const segments = segs.map((s) => {
+			const p = PARAM.exec(s);
+			return p ? ":" + p[1] : s;
+		});
+		const name = segments.join("/") || "index";
+		const meta = {
+			name,
+			segments,
+			params: segments.filter((s) => s.startsWith(":")).map((s) => s.slice(1)),
+			file: key,
+			presentation
+		};
+		const loader = files[key]?.loader;
+		if (typeof loader === "function") meta.loader = loader;
+		const beforeLoad = files[key]?.beforeLoad;
+		if (typeof beforeLoad === "function") meta.beforeLoad = beforeLoad;
+		if (files[key]?.head && (typeof files[key].head === "object" || typeof files[key].head === "function")) meta.head = files[key].head;
+		const prev = seen.get(name);
+		if (prev && prev.rank <= rank) {
+			if (prev.rank === rank && !warned.has(name)) {
+				warned.add(name);
+				console.warn(`[octane-xplat] route '${name}' is defined by both ${prev.meta.file} and ${key} — keeping ${prev.meta.file}`);
+			}
+			continue;
+		}
+		const component = pick(files[key], key);
+		if (component) seen.set(name, {
+			rank,
+			meta,
+			component
+		});
+	}
+	const screens = {};
+	const routes = [];
+	for (const { meta, component } of seen.values()) {
+		screens[meta.name] = component;
+		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));
+	return {
+		screens,
+		routes,
+		layouts,
+		loaders
 	};
-	const close = (result) => host.closeModal(result);
-	root.render(Component, {
-		params,
-		close
-	});
-	const fullscreen = options.presentation ? options.presentation === "fullscreen" : options.fullscreen ?? true;
-	presenter.showModal(host, {
-		context: {},
-		closeCallback: finish,
-		fullscreen,
-		animated: options.animated ?? true
+}
+/** Match URL path segments against a manifest — returns the winning meta
+*  plus extracted params, or null. First hit wins (routes are pre-sorted
+*  by specificity). */
+function matchRoute(routes, segs) {
+	for (const meta of routes) {
+		if (meta.segments.length !== segs.length) continue;
+		const params = {};
+		let ok = true;
+		for (let i = 0; i < segs.length; i++) {
+			const p = meta.segments[i];
+			if (p.startsWith(":")) params[p.slice(1)] = decodeRouteParam(decodeURIComponent(segs[i]));
+			else if (p !== segs[i]) {
+				ok = false;
+				break;
+			}
+		}
+		if (ok) return {
+			meta,
+			params
+		};
+	}
+	return null;
+}
+/** Serialize a Route to a URL path (no origin): manifest routes substitute
+*  `:param` segments from params (leftover params → query string);
+*  non-manifest names keep the legacy `/<stack>/<name>?params` shape. */
+function buildRoutePath(routes, r) {
+	const meta = routes.find((m) => m.name === r.name);
+	let segs;
+	let rest = r.params;
+	if (meta) {
+		segs = meta.segments.map((s) => {
+			if (!s.startsWith(":")) return s;
+			const v = r.params[s.slice(1)];
+			if (v === void 0) console.warn(`[octane-xplat] route '${r.name}' pushed without path param ${s}`);
+			return encodeURIComponent(encodeRouteParam(v, r.name, s.slice(1)));
+		});
+		rest = Object.fromEntries(Object.entries(r.params).filter(([k]) => !meta.params.includes(k)));
+	} else segs = [r.name];
+	const q = Object.entries(rest).map(([k, v]) => encodeURIComponent(k) + "=" + encodeURIComponent(encodeRouteParam(v, r.name, k))).join("&");
+	return (((r.stack === "root" ? "" : "/" + r.stack) + "/" + segs.join("/")).replace(/\/+$/, "") || "/") + (q ? "?" + q : "");
+}
+var JSON_PARAM_PREFIX = "json:";
+/** Route codegen exposes string params, but the low-level Route shape remains
+* open for compatibility. Preserve accidental object params on web instead
+* of silently turning them into `[object Object]`; generated APIs still keep
+* callers on scalar strings. */
+function encodeRouteParam(value, routeName, key) {
+	if (value === void 0 || value === null || [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof value)) return String(value ?? "");
+	console.warn(`[octane-xplat] route '${routeName}' param '${key}' is non-scalar; JSON-encoding it for the URL`);
+	try {
+		return JSON_PARAM_PREFIX + JSON.stringify(value);
+	} catch {
+		console.warn(`[octane-xplat] route '${routeName}' param '${key}' could not be JSON-encoded; using an empty value`);
+		return "";
+	}
+}
+function decodeRouteParam(value) {
+	if (!value.startsWith(JSON_PARAM_PREFIX)) return value;
+	try {
+		return JSON.parse(value.slice(5));
+	} catch {
+		return value;
+	}
+}
+/** `?a=1&b=2` → params — shared code carries no URLSearchParams
+*  (invariant 4: no DOM globals on the native path). */
+function parseQueryString(qs) {
+	const params = {};
+	if (!qs) return params;
+	for (const pair of qs.split("&")) {
+		if (!pair) continue;
+		const eq = pair.indexOf("=");
+		const k = eq === -1 ? pair : pair.slice(0, eq);
+		const v = eq === -1 ? "" : pair.slice(eq + 1);
+		params[decodeURIComponent(k)] = decodeRouteParam(decodeURIComponent(v));
+	}
+	return params;
+}
+/** Full URL or path → canonical path for matching. `https://x/a/b?y` →
+*  `/a/b?y`; custom-scheme links keep their host as the first segment —
+*  `textcoral://post/5` → `/post/5` (the common app-scheme convention). */
+function linkPath(url) {
+	const m = /^[a-z][a-z0-9+.-]*:(\/\/)?/i.exec(url);
+	let rest = m ? url.slice(m[0].length) : url;
+	if (m?.[1] && /^https?:\/\//i.test(m[0])) rest = rest.replace(/^[^/?#]*/, "");
+	return "/" + rest.replace(/^\/+/, "");
+}
+/** Match a URL path+query against the manifest into a Route — the shared
+*  half of web's URL parse and native's deep-link handling. Whole-path
+*  match wins ('/demo/x' → root 'demo/:id'); a non-matching first segment
+*  is the stack prefix ('/demos/demo/x' → stack 'demos'). Unmatched names
+*  fall through as literal routes for pre-manifest callers. */
+function matchUrl(routes, url) {
+	const [p, qs] = url.split("?");
+	const segs = p.split("/").filter(Boolean);
+	const query = parseQueryString(qs);
+	if (!segs.length) return null;
+	const finish = (stack, m, fallbackName) => ({
+		stack,
+		name: m ? m.meta.name : fallbackName,
+		params: {
+			...query,
+			...m?.params
+		},
+		presentation: m?.meta.presentation
 	});
-});
+	const root = matchRoute(routes, segs);
+	if (root) return finish("root", root, segs.join("/"));
+	if (segs.length > 1) {
+		const named = matchRoute(routes, segs.slice(1));
+		if (named) return finish(segs[0], named, segs[1]);
+		return finish(segs[0], null, segs[1]);
+	}
+	return finish("root", null, segs[0]);
+}
+/** Layout components wrapping a route name, outermost → innermost —
+*  'chat/room' picks up `app/chat/_layout.tsrx`, 'a/b/c' chains 'a' then
+*  'a/b'. The '' root layout is the app's own shell (entry renders it)
+*  and never joins a chain. Leaves apply the chain at render: native
+*  wraps each pushed Page's component, web wraps the outlet's resolved
+*  element. */
+function layoutChain(layouts, name) {
+	const segs = name.split("/");
+	const chain = [];
+	for (let i = 1; i < segs.length; i++) {
+		const L = layouts[segs.slice(0, i).join("/")];
+		if (L) chain.push(L);
+	}
+	return chain;
+}
 //#endregion
-export { openModal };
+export { RouteRedirect, buildRoutePath, deriveRouteManifest, layoutChain, linkPath, matchRoute, matchUrl, parseQueryString };

package/dist/native/ui20.js

@@ -1,17 +1,28 @@
-import { hookSlots, useSyncExternalStore } from "@nativescript-community/octane";
-import { Application } from "@nativescript/core";
-//#region src/theme/colorScheme.native.tsrx
-var _h$0 = /* @__PURE__ */ Symbol(/* @__PURE__ */ hookSlots(1));
-function getColorScheme() {
-	return Application.primaryWindow?.systemAppearance?.() ?? Application.systemAppearance?.() ?? "light";
-}
-function subscribe(cb) {
-	const h = () => cb();
-	Application.on("systemAppearanceChanged", h);
-	return () => Application.off("systemAppearanceChanged", h);
-}
-function useColorScheme() {
-	return useSyncExternalStore(subscribe, getColorScheme, _h$0);
-}
+import { defineUniversalComponent, universalComponent, universalPlan, universalProps, universalValue } from "@nativescript-community/octane";
+//#region src/RouteHost.native.tsrx
+var __octaneUniversalPlan0 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+var __octaneUniversalPlan1 = universalPlan("nativescript", {
+	"kind": "slot",
+	"slot": 0
+});
+var __octaneUniversalPlan2 = universalPlan("nativescript", {
+	"kind": "range",
+	"children": [{
+		"kind": "slot",
+		"slot": 0
+	}]
+});
+var RouteHost = defineUniversalComponent("nativescript", function RouteHost(props) {
+	const Screen = props.screen;
+	let child = universalValue(__octaneUniversalPlan0, [universalComponent("nativescript", Screen, universalProps([["spread", props.params]]))]);
+	for (let i = props.layouts.length - 1; i >= 0; i--) {
+		const Layout = props.layouts[i];
+		child = universalValue(__octaneUniversalPlan1, [universalComponent("nativescript", Layout, universalProps([], child))]);
+	}
+	return universalValue(__octaneUniversalPlan2, [child]);
+}, { "module": "@nativescript-community/octane" });
 //#endregion
-export { getColorScheme, useColorScheme };
+export { RouteHost };