create-jilatax 0.0.3 → 0.0.5

package/README.md

@@ -1,21 +1,55 @@
 # create-jilatax
 
-> A minimal TypeScript library package with ESM, CommonJS, and declaration outputs.
+Create an Android-first Lynx application backed by the Jilatax runtime and CLI.
 
-Requires Node.js 22.18 or newer.
+Requires Node.js 22.18 or newer and Bun.
 
-## Install
+## Create an application
+
+```sh
+bun create jilatax@latest
+```
+---
+
+```bash
+bunx create-jilatax@latest my-app
+cd my-app
+bun run run:android
+```
+
+The creator asks for the application name, Android package ID, and whether to
+install dependencies. In non-interactive environments, pass the directory and
+options explicitly:
 
 ```bash
-npm i create-jilatax
+bunx create-jilatax@latest my-app \
+  --name "My App" \
+  --package-id com.example.my_app \
+  --skip-install
 ```
 
-## Usage
+Generated projects include:
+
+- a Lynx and Rspeedy application;
+- `app.json` as the Jilatax application configuration;
+- an Android Gradle project linked to `jilatax/android`;
+- `bun run run:android` for development on a connected device;
+- `bun run create:aab` for a Play Store Android App Bundle.
+
+The creator only writes the project and can run `bun install`. Device, Gradle,
+bundle, APK, and AAB orchestration belongs to `@jilatax/cli`.
+
+## Programmatic API
 
 ```ts
-import { hello } from "create-jilatax";
+import { createProject } from 'create-jilatax';
 
-hello("world");
+await createProject({
+  targetDirectory: './my-app',
+  displayName: 'My App',
+  packageId: 'com.example.my_app',
+  install: false,
+});
 ```
 
 ## Development
@@ -25,21 +59,6 @@ bun install
 bun run check
 ```
 
-## 📄 License
+## License
 
 MIT © [JilataX](https://jilatax.dev) — see [`LICENSE`](./LICENSE).
-
-<br>
-
----
-
-<div align="center">
-  <p>
-    Built with <strong>Bun</strong>, <strong>TypeScript</strong>, and <strong>Lynx</strong>.
-  </p>
-  <p>
-    <a href="https://www.jilatax.dev/jilatax">Website</a> ·
-    <a href="https://github.com/jilatax/jilatax">GitHub</a> ·
-    <a href="https://www.npmjs.com/package/jilatax">npm</a>
-  </p>
-</div>

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,7 @@
+# Third-party notices
+
+The generated Android template includes the Gradle Wrapper from Gradle 8.11.1.
+Gradle is licensed under the Apache License 2.0.
+
+- Project: https://github.com/gradle/gradle
+- License: https://www.apache.org/licenses/LICENSE-2.0

package/dist/bin.cjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+//#region src/bin.ts
+require("./cli-DMT97_QW.cjs").runCreateCli().then((exitCode) => {
+	process.exitCode = exitCode;
+});
+//#endregion

package/dist/bin.d.cts

@@ -0,0 +1 @@
+export {}

package/dist/bin.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/bin.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { n as runCreateCli } from "./cli-B8DIbCrH.js";
+//#region src/bin.ts
+runCreateCli().then((exitCode) => {
+	process.exitCode = exitCode;
+});
+//#endregion
+export {};

package/dist/cli-B8DIbCrH.js

@@ -0,0 +1,387 @@
+import * as prompts from "@clack/prompts";
+import { chmod, copyFile, lstat, mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { stdin, stdout } from "node:process";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseAppConfig, serializeAndroidProjectConfig } from "jilatax";
+//#region src/generator.ts
+const JILATAX_CLI_VERSION = "^0.0.8";
+const JILATAX_VERSION = "^0.0.5";
+const LYNX_QRCODE_PLUGIN_VERSION = "^0.4.4";
+const LYNX_REACT_VERSION = "^0.116.2";
+const LYNX_TYPES_VERSION = "^3.7.0";
+const REACT_PLUGIN_VERSION = "^0.12.7";
+const RSPEEDY_VERSION = "^0.13.3";
+const TEXT_TEMPLATE_FILES = /* @__PURE__ */ new Set([
+	"README.md.tmpl",
+	"android/settings.gradle.kts.tmpl",
+	"src/App.tsx.tmpl"
+]);
+async function createProject(options) {
+	const projectDirectory = path.resolve(options.targetDirectory);
+	const projectName = normalizeProjectName(path.basename(projectDirectory));
+	const displayName = normalizeDisplayName(options.displayName ?? titleCase$1(projectName));
+	const packageId = validatePackageId(options.packageId ?? defaultPackageId(projectName));
+	const config = createInitialConfig(displayName, projectName, packageId);
+	await assertTargetDoesNotExist(projectDirectory);
+	const parentDirectory = path.dirname(projectDirectory);
+	await mkdir(parentDirectory, { recursive: true });
+	const stagingDirectory = await mkdtemp(path.join(parentDirectory, `.${projectName}-`));
+	try {
+		await renderTemplate(stagingDirectory, {
+			displayName,
+			projectName
+		});
+		await writeGeneratedMetadata(stagingDirectory, config, projectName);
+		await rename(stagingDirectory, projectDirectory);
+	} catch (error) {
+		await rm(stagingDirectory, {
+			force: true,
+			recursive: true
+		});
+		throw error;
+	}
+	const shouldInstall = options.install === true;
+	if (shouldInstall) await (options.installer ?? installWithBun)(projectDirectory);
+	return {
+		displayName,
+		installed: shouldInstall,
+		packageId,
+		projectDirectory,
+		projectName
+	};
+}
+function normalizeProjectName(value) {
+	const projectName = value.trim().toLowerCase();
+	if (!/^[a-z0-9][a-z0-9._-]*$/u.test(projectName) || projectName.length > 214) throw new Error("Project directory name must start with a letter or number and contain only lowercase letters, numbers, dots, hyphens, or underscores.");
+	return projectName;
+}
+function normalizeDisplayName(value) {
+	const displayName = value.trim().replace(/\s+/gu, " ");
+	if (displayName.length === 0 || displayName.length > 80) throw new Error("Application name must contain between 1 and 80 characters.");
+	return displayName;
+}
+function defaultPackageId(projectName) {
+	return `com.example.${projectName.replace(/[^a-z0-9_]+/gu, "_").replace(/^[^a-z]+/u, "").replace(/_+$/gu, "") || "app"}`;
+}
+function validatePackageId(value) {
+	const packageId = value.trim();
+	parseAppConfig({ jilatax: {
+		android: { package: packageId },
+		name: "Package validation"
+	} });
+	return packageId;
+}
+async function renderTemplate(targetRoot, values) {
+	await copyTemplateDirectory(fileURLToPath(new URL("../template", import.meta.url)), targetRoot, "", values);
+}
+async function copyTemplateDirectory(templateRoot, targetRoot, relativeDirectory, values) {
+	const entries = await readdir(path.join(templateRoot, relativeDirectory), { withFileTypes: true });
+	for (const entry of entries) {
+		const relativeSource = path.join(relativeDirectory, entry.name);
+		const normalizedSource = relativeSource.split(path.sep).join("/");
+		const sourcePath = path.join(templateRoot, relativeSource);
+		if (entry.isSymbolicLink() || !entry.isDirectory() && !entry.isFile()) throw new Error(`Unsupported template entry: ${normalizedSource}`);
+		if (entry.isDirectory()) {
+			await copyTemplateDirectory(templateRoot, targetRoot, relativeSource, values);
+			continue;
+		}
+		const outputRelative = templateOutputPath(normalizedSource);
+		const outputPath = path.join(targetRoot, ...outputRelative.split("/"));
+		await mkdir(path.dirname(outputPath), { recursive: true });
+		if (normalizedSource.endsWith("gradle-wrapper.jar.base64")) {
+			const encoded = (await readFile(sourcePath, "utf8")).replace(/\s+/gu, "");
+			await writeFile(outputPath, Buffer.from(encoded, "base64"));
+			continue;
+		}
+		if (TEXT_TEMPLATE_FILES.has(normalizedSource)) {
+			await writeFile(outputPath, renderTextTemplate(await readFile(sourcePath, "utf8"), values), "utf8");
+			continue;
+		}
+		if (normalizedSource.endsWith(".tmpl")) throw new Error(`Unregistered text template: ${normalizedSource}`);
+		await copyFile(sourcePath, outputPath);
+	}
+}
+function templateOutputPath(relativeSource) {
+	if (relativeSource === "gitignore") return ".gitignore";
+	if (relativeSource.endsWith("gradle-wrapper.jar.base64")) return relativeSource.slice(0, -7);
+	return relativeSource.endsWith(".tmpl") ? relativeSource.slice(0, -5) : relativeSource;
+}
+function renderTextTemplate(source, values) {
+	const replacements = /* @__PURE__ */ new Map([
+		["{{displayNameJson}}", JSON.stringify(values.displayName)],
+		["{{projectName}}", values.projectName],
+		["{{projectNameJson}}", JSON.stringify(values.projectName)]
+	]);
+	let rendered = source;
+	for (const [token, replacement] of replacements) rendered = rendered.replaceAll(token, replacement);
+	const unresolved = rendered.match(/\{\{[A-Za-z][A-Za-z0-9]*\}\}/u);
+	if (unresolved !== null) throw new Error(`Unresolved template token: ${unresolved[0]}`);
+	return rendered;
+}
+async function writeGeneratedMetadata(projectRoot, config, projectName) {
+	const packageJson = {
+		name: projectName,
+		version: config.jilatax.version,
+		private: true,
+		type: "module",
+		packageManager: "bun@1.3.4",
+		engines: { node: ">=22.18.0" },
+		scripts: {
+			dev: "rspeedy dev",
+			build: "rspeedy build",
+			typecheck: "tsc -b",
+			"run:android": "jilatax run:android",
+			"create:aab": "jilatax create:aab"
+		},
+		dependencies: {
+			"@lynx-js/react": LYNX_REACT_VERSION,
+			jilatax: JILATAX_VERSION
+		},
+		devDependencies: {
+			"@jilatax/cli": JILATAX_CLI_VERSION,
+			"@lynx-js/qrcode-rsbuild-plugin": LYNX_QRCODE_PLUGIN_VERSION,
+			"@lynx-js/react-rsbuild-plugin": REACT_PLUGIN_VERSION,
+			"@lynx-js/rspeedy": RSPEEDY_VERSION,
+			"@lynx-js/types": LYNX_TYPES_VERSION,
+			"@types/node": "^22.20.1",
+			"@types/react": "^18.3.20",
+			typescript: "~5.9.3"
+		}
+	};
+	await writeFile(path.join(projectRoot, "package.json"), `${JSON.stringify(packageJson, null, 2)}\n`, "utf8");
+	await writeFile(path.join(projectRoot, "app.json"), `${JSON.stringify(config, null, 2)}\n`, "utf8");
+	await writeFile(path.join(projectRoot, "android", "jilatax.properties"), serializeAndroidProjectConfig(config), "utf8");
+	if (process.platform !== "win32") await chmod(path.join(projectRoot, "android", "gradlew"), 493);
+}
+function createInitialConfig(displayName, projectName, packageId) {
+	const slug = projectName.replace(/[._-]+/gu, "-").replace(/^-|-$/gu, "");
+	const schemeBase = projectName.replace(/[^a-z0-9+.-]+/gu, "-").replace(/^[^a-z]+/u, "");
+	return parseAppConfig({
+		$schema: "./node_modules/jilatax/schema/app.schema.json",
+		jilatax: {
+			android: {
+				package: packageId,
+				predictiveBackGestureEnabled: false,
+				versionCode: 1
+			},
+			name: displayName,
+			orientation: "portrait",
+			scheme: schemeBase || "jilatax-app",
+			slug,
+			splash: { backgroundColor: "#0F172A" },
+			userInterfaceStyle: "automatic",
+			version: "1.0.0"
+		}
+	});
+}
+async function assertTargetDoesNotExist(target) {
+	try {
+		await lstat(target);
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	throw new Error(`Target directory already exists: ${target}`);
+}
+function titleCase$1(value) {
+	return value.split(/[-_.\s]+/u).filter(Boolean).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
+}
+function installWithBun(projectDirectory) {
+	return new Promise((resolveInstall, rejectInstall) => {
+		const child = spawn("bun", ["install"], {
+			cwd: projectDirectory,
+			env: process.env,
+			stdio: "inherit",
+			windowsHide: true
+		});
+		child.once("error", rejectInstall);
+		child.once("close", (code) => {
+			if (code === 0) {
+				resolveInstall();
+				return;
+			}
+			rejectInstall(/* @__PURE__ */ new Error(`bun install failed with exit code ${code ?? 1}.`));
+		});
+	});
+}
+//#endregion
+//#region src/cli.ts
+var PromptCancelledError = class extends Error {};
+async function runCreateCli(args = process.argv.slice(2), services = {}) {
+	const log = services.log ?? console.log;
+	const warn = services.warn ?? console.error;
+	try {
+		const parsed = parseArgs(args);
+		if (parsed.showHelp) {
+			log(createHelpText());
+			return 0;
+		}
+		if (parsed.showVersion) {
+			log(await readCreatorVersion());
+			return 0;
+		}
+		const options = services.interactive ?? (stdin.isTTY && stdout.isTTY) ? await promptForOptions(parsed) : nonInteractiveOptions(parsed);
+		printResult(await (services.create ?? createProject)({
+			displayName: options.displayName,
+			install: options.install,
+			packageId: options.packageId,
+			targetDirectory: options.targetDirectory
+		}), log);
+		return 0;
+	} catch (error) {
+		if (error instanceof PromptCancelledError) return 0;
+		warn(error instanceof Error ? error.message : String(error));
+		return 1;
+	}
+}
+function createHelpText() {
+	return `Create an Android-first Jilatax application.
+
+Usage:
+  create-jilatax [directory] [options]
+
+Options:
+  --name <display-name>   Human-readable application name
+  --package-id <id>       Android application ID
+  --install               Install dependencies with Bun
+  --skip-install          Generate without installing dependencies
+  -h, --help              Show this help
+  -V, --version           Show the installed creator version`;
+}
+function parseArgs(args) {
+	let displayName;
+	let install;
+	let packageId;
+	let showHelp = false;
+	let showVersion = false;
+	let targetDirectory;
+	for (let index = 0; index < args.length; index += 1) {
+		const argument = args[index];
+		if (argument === void 0) continue;
+		if (argument === "--install") install = true;
+		else if (argument === "--skip-install" || argument === "--no-install") install = false;
+		else if (argument === "--name") {
+			displayName = readOptionValue(args, index, argument);
+			index += 1;
+		} else if (argument.startsWith("--name=")) displayName = readInlineValue(argument, "--name");
+		else if (argument === "--package-id") {
+			packageId = readOptionValue(args, index, argument);
+			index += 1;
+		} else if (argument.startsWith("--package-id=")) packageId = readInlineValue(argument, "--package-id");
+		else if (argument === "--help" || argument === "-h") showHelp = true;
+		else if (argument === "--version" || argument === "-V") showVersion = true;
+		else if (argument.startsWith("-")) throw new Error(`Unknown option: ${argument}`);
+		else if (targetDirectory === void 0) targetDirectory = argument;
+		else throw new Error(`Unexpected argument: ${argument}`);
+	}
+	return {
+		...displayName === void 0 ? {} : { displayName },
+		...install === void 0 ? {} : { install },
+		...packageId === void 0 ? {} : { packageId },
+		showHelp,
+		showVersion,
+		...targetDirectory === void 0 ? {} : { targetDirectory }
+	};
+}
+async function promptForOptions(options) {
+	prompts.intro("Jilatax · Android-first Lynx application");
+	const targetDirectory = options.targetDirectory ?? unwrapPrompt(await prompts.text({
+		message: "Where should the project be created?",
+		placeholder: "./my-jilatax-app",
+		validate(value) {
+			try {
+				normalizeProjectNameFromDirectory(value ?? "");
+			} catch (error) {
+				return validationMessage(error);
+			}
+		}
+	}));
+	const projectName = normalizeProjectNameFromDirectory(targetDirectory);
+	const displayName = options.displayName ?? unwrapPrompt(await prompts.text({
+		initialValue: titleCase(projectName),
+		message: "Application name",
+		validate(value) {
+			try {
+				normalizeDisplayName(value ?? "");
+			} catch (error) {
+				return validationMessage(error);
+			}
+		}
+	}));
+	const packageId = options.packageId ?? unwrapPrompt(await prompts.text({
+		initialValue: defaultPackageId(projectName),
+		message: "Android application ID",
+		validate(value) {
+			try {
+				validatePackageId(value ?? "");
+			} catch (error) {
+				return validationMessage(error);
+			}
+		}
+	}));
+	const install = options.install ?? unwrapPrompt(await prompts.confirm({
+		initialValue: true,
+		message: "Install dependencies with Bun?"
+	}));
+	return {
+		displayName: normalizeDisplayName(displayName),
+		install,
+		packageId: validatePackageId(packageId),
+		targetDirectory
+	};
+}
+function nonInteractiveOptions(options) {
+	if (options.targetDirectory === void 0) throw new Error("Project directory is required in a non-interactive terminal.");
+	const projectName = normalizeProjectNameFromDirectory(options.targetDirectory);
+	return {
+		displayName: normalizeDisplayName(options.displayName ?? titleCase(projectName)),
+		install: options.install ?? false,
+		packageId: validatePackageId(options.packageId ?? defaultPackageId(projectName)),
+		targetDirectory: options.targetDirectory
+	};
+}
+function normalizeProjectNameFromDirectory(directory) {
+	return normalizeProjectName(directory.trim().replace(/[\\/]+$/gu, "").split(/[\\/]/u).at(-1) ?? "");
+}
+function unwrapPrompt(value) {
+	if (prompts.isCancel(value)) {
+		prompts.cancel("Project creation cancelled.");
+		throw new PromptCancelledError();
+	}
+	return value;
+}
+function validationMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function readOptionValue(args, index, option) {
+	const value = args[index + 1];
+	if (value === void 0 || value.startsWith("-") || value.trim().length === 0) throw new Error(`${option} requires a value.`);
+	return value.trim();
+}
+function readInlineValue(argument, option) {
+	const value = argument.slice(`${option}=`.length).trim();
+	if (value.length === 0) throw new Error(`${option} requires a value.`);
+	return value;
+}
+function titleCase(value) {
+	return value.split(/[-_.\s]+/u).filter(Boolean).map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`).join(" ");
+}
+function printResult(result, log) {
+	const installStep = result.installed ? "" : "  bun install\n";
+	log(`Created ${result.displayName} in ${result.projectDirectory}.
+
+Next steps:
+  cd ${JSON.stringify(result.projectDirectory)}
+${installStep}  bun run run:android
+
+Release bundle:
+  bun run create:aab`);
+}
+async function readCreatorVersion() {
+	const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf8"));
+	return typeof packageJson.version === "string" ? packageJson.version : "unknown";
+}
+//#endregion
+export { normalizeDisplayName as a, defaultPackageId as i, runCreateCli as n, normalizeProjectName as o, createProject as r, validatePackageId as s, createHelpText as t };