create-jilatax 0.0.2 → 0.0.4

package/dist/cli-BQK3vkvN.js

@@ -0,0 +1,385 @@
+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.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 = 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/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 };

package/dist/index.cjs

@@ -1,7 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/index.ts
-function hello(name) {
-	return `Hello, ${name}!`;
-}
-//#endregion
-exports.hello = hello;
+const require_cli = require("./cli-BO6toXiq.cjs");
+exports.createHelpText = require_cli.createHelpText;
+exports.createProject = require_cli.createProject;
+exports.defaultPackageId = require_cli.defaultPackageId;
+exports.normalizeDisplayName = require_cli.normalizeDisplayName;
+exports.normalizeProjectName = require_cli.normalizeProjectName;
+exports.runCreateCli = require_cli.runCreateCli;
+exports.validatePackageId = require_cli.validatePackageId;

package/dist/index.d.cts

@@ -1,4 +1,33 @@
-//#region src/index.d.ts
-declare function hello(name: string): string;
+//#region src/generator.d.ts
+interface CreateProjectOptions {
+  readonly displayName?: string;
+  readonly install?: boolean;
+  readonly installer?: ProjectInstaller;
+  readonly packageId?: string;
+  readonly targetDirectory: string;
+}
+interface CreateProjectResult {
+  readonly displayName: string;
+  readonly installed: boolean;
+  readonly packageId: string;
+  readonly projectDirectory: string;
+  readonly projectName: string;
+}
+type ProjectInstaller = (projectDirectory: string) => Promise<void>;
+declare function createProject(options: CreateProjectOptions): Promise<CreateProjectResult>;
+declare function normalizeProjectName(value: string): string;
+declare function normalizeDisplayName(value: string): string;
+declare function defaultPackageId(projectName: string): string;
+declare function validatePackageId(value: string): string;
 //#endregion
-export { hello };
+//#region src/cli.d.ts
+interface CreateCliServices {
+  readonly create?: typeof createProject;
+  readonly interactive?: boolean;
+  readonly log?: (message: string) => void;
+  readonly warn?: (message: string) => void;
+}
+declare function runCreateCli(args?: readonly string[], services?: CreateCliServices): Promise<number>;
+declare function createHelpText(): string;
+//#endregion
+export { type CreateCliServices, type CreateProjectOptions, type CreateProjectResult, type ProjectInstaller, createHelpText, createProject, defaultPackageId, normalizeDisplayName, normalizeProjectName, runCreateCli, validatePackageId };

package/dist/index.d.ts

@@ -1,4 +1,33 @@
-//#region src/index.d.ts
-declare function hello(name: string): string;
+//#region src/generator.d.ts
+interface CreateProjectOptions {
+  readonly displayName?: string;
+  readonly install?: boolean;
+  readonly installer?: ProjectInstaller;
+  readonly packageId?: string;
+  readonly targetDirectory: string;
+}
+interface CreateProjectResult {
+  readonly displayName: string;
+  readonly installed: boolean;
+  readonly packageId: string;
+  readonly projectDirectory: string;
+  readonly projectName: string;
+}
+type ProjectInstaller = (projectDirectory: string) => Promise<void>;
+declare function createProject(options: CreateProjectOptions): Promise<CreateProjectResult>;
+declare function normalizeProjectName(value: string): string;
+declare function normalizeDisplayName(value: string): string;
+declare function defaultPackageId(projectName: string): string;
+declare function validatePackageId(value: string): string;
 //#endregion
-export { hello };
+//#region src/cli.d.ts
+interface CreateCliServices {
+  readonly create?: typeof createProject;
+  readonly interactive?: boolean;
+  readonly log?: (message: string) => void;
+  readonly warn?: (message: string) => void;
+}
+declare function runCreateCli(args?: readonly string[], services?: CreateCliServices): Promise<number>;
+declare function createHelpText(): string;
+//#endregion
+export { type CreateCliServices, type CreateProjectOptions, type CreateProjectResult, type ProjectInstaller, createHelpText, createProject, defaultPackageId, normalizeDisplayName, normalizeProjectName, runCreateCli, validatePackageId };

package/dist/index.js

@@ -1,6 +1,2 @@
-//#region src/index.ts
-function hello(name) {
-	return `Hello, ${name}!`;
-}
-//#endregion
-export { hello };
+import { a as normalizeDisplayName, i as defaultPackageId, n as runCreateCli, o as normalizeProjectName, r as createProject, s as validatePackageId, t as createHelpText } from "./cli-BQK3vkvN.js";
+export { createHelpText, createProject, defaultPackageId, normalizeDisplayName, normalizeProjectName, runCreateCli, validatePackageId };

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "create-jilatax",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "packageManager": "bun@1.3.4",
-  "description": "A minimal TypeScript library package with ESM, CommonJS, and declaration outputs.",
+  "description": "Create an Android-first Jilatax application for Lynx and Rspeedy.",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "bin": {
+    "create-jilatax": "./dist/bin.js"
+  },
   "exports": {
     ".": {
       "import": {
@@ -19,10 +22,10 @@
       }
     }
   },
-  "files": ["dist"],
-  "sideEffects": false,
+  "files": ["dist", "template", "THIRD_PARTY_NOTICES.md"],
+  "sideEffects": ["./dist/bin.js"],
 
-  "keywords": ["typescript", "esm", "commonjs"],
+  "keywords": ["android", "creator", "jilatax", "lynx", "rspeedy"],
   "author": "Gohit X (bastndev)",
   "license": "MIT",
   "homepage": "https://jilatax.dev/jilatax",
@@ -40,6 +43,11 @@
     "node": ">=22.18.0"
   },
 
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "jilatax": "^0.0.5"
+  },
+
   "devDependencies": {
     "@arethetypeswrong/core": "^0.18.5",
     "@types/node": "^22.20.1",

package/template/README.md.tmpl

@@ -0,0 +1,31 @@
+# {{projectName}}
+
+Android-first Lynx application created with Jilatax.
+
+## Development
+
+```bash
+bun install
+bun run run:android
+```
+
+The Android command starts Rspeedy, builds and installs the debug APK, verifies
+the ADB reverse tunnel, and launches the app once.
+
+To run only the Lynx development server:
+
+```bash
+bun run dev
+```
+
+## Android App Bundle
+
+```bash
+bun run create:aab
+```
+
+Configure `android/keystore.properties` from the included example before a
+Play Store release. Never commit signing credentials.
+
+Application metadata lives in `app.json`. Android is the only supported native
+platform in this phase.

package/template/android/app/build.gradle.kts

@@ -0,0 +1,112 @@
+import java.util.Properties
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    id("com.android.application")
+    id("org.jetbrains.kotlin.android")
+}
+
+val jilataxConfigFile = rootProject.file("jilatax.properties")
+check(jilataxConfigFile.isFile) {
+    "Missing android/jilatax.properties. Run a Jilatax Android command from the project root."
+}
+val jilataxConfig = Properties().apply {
+    jilataxConfigFile.reader(Charsets.UTF_8).use(::load)
+}
+
+fun requiredConfig(key: String): String =
+    checkNotNull(jilataxConfig.getProperty(key)?.takeIf { it.isNotBlank() }) {
+        "Missing Jilatax Android property: $key"
+    }
+
+val appName = requiredConfig("jilatax.name")
+val appPackage = requiredConfig("jilatax.android.package")
+val appVersion = requiredConfig("jilatax.version")
+val appVersionCode = requiredConfig("jilatax.android.versionCode").toInt()
+val appScheme = requiredConfig("jilatax.scheme")
+val predictiveBack = requiredConfig(
+    "jilatax.android.predictiveBackGestureEnabled",
+).toBooleanStrict()
+val screenOrientation =
+    when (requiredConfig("jilatax.orientation")) {
+        "portrait" -> "portrait"
+        "landscape" -> "landscape"
+        else -> "unspecified"
+    }
+val splashBackground = requiredConfig("jilatax.splash.backgroundColor")
+
+val signingFile = rootProject.file("keystore.properties")
+val signingProperties = Properties()
+val signingKeys = listOf("storeFile", "storePassword", "keyAlias", "keyPassword")
+val signingConfigured = signingFile.isFile
+if (signingConfigured) {
+    signingFile.reader(Charsets.UTF_8).use(signingProperties::load)
+    check(signingKeys.all { !signingProperties.getProperty(it).isNullOrBlank() }) {
+        "android/keystore.properties exists but is incomplete."
+    }
+}
+
+android {
+    namespace = appPackage
+    compileSdk = 35
+
+    defaultConfig {
+        applicationId = appPackage
+        minSdk = 24
+        targetSdk = 35
+        versionCode = appVersionCode
+        versionName = appVersion
+        manifestPlaceholders["jilataxOrientation"] = screenOrientation
+        manifestPlaceholders["jilataxPredictiveBack"] = predictiveBack.toString()
+        manifestPlaceholders["jilataxScheme"] = appScheme
+        resValue("string", "jilatax_app_name", appName)
+        resValue("color", "jilatax_icon_background", splashBackground)
+        resValue("color", "jilatax_splash_background", splashBackground)
+    }
+
+    sourceSets {
+        getByName("main").assets.srcDir(file("../../.jilatax/android-assets"))
+    }
+
+    signingConfigs {
+        if (signingConfigured) {
+            create("release") {
+                storeFile = rootProject.file(signingProperties.getProperty("storeFile"))
+                storePassword = signingProperties.getProperty("storePassword")
+                keyAlias = signingProperties.getProperty("keyAlias")
+                keyPassword = signingProperties.getProperty("keyPassword")
+            }
+        }
+    }
+
+    buildTypes {
+        debug {
+            isDebuggable = true
+        }
+        release {
+            isMinifyEnabled = false
+            if (signingConfigured) {
+                signingConfig = signingConfigs.getByName("release")
+            }
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro",
+            )
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
+    }
+}
+
+kotlin {
+    compilerOptions {
+        jvmTarget.set(JvmTarget.JVM_11)
+    }
+}
+
+dependencies {
+    implementation(project(":jilatax"))
+}

package/template/android/app/proguard-rules.pro

@@ -0,0 +1 @@
+# Jilatax release minification is disabled during the Android foundation phase.

package/template/android/app/src/debug/AndroidManifest.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+    <application
+        android:usesCleartextTraffic="true"
+        tools:replace="android:usesCleartextTraffic" />
+</manifest>