@teardown/cli 1.2.39 → 2.0.41

package/src/templates/generator.ts

@@ -0,0 +1,507 @@
+/**
+ * Template Generator
+ *
+ * Handles copying and processing template files for iOS and Android projects.
+ * Uses EJS for template processing and handles dynamic file/folder renaming.
+ */
+
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import ejs from "ejs";
+import type { VirtualFileSystem } from "../utils/fs";
+import type { Logger } from "../utils/logger";
+import { getTemplatePath, getTemplatesPath } from "./paths";
+
+/**
+ * Template variables for EJS processing
+ */
+export interface TemplateVariables {
+	// Common variables
+	slug: string;
+
+	// iOS variables
+	appName: string;
+	bundleIdentifier: string;
+	version: string;
+	buildNumber: number;
+
+	// Android variables
+	packageName: string;
+	versionCode: number;
+	versionName: string;
+
+	// CLI version (for package.json template)
+	cliVersion?: string;
+}
+
+/**
+ * Template generation options
+ */
+export interface TemplateOptions {
+	projectRoot: string;
+	variables: TemplateVariables;
+	logger?: Logger;
+	fs?: VirtualFileSystem;
+	dryRun?: boolean;
+	force?: boolean; // Overwrite existing files
+}
+
+/**
+ * Result of template generation
+ */
+export interface TemplateResult {
+	success: boolean;
+	filesCreated: string[];
+	filesSkipped: string[];
+	errors: string[];
+}
+
+/**
+ * Template Generator class
+ */
+export class TemplateGenerator {
+	private options: TemplateOptions;
+	private logger?: Logger;
+
+	constructor(options: TemplateOptions) {
+		this.options = options;
+		this.logger = options.logger;
+	}
+
+	/**
+	 * Generate iOS project from templates
+	 */
+	async generateiOS(): Promise<TemplateResult> {
+		const templatePath = getTemplatePath("ios");
+		const outputPath = join(this.options.projectRoot, "ios");
+
+		this.logger?.info("Generating iOS project from template...");
+
+		return this.processTemplateDirectory(templatePath, outputPath, "ios");
+	}
+
+	/**
+	 * Generate Android project from templates
+	 */
+	async generateAndroid(): Promise<TemplateResult> {
+		const templatePath = getTemplatePath("android");
+		const outputPath = join(this.options.projectRoot, "android");
+
+		this.logger?.info("Generating Android project from template...");
+
+		return this.processTemplateDirectory(templatePath, outputPath, "android");
+	}
+
+	/**
+	 * Generate both iOS and Android projects
+	 */
+	async generateAll(): Promise<{ ios: TemplateResult; android: TemplateResult }> {
+		const ios = await this.generateiOS();
+		const android = await this.generateAndroid();
+		return { ios, android };
+	}
+
+	/**
+	 * Check if iOS project already exists
+	 */
+	async iosProjectExists(): Promise<boolean> {
+		const xcodeProjectPath = join(this.options.projectRoot, "ios", `${this.options.variables.appName}.xcodeproj`);
+		try {
+			await stat(xcodeProjectPath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	/**
+	 * Check if Android project already exists
+	 */
+	async androidProjectExists(): Promise<boolean> {
+		const manifestPath = join(this.options.projectRoot, "android", "app", "src", "main", "AndroidManifest.xml");
+		try {
+			await stat(manifestPath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	/**
+	 * Check if package.json exists
+	 */
+	async packageJsonExists(): Promise<boolean> {
+		const packagePath = join(this.options.projectRoot, "package.json");
+		try {
+			await stat(packagePath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	/**
+	 * Check if src folder exists
+	 */
+	async srcFolderExists(): Promise<boolean> {
+		const srcPath = join(this.options.projectRoot, "src", "index.ts");
+		try {
+			await stat(srcPath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	/**
+	 * Generate src folder from template
+	 */
+	async generateSrcFolder(): Promise<TemplateResult> {
+		const templatePath = join(getTemplatesPath(), "src");
+		const outputPath = join(this.options.projectRoot, "src");
+
+		this.logger?.info("Generating src folder from template...");
+
+		return this.processTemplateDirectory(templatePath, outputPath, "ios"); // Use ios as platform for EJS processing
+	}
+
+	/**
+	 * Generate root config files (tsconfig.json, babel.config.js, metro.config.js, index.js)
+	 */
+	async generateRootConfigFiles(): Promise<TemplateResult> {
+		const result: TemplateResult = {
+			success: true,
+			filesCreated: [],
+			filesSkipped: [],
+			errors: [],
+		};
+
+		const configFiles = [
+			"tsconfig.json",
+			"babel.config.js",
+			"metro.config.js",
+			"index.js",
+			"react-native.config.js",
+			"Gemfile",
+		];
+
+		for (const file of configFiles) {
+			const templatePath = join(getTemplatesPath(), file);
+			const outputPath = join(this.options.projectRoot, file);
+
+			try {
+				// Check if template file exists
+				try {
+					await stat(templatePath);
+				} catch {
+					// Template doesn't exist, skip
+					continue;
+				}
+
+				// Check if output file already exists
+				if (!this.options.force) {
+					try {
+						await stat(outputPath);
+						result.filesSkipped.push(outputPath);
+						this.logger?.debug(`${file} already exists, skipping`);
+						continue;
+					} catch {
+						// File doesn't exist, continue
+					}
+				}
+
+				const content = await readFile(templatePath, "utf-8");
+				let processedContent = content;
+
+				// Process EJS if the file contains EJS tags
+				if (content.includes("<%=") || content.includes("<%")) {
+					processedContent = ejs.render(content, this.options.variables, {
+						filename: templatePath,
+					});
+				}
+
+				if (!this.options.dryRun) {
+					await writeFile(outputPath, processedContent, "utf-8");
+				}
+
+				result.filesCreated.push(outputPath);
+				this.logger?.debug(`Created: ${outputPath}`);
+			} catch (error) {
+				result.errors.push(`Failed to generate ${file}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+
+		if (result.errors.length > 0) {
+			result.success = false;
+		}
+
+		return result;
+	}
+
+	/**
+	 * Generate .gitignore from template
+	 */
+	async generateGitignore(): Promise<TemplateResult> {
+		const result: TemplateResult = {
+			success: true,
+			filesCreated: [],
+			filesSkipped: [],
+			errors: [],
+		};
+
+		const templatePath = join(getTemplatesPath(), ".gitignore");
+		const outputPath = join(this.options.projectRoot, ".gitignore");
+
+		try {
+			// Check if .gitignore already exists
+			if (!this.options.force) {
+				try {
+					await stat(outputPath);
+					result.filesSkipped.push(outputPath);
+					this.logger?.debug(".gitignore already exists, skipping");
+					return result;
+				} catch {
+					// File doesn't exist, continue
+				}
+			}
+
+			const content = await readFile(templatePath, "utf-8");
+
+			if (!this.options.dryRun) {
+				await writeFile(outputPath, content, "utf-8");
+			}
+
+			result.filesCreated.push(outputPath);
+			this.logger?.debug(`Created: ${outputPath}`);
+		} catch (error) {
+			result.success = false;
+			result.errors.push(`Failed to generate .gitignore: ${error instanceof Error ? error.message : String(error)}`);
+		}
+
+		return result;
+	}
+
+	/**
+	 * Generate package.json from template
+	 */
+	async generatePackageJson(): Promise<TemplateResult> {
+		const result: TemplateResult = {
+			success: true,
+			filesCreated: [],
+			filesSkipped: [],
+			errors: [],
+		};
+
+		const templatePath = join(getTemplatesPath(), "package.json");
+		const outputPath = join(this.options.projectRoot, "package.json");
+
+		try {
+			// Check if package.json already exists
+			if (!this.options.force) {
+				try {
+					await stat(outputPath);
+					result.filesSkipped.push(outputPath);
+					this.logger?.debug("package.json already exists, skipping");
+					return result;
+				} catch {
+					// File doesn't exist, continue
+				}
+			}
+
+			const content = await readFile(templatePath, "utf-8");
+			const processedContent = ejs.render(content, this.options.variables, {
+				filename: templatePath,
+			});
+
+			if (!this.options.dryRun) {
+				await writeFile(outputPath, processedContent, "utf-8");
+			}
+
+			result.filesCreated.push(outputPath);
+			this.logger?.debug(`Created: ${outputPath}`);
+		} catch (error) {
+			result.success = false;
+			result.errors.push(`Failed to generate package.json: ${error instanceof Error ? error.message : String(error)}`);
+		}
+
+		return result;
+	}
+
+	/**
+	 * Process a template directory recursively
+	 */
+	private async processTemplateDirectory(
+		templateDir: string,
+		outputDir: string,
+		platform: "ios" | "android"
+	): Promise<TemplateResult> {
+		const result: TemplateResult = {
+			success: true,
+			filesCreated: [],
+			filesSkipped: [],
+			errors: [],
+		};
+
+		try {
+			await this.processDirectory(templateDir, outputDir, platform, result);
+		} catch (error) {
+			result.success = false;
+			result.errors.push(error instanceof Error ? error.message : String(error));
+		}
+
+		return result;
+	}
+
+	/**
+	 * Recursively process a directory
+	 */
+	private async processDirectory(
+		srcDir: string,
+		destDir: string,
+		platform: "ios" | "android",
+		result: TemplateResult
+	): Promise<void> {
+		const entries = await readdir(srcDir, { withFileTypes: true });
+
+		// Create destination directory
+		if (!this.options.dryRun) {
+			await mkdir(destDir, { recursive: true });
+		}
+
+		for (const entry of entries) {
+			const srcPath = join(srcDir, entry.name);
+
+			// Special handling for Android java source directories
+			// When we encounter "com/appname", we need to replace it with the actual package path
+			if (platform === "android" && entry.name === "com" && entry.isDirectory()) {
+				// Check if this is the com/appname directory in the template
+				const appnamePath = join(srcPath, "appname");
+				try {
+					const appnameStat = await stat(appnamePath);
+					if (appnameStat.isDirectory()) {
+						// Replace com/appname with the actual package path
+						const packagePath = this.options.variables.packageName.replace(/\./g, "/");
+						const newDestDir = join(destDir, packagePath);
+
+						// Process files in com/appname and put them in the correct package directory
+						await this.processDirectory(appnamePath, newDestDir, platform, result);
+						continue;
+					}
+				} catch {
+					// com/appname doesn't exist, process normally
+				}
+			}
+
+			const destName = this.replaceTemplateNames(entry.name, platform);
+			const destPath = join(destDir, destName);
+
+			if (entry.isDirectory()) {
+				await this.processDirectory(srcPath, destPath, platform, result);
+			} else {
+				await this.processFile(srcPath, destPath, platform, result);
+			}
+		}
+	}
+
+	/**
+	 * Process a single template file
+	 */
+	private async processFile(
+		srcPath: string,
+		destPath: string,
+		platform: "ios" | "android",
+		result: TemplateResult
+	): Promise<void> {
+		// Check if destination exists
+		if (!this.options.force) {
+			try {
+				await stat(destPath);
+				result.filesSkipped.push(destPath);
+				this.logger?.debug(`Skipping existing file: ${destPath}`);
+				return;
+			} catch {
+				// File doesn't exist, continue
+			}
+		}
+
+		try {
+			const content = await readFile(srcPath, "utf-8");
+			let processedContent: string;
+
+			// Check if file needs EJS processing (contains <%= or <% tags)
+			if (this.shouldProcessAsTemplate(content)) {
+				processedContent = ejs.render(content, this.options.variables, {
+					filename: srcPath,
+				});
+			} else {
+				processedContent = content;
+			}
+
+			// Replace template names in content as well (for things like package names in paths)
+			processedContent = this.replaceTemplateNamesInContent(processedContent, platform);
+
+			if (!this.options.dryRun) {
+				// Ensure directory exists
+				await mkdir(dirname(destPath), { recursive: true });
+
+				// Write file
+				await writeFile(destPath, processedContent, "utf-8");
+			}
+
+			result.filesCreated.push(destPath);
+			this.logger?.debug(`Created: ${destPath}`);
+		} catch (error) {
+			const errorMessage = `Failed to process ${srcPath}: ${error instanceof Error ? error.message : String(error)}`;
+			result.errors.push(errorMessage);
+			this.logger?.error(errorMessage);
+		}
+	}
+
+	/**
+	 * Check if a file should be processed as an EJS template
+	 */
+	private shouldProcessAsTemplate(content: string): boolean {
+		return content.includes("<%=") || content.includes("<%");
+	}
+
+	/**
+	 * Replace template placeholder names in file/folder names
+	 */
+	private replaceTemplateNames(name: string, platform: "ios" | "android"): string {
+		const { appName, packageName } = this.options.variables;
+
+		let result = name;
+
+		// iOS replacements
+		if (platform === "ios") {
+			result = result.replace(/AppName/g, appName);
+		}
+
+		// Android replacements
+		if (platform === "android") {
+			// Replace com/appname path structure with actual package path
+			if (name === "appname" || result.includes("appname")) {
+				const packagePath = packageName.replace(/\./g, "/");
+				result = result.replace(/com\/appname/g, packagePath);
+				result = result.replace(/appname/g, packagePath.split("/").pop() || appName.toLowerCase());
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Replace template names in file content
+	 */
+	private replaceTemplateNamesInContent(content: string, _platform: "ios" | "android"): string {
+		// These are already handled by EJS, but this catches any remaining placeholders
+		return content;
+	}
+}
+
+/**
+ * Create a template generator instance
+ */
+export function createTemplateGenerator(options: TemplateOptions): TemplateGenerator {
+	return new TemplateGenerator(options);
+}

package/src/templates/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Template generation system for React Native projects
+ *
+ * Similar to Expo's approach, this module handles copying base templates
+ * and processing EJS variables to generate native iOS and Android projects.
+ */
+
+export { TemplateGenerator, type TemplateOptions, type TemplateVariables } from "./generator";
+export { getTemplatePath, getTemplatesPath } from "./paths";

package/src/templates/paths.ts

@@ -0,0 +1,25 @@
+/**
+ * Template path utilities
+ */
+
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/**
+ * Get the absolute path to the templates directory
+ */
+export function getTemplatesPath(): string {
+	// Get the directory of this file
+	const __filename = fileURLToPath(import.meta.url);
+	const __dirname = dirname(__filename);
+
+	// Templates are in ../../templates relative to this file (src/templates/paths.ts)
+	return join(__dirname, "..", "..", "templates");
+}
+
+/**
+ * Get the path to a specific template
+ */
+export function getTemplatePath(platform: "ios" | "android"): string {
+	return join(getTemplatesPath(), platform);
+}