create-jilatax 0.0.3 → 0.0.4

package/README.md

@@ -1,21 +1,50 @@
 # 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
 
 ```bash
-npm i create-jilatax
+bunx create-jilatax@latest my-app
+cd my-app
+bun run run:android
 ```
 
-## Usage
+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:
 
-```ts
-import { hello } from "create-jilatax";
+```bash
+bunx create-jilatax@latest my-app \
+  --name "My App" \
+  --package-id com.example.my_app \
+  --skip-install
+```
+
+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`.
 
-hello("world");
+## Programmatic API
+
+```ts
+import { createProject } from 'create-jilatax';
+
+await createProject({
+  targetDirectory: './my-app',
+  displayName: 'My App',
+  packageId: 'com.example.my_app',
+  install: false,
+});
 ```
 
 ## Development
@@ -25,21 +54,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-BO6toXiq.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-BQK3vkvN.js";
+//#region src/bin.ts
+runCreateCli().then((exitCode) => {
+	process.exitCode = exitCode;
+});
+//#endregion
+export {};

package/dist/cli-BO6toXiq.cjs

@@ -0,0 +1,450 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _clack_prompts = require("@clack/prompts");
+_clack_prompts = __toESM(_clack_prompts, 1);
+let node_fs_promises = require("node:fs/promises");
+let node_process = require("node:process");
+let node_child_process = require("node:child_process");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_url = require("node:url");
+let jilatax = require("jilatax");
+//#region src/generator.ts
+const JILATAX_CLI_VERSION = "^0.0.7";
+const JILATAX_VERSION = "^0.0.5";
+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 = node_path.default.resolve(options.targetDirectory);
+	const projectName = normalizeProjectName(node_path.default.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 = node_path.default.dirname(projectDirectory);
+	await (0, node_fs_promises.mkdir)(parentDirectory, { recursive: true });
+	const stagingDirectory = await (0, node_fs_promises.mkdtemp)(node_path.default.join(parentDirectory, `.${projectName}-`));
+	try {
+		await renderTemplate(stagingDirectory, {
+			displayName,
+			projectName
+		});
+		await writeGeneratedMetadata(stagingDirectory, config, projectName);
+		await (0, node_fs_promises.rename)(stagingDirectory, projectDirectory);
+	} catch (error) {
+		await (0, node_fs_promises.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();
+	(0, jilatax.parseAppConfig)({ jilatax: {
+		android: { package: packageId },
+		name: "Package validation"
+	} });
+	return packageId;
+}
+async function renderTemplate(targetRoot, values) {
+	await copyTemplateDirectory((0, node_url.fileURLToPath)(new URL("../template", require("url").pathToFileURL(__filename).href)), targetRoot, "", values);
+}
+async function copyTemplateDirectory(templateRoot, targetRoot, relativeDirectory, values) {
+	const entries = await (0, node_fs_promises.readdir)(node_path.default.join(templateRoot, relativeDirectory), { withFileTypes: true });
+	for (const entry of entries) {
+		const relativeSource = node_path.default.join(relativeDirectory, entry.name);
+		const normalizedSource = relativeSource.split(node_path.default.sep).join("/");
+		const sourcePath = node_path.default.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 = node_path.default.join(targetRoot, ...outputRelative.split("/"));
+		await (0, node_fs_promises.mkdir)(node_path.default.dirname(outputPath), { recursive: true });
+		if (normalizedSource.endsWith("gradle-wrapper.jar.base64")) {
+			const encoded = (await (0, node_fs_promises.readFile)(sourcePath, "utf8")).replace(/\s+/gu, "");
+			await (0, node_fs_promises.writeFile)(outputPath, Buffer.from(encoded, "base64"));
+			continue;
+		}
+		if (TEXT_TEMPLATE_FILES.has(normalizedSource)) {
+			await (0, node_fs_promises.writeFile)(outputPath, renderTextTemplate(await (0, node_fs_promises.readFile)(sourcePath, "utf8"), values), "utf8");
+			continue;
+		}
+		if (normalizedSource.endsWith(".tmpl")) throw new Error(`Unregistered text template: ${normalizedSource}`);
+		await (0, node_fs_promises.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/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 (0, node_fs_promises.writeFile)(node_path.default.join(projectRoot, "package.json"), `${JSON.stringify(packageJson, null, 2)}\n`, "utf8");
+	await (0, node_fs_promises.writeFile)(node_path.default.join(projectRoot, "app.json"), `${JSON.stringify(config, null, 2)}\n`, "utf8");
+	await (0, node_fs_promises.writeFile)(node_path.default.join(projectRoot, "android", "jilatax.properties"), (0, jilatax.serializeAndroidProjectConfig)(config), "utf8");
+	if (process.platform !== "win32") await (0, node_fs_promises.chmod)(node_path.default.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 (0, jilatax.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 (0, node_fs_promises.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 = (0, node_child_process.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 ?? (node_process.stdin.isTTY && node_process.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) {
+	_clack_prompts.intro("Jilatax · Android-first Lynx application");
+	const targetDirectory = options.targetDirectory ?? unwrapPrompt(await _clack_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 _clack_prompts.text({
+		initialValue: titleCase(projectName),
+		message: "Application name",
+		validate(value) {
+			try {
+				normalizeDisplayName(value ?? "");
+			} catch (error) {
+				return validationMessage(error);
+			}
+		}
+	}));
+	const packageId = options.packageId ?? unwrapPrompt(await _clack_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 _clack_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 (_clack_prompts.isCancel(value)) {
+		_clack_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 (0, node_fs_promises.readFile)(new URL("../package.json", require("url").pathToFileURL(__filename).href), "utf8"));
+	return typeof packageJson.version === "string" ? packageJson.version : "unknown";
+}
+//#endregion
+Object.defineProperty(exports, "createHelpText", {
+	enumerable: true,
+	get: function() {
+		return createHelpText;
+	}
+});
+Object.defineProperty(exports, "createProject", {
+	enumerable: true,
+	get: function() {
+		return createProject;
+	}
+});
+Object.defineProperty(exports, "defaultPackageId", {
+	enumerable: true,
+	get: function() {
+		return defaultPackageId;
+	}
+});
+Object.defineProperty(exports, "normalizeDisplayName", {
+	enumerable: true,
+	get: function() {
+		return normalizeDisplayName;
+	}
+});
+Object.defineProperty(exports, "normalizeProjectName", {
+	enumerable: true,
+	get: function() {
+		return normalizeProjectName;
+	}
+});
+Object.defineProperty(exports, "runCreateCli", {
+	enumerable: true,
+	get: function() {
+		return runCreateCli;
+	}
+});
+Object.defineProperty(exports, "validatePackageId", {
+	enumerable: true,
+	get: function() {
+		return validatePackageId;
+	}
+});