@octane-xplat/cli 0.3.0 → 0.5.0

package/src/commands/routes.mjs

@@ -0,0 +1,203 @@
+import { command, option, optional, string } from '@alloc/cmd-ts'
+import { existsSync, readdirSync, statSync, writeFileSync } from 'node:fs'
+import { join, relative, sep } from 'node:path'
+import * as p from '@clack/prompts'
+
+// Mirror of packages/ui/src/route-table.ts conventions — the CLI walks the
+// route dir off disk (no vite glob), so the derivation is re-implemented
+// here. Keep the two in sync: same suffix strip order, same index/_layout
+// rules. All platform variants count — the union is cross-platform.
+const EXT = /\.(tsrx|tsx|ts|mts|cts|js|mjs|cjs|jsx)$/
+const SUFFIX = /\.(web|native|ios|android)$/
+const PARAM = /^\[(.+)\]$/
+const PRESENT = /\+(modal|fade|push)$/
+
+function walk(dir, out = []) {
+	for (const name of readdirSync(dir).sort()) {
+		const full = join(dir, name)
+		if (statSync(full).isDirectory()) {
+			walk(full, out)
+		} else if (EXT.test(name)) {
+			out.push(full)
+		}
+	}
+
+	return out
+}
+
+function routeFor(rel) {
+	rel = rel.split(sep).join('/').replace(EXT, '')
+	const parts = rel.split('/')
+	let base = parts[parts.length - 1]
+	const sm = SUFFIX.exec(base)
+	if (sm) {
+		base = base.slice(0, base.length - sm[0].length)
+	}
+
+	const pm = PRESENT.exec(base)
+	const presentation = pm ? pm[1] : undefined
+	if (pm) {
+		base = base.slice(0, base.length - pm[0].length)
+	}
+
+	if (base === '_layout') {
+		return null
+	}
+
+	const segs = parts.slice(0, -1).concat(base)
+	if (segs[segs.length - 1] === 'index') {
+		segs.pop()
+	}
+
+	const segments = segs.map((s) => {
+		const m = PARAM.exec(s)
+		return m ? ':' + m[1] : s
+	})
+
+	return {
+		name: segments.join('/') || 'index',
+		params: segments.filter((s) => s.startsWith(':')).map((s) => s.slice(1)),
+		presentation,
+	}
+}
+
+/** Generates routes.gen.types.ts + platform manifest glue for a route dir.
+ *  Returns true when a dir was found and files written; false when no route
+ *  dir exists (callers that run this implicitly — dev/build — stay quiet). */
+export function generateRoutes(cwd, dir, out) {
+	if (!dir) {
+		return false
+	}
+
+	// `out` is the module basename — three files are emitted:
+	//   <out>.types.ts    shared types (RouteName/Params/Presentations)
+	//   <out>.web.ts      web glob + registerRoutes
+	//   <out>.native.ts   native glob + registerRoutes (Device.os prefer)
+	// Importing '<out>' resolves the platform leaf automatically.
+	const base = (out ?? join(dir, '..', 'routes.gen')).replace(/\.ts$/, '')
+
+	// name → {params, presentation}; platform variants of one route
+	// collapse to a single entry (union across platforms).
+	const seen = new Map()
+	for (const file of walk(join(cwd, dir))) {
+		const r = routeFor(relative(join(cwd, dir), file))
+		if (!r) {
+			continue
+		}
+
+		if (!seen.has(r.name)) {
+			seen.set(r.name, r)
+		}
+	}
+
+	const list = [...seen.values()].sort((a, b) => a.name.localeCompare(b.name))
+
+	const union = list.length ? list.map((r) => `\n\t| '${r.name}'`).join('') : 'never'
+
+	const params = list
+		.map((r) => `\t'${r.name}': { ${r.params.map((k) => `${k}: string`).join('; ')} }`)
+
+	const presents = list
+		.filter((r) => r.presentation)
+		.map((r) => `\t'${r.name}': '${r.presentation}'`)
+
+	const src = `// Generated by \`xplat routes\` — do not edit. Re-run after
+// touching the route dir (add/remove/rename route files).
+export type RouteName =${union}
+
+export interface RouteParams {
+${params.length ? params.join('\n') : '\t// no param routes'}
+}
+
+export interface RoutePresentations {
+${presents.length ? presents.join('\n') : '\t// no +modal/+fade routes'}
+}
+`
+
+	writeFileSync(join(cwd, base + '.types.ts'), src)
+
+	// Platform-suffixed twins carry the actual manifest derivation +
+	// registration — routes.gen.web.ts / routes.gen.native.ts resolve
+	// through the platform extension chain, so importing './routes.gen'
+	// gets the right glob for the platform with no app-side leaf file.
+	// Types live in '.types.ts' — './routes.gen' inside a .web.ts sibling
+	// would self-resolve.
+	const outDir = join(cwd, base, '..')
+	const rel = relative(outDir, join(cwd, dir)).split(sep).join('/')
+	const globDir = rel.startsWith('.') ? rel : './' + rel
+	const baseName = base.split('/').pop()
+	const typesRef = `export type { RouteName, RouteParams, RoutePresentations } from './${baseName}.types'`
+
+	const shared = (prelude, globs, prefer) => `// Generated by \`xplat routes\` — do not edit.
+${prelude}import { deriveRouteManifest, registerRoutes } from '@octane-xplat/ui'
+${typesRef}
+
+const files = import.meta.glob(
+	[
+		'${globDir}/**/*.{tsrx,tsx}',
+${globs}
+	],
+	{ eager: true },
+)
+
+export const routes = deriveRouteManifest(files, ${prefer})
+registerRoutes(routes)
+export const screens = routes.screens
+`
+
+	writeFileSync(
+		join(cwd, base + '.web.ts'),
+		shared(
+			'',
+			[
+				`\t\t'!${globDir}/**/*.native.{tsrx,tsx}'`,
+				`\t\t'!${globDir}/**/*.ios.{tsrx,tsx}'`,
+				`\t\t'!${globDir}/**/*.android.{tsrx,tsx}'`,
+			].join(',\n'),
+			`['web']`,
+		),
+	)
+
+	writeFileSync(
+		join(cwd, base + '.native.ts'),
+		shared(
+			`import { Device } from '@nativescript/core'\n`,
+			`\t\t'!${globDir}/**/*.web.{tsrx,tsx}'`,
+			`Device.os === 'Android' ? ['android', 'native'] : ['ios', 'native']`,
+		),
+	)
+
+	return list.length
+}
+
+export const routes = command({
+	name: 'routes',
+	description: 'Generate routes.gen.ts (typed RouteName/params) from the route dir',
+	args: {
+		dir: option({
+			long: 'dir',
+			short: 'd',
+			type: optional(string),
+			description: 'Route dir — default: first of ./app, ./src/app',
+		}),
+		out: option({
+			long: 'out',
+			short: 'o',
+			type: optional(string),
+			description: 'Output file — default: <route dir>/../routes.gen.ts',
+		}),
+	},
+	handler: async (args) => {
+		const cwd = process.cwd()
+		const dir = args.dir ?? ['app', 'src/app'].find((d) => existsSync(join(cwd, d)))
+		if (!dir) {
+			p.log.error('No route dir found — expected ./app or ./src/app (or pass --dir).')
+			process.exit(1)
+		}
+
+		const count = generateRoutes(cwd, dir, args.out)
+		p.log.success(
+			`Wrote routes.gen.{types,web,native}.ts — ${count} route${count === 1 ? '' : 's'}`,
+		)
+	},
+})

package/src/commands/typecheck.mjs

@@ -1,23 +1,34 @@
-import { command } from '@alloc/cmd-ts';
-import { existsSync } from 'node:fs';
-import * as p from '@clack/prompts';
-import { runTagged } from '../procs.mjs';
+import { command } from '@alloc/cmd-ts'
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+import * as p from '@clack/prompts'
+import { runTagged } from '../procs.mjs'
+import { generateRoutes } from './routes.mjs'
 
 export const typecheck = command({
 	name: 'typecheck',
 	description: 'tsrx-tsc --noEmit for every tsconfig present',
 	args: {},
 	handler: async () => {
-		const cwd = process.cwd();
-		const configs = ['tsconfig.json', 'tsconfig.native.json'].filter((f) => existsSync(`${cwd}/${f}`));
+		const cwd = process.cwd()
+		const routeDir = ['app', 'src/app'].find((d) => existsSync(join(cwd, d)))
+		if (routeDir) {
+			generateRoutes(cwd, routeDir)
+		}
+
+		const configs = ['tsconfig.json', 'tsconfig.native.json'].filter((f) =>
+			existsSync(`${cwd}/${f}`),
+		)
+
 		for (const c of configs) {
 			try {
-				await runTagged('tsc', 'pnpm', ['exec', 'tsrx-tsc', '--noEmit', '-p', c], cwd);
+				await runTagged('tsc', 'pnpm', ['exec', 'tsrx-tsc', '--noEmit', '-p', c], cwd)
 			} catch (e) {
-				p.log.error(String(e));
-				process.exit(1);
+				p.log.error(String(e))
+				process.exit(1)
 			}
 		}
-		p.log.success('Typecheck clean');
+
+		p.log.success('Typecheck clean')
 	},
-});
+})

package/src/procs.mjs

@@ -1,33 +1,39 @@
 // Prefixed process plumbing — dev runs several tools side by side, so each
 // gets a short tag on its output lines. SIGINT fans out to every child.
-import { spawn } from 'node:child_process';
+import { spawn } from 'node:child_process'
 
-const children = new Set();
+const children = new Set()
 
 process.on('SIGINT', () => {
-	for (const p of children) p.kill('SIGINT');
-	process.exit(130);
-});
+	for (const p of children) {
+		p.kill('SIGINT')
+	}
+
+	process.exit(130)
+})
 
 /** Spawn long-running, output prefixed `[tag]`. */
 export function spawnTagged(tag, cmd, args, cwd) {
-	const p = spawn(cmd, args, { cwd, env: process.env });
-	children.add(p);
+	const p = spawn(cmd, args, { cwd, env: process.env })
+	children.add(p)
 	const prefix = (chunk) => {
 		for (const line of chunk.toString().split('\n')) {
-			if (line.trim()) process.stdout.write(`[${tag}] ${line}\n`);
+			if (line.trim()) {
+				process.stdout.write(`[${tag}] ${line}\n`)
+			}
 		}
-	};
-	p.stdout.on('data', prefix);
-	p.stderr.on('data', prefix);
-	p.on('exit', () => children.delete(p));
-	return p;
+	}
+
+	p.stdout.on('data', prefix)
+	p.stderr.on('data', prefix)
+	p.on('exit', () => children.delete(p))
+	return p
 }
 
 /** Spawn to completion, output prefixed `[tag]`. Resolves on exit 0. */
 export function runTagged(tag, cmd, args, cwd) {
 	return new Promise((resolve, reject) => {
-		const p = spawnTagged(tag, cmd, args, cwd);
-		p.on('exit', (code) => (code === 0 ? resolve() : reject(new Error(`${tag} exited ${code}`))));
-	});
+		const p = spawnTagged(tag, cmd, args, cwd)
+		p.on('exit', (code) => (code === 0 ? resolve() : reject(new Error(`${tag} exited ${code}`))))
+	})
 }

package/src/targets.mjs

@@ -1,78 +1,110 @@
 // Target + device discovery. Everything degrades quietly — a missing
 // toolchain means the target is absent from prompts, not an error.
-import { existsSync } from 'node:fs';
-import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs'
+import { execFileSync } from 'node:child_process'
 
 const run = (cmd, args) => {
 	try {
-		return execFileSync(cmd, args, { encoding: 'utf8', timeout: 15000, stdio: ['ignore', 'pipe', 'ignore'] });
+		return execFileSync(cmd, args, {
+			encoding: 'utf8',
+			timeout: 15000,
+			stdio: ['ignore', 'pipe', 'ignore'],
+		})
 	} catch {
-		return null;
+		return null
 	}
-};
+}
+
+export const hasWeb = (cwd) =>
+	existsSync(`${cwd}/vite.config.ts`) || existsSync(`${cwd}/vite.config.mts`)
 
-export const hasWeb = (cwd) => existsSync(`${cwd}/vite.config.ts`) || existsSync(`${cwd}/vite.config.mts`);
-export const hasNative = (cwd) => existsSync(`${cwd}/nativescript.config.ts`);
+export const hasNative = (cwd) => existsSync(`${cwd}/nativescript.config.ts`)
 
 /** iOS targets: booted sims first, then other available sims, then physical devices. */
 export function iosTargets() {
-	const out = run('xcrun', ['simctl', 'list', 'devices', 'available', '-j']);
-	if (!out) return [];
+	const out = run('xcrun', ['simctl', 'list', 'devices', 'available', '-j'])
+	if (!out) {
+		return []
+	}
+
 	try {
-		const j = JSON.parse(out);
-		const sims = [];
+		const j = JSON.parse(out)
+		const sims = []
 		for (const list of Object.values(j.devices ?? {})) {
 			for (const d of list) {
-				if (!d.isAvailable) continue;
+				if (!d.isAvailable) {
+					continue
+				}
+
 				sims.push({
 					kind: 'ios',
 					id: d.udid,
 					name: d.name + (d.state === 'Booted' ? ' (booted)' : ''),
 					device: d.udid,
 					booted: d.state === 'Booted',
-				});
+				})
 			}
 		}
+
 		// Booted first — that's almost always the one you mean.
-		return sims.sort((a, b) => (b.booted ? 1 : 0) - (a.booted ? 1 : 0));
+		return sims.sort((a, b) => (b.booted ? 1 : 0) - (a.booted ? 1 : 0))
 	} catch {
-		return [];
+		return []
 	}
 }
 
 /** Android targets: emulators + physical devices from adb. */
 export function androidTargets() {
-	const out = run('adb', ['devices']);
-	if (!out) return [];
+	const out = run('adb', ['devices'])
+	if (!out) {
+		return []
+	}
+
 	return out
 		.split('\n')
 		.slice(1)
 		.map((l) => l.trim())
 		.filter((l) => l.endsWith('\tdevice'))
 		.map((l) => {
-			const serial = l.split('\t')[0];
-			const emu = serial.startsWith('emulator-');
-			return { kind: 'android', id: serial, name: emu ? `${serial} (emulator)` : `${serial} (device)`, device: serial };
-		});
+			const serial = l.split('\t')[0]
+			const emu = serial.startsWith('emulator-')
+			return {
+				kind: 'android',
+				id: serial,
+				name: emu ? `${serial} (emulator)` : `${serial} (device)`,
+				device: serial,
+			}
+		})
 }
 
 /** Every launchable target for this project + machine. */
 export function discoverTargets(cwd) {
-	const targets = [];
-	if (hasWeb(cwd)) targets.push({ kind: 'web', id: 'web', name: 'Web (vite :5200)' });
+	const targets = []
+	if (hasWeb(cwd)) {
+		targets.push({ kind: 'web', id: 'web', name: 'Web (vite :5200)' })
+	}
+
 	if (hasNative(cwd)) {
-		targets.push(...iosTargets(), ...androidTargets());
+		targets.push(...iosTargets(), ...androidTargets())
 	}
-	return targets;
+
+	return targets
 }
 
 /** Distinct platform buckets for `build` — one entry per platform, no device picks. */
 export function buildTargets(cwd) {
-	const t = [];
-	if (hasWeb(cwd)) t.push({ kind: 'web', id: 'web', name: 'Web (vite build)' });
+	const t = []
+	if (hasWeb(cwd)) {
+		t.push({ kind: 'web', id: 'web', name: 'Web (vite build)' })
+	}
+
 	if (hasNative(cwd)) {
-		if (iosTargets().length || run('xcrun', ['--version'])) t.push({ kind: 'ios', id: 'ios', name: 'iOS (ns build ios)' });
-		t.push({ kind: 'android', id: 'android', name: 'Android (ns build android)' });
+		if (iosTargets().length || run('xcrun', ['--version'])) {
+			t.push({ kind: 'ios', id: 'ios', name: 'iOS (ns build ios)' })
+		}
+
+		t.push({ kind: 'android', id: 'android', name: 'Android (ns build android)' })
 	}
-	return t;
+
+	return t
 }

package/src/vite.d.ts

@@ -0,0 +1,20 @@
+import type { UserConfig } from 'vite'
+
+export const nativeExtensions: string[]
+
+export interface XplatNativeOptions {
+	/** Extra optimizeDeps.exclude entries — app-shipped @nativescript plugins. */
+	deps?: string[]
+	/** Renderer rules override — defaults cover src/ + linked package source. */
+	rules?: unknown[]
+	/** App-specific config merged in last (plugins, server, …). */
+	extra?: UserConfig
+}
+
+/** Full native (iOS/Android) Vite config — the shared preset. Resolves the
+ *  app's own vite/vite-octane/octane toolchain (async because it loads
+ *  through the app's node_modules). */
+export function xplatNative(
+	env: { mode: string } | string,
+	opts?: XplatNativeOptions,
+): Promise<UserConfig>