@octane-xplat/ui 0.2.1 → 0.4.0

package/dist/native/ui19.js

@@ -1,13 +1,249 @@
-//#region src/route.native.ts
-function routeFor(_stack) {
-	return null;
+//#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 currentRoute() {
-	return null;
+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
+	};
 }
-function useRoute(_stack) {
+/** 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;
 }
-function pushRoute(_r) {}
+/** 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 { currentRoute, pushRoute, routeFor, useRoute };
+export { RouteRedirect, buildRoutePath, deriveRouteManifest, layoutChain, linkPath, matchRoute, matchUrl, parseQueryString };

package/dist/native/ui2.js

@@ -1,49 +1,11 @@
-import { defineUniversalComponent, hookSlots, universalPlan, universalValue, useCallback } from "@nativescript-community/octane";
-//#region src/View.native.tsrx
-var _h$0 = /* @__PURE__ */ Symbol(/* @__PURE__ */ hookSlots(1));
-var __octaneUniversalPlan0 = universalPlan("nativescript", {
-	"kind": "host",
-	"type": "flexboxlayout",
-	"props": { "flexDirection": "column" },
-	"bindings": [
-		["id", 0],
-		["ref", 1],
-		["className", 2],
-		["style", 3],
-		["onPan", 4],
-		["onSwipe", 5]
-	],
-	"children": [{
-		"kind": "slot",
-		"slot": 6
-	}]
-});
-var PAN_STATE = [
-	"cancelled",
-	"began",
-	"moved",
-	"ended"
-];
-var View = defineUniversalComponent("nativescript", function View(props) {
-	const onPan = useCallback((e) => props.onPan?.({
-		x: e.deltaX,
-		y: e.deltaY,
-		dx: e.deltaX,
-		dy: e.deltaY,
-		vx: 0,
-		vy: 0,
-		state: PAN_STATE[e.state] ?? "moved",
-		target: e.view ?? e.object
-	}), [props.onPan], _h$0);
-	return universalValue(__octaneUniversalPlan0, [
-		props.id,
-		props.bind,
-		props.className,
-		props.style,
-		props.onPan ? onPan : void 0,
-		props.onSwipe,
-		props.children
-	]);
-}, { "module": "@nativescript-community/octane" });
+//#region src/cx.ts
+/** NS `className` splits on ' ' only, and the universal driver applies the
+*  prop via `String(value)` — an array would arrive comma-joined and match
+*  no class at all. Native leaves normalize through cx() before handing
+*  className to an intrinsic. (The DOM renderer already flattens arrays,
+*  so web leaves don't need this.) */
+function cx(...parts) {
+	return parts.flat(Infinity).filter(Boolean).join(" ");
+}
 //#endregion
-export { View };
+export { cx };

package/dist/native/ui20.js

@@ -0,0 +1,28 @@
+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 { RouteHost };