@teardown/cli 1.2.38 → 2.0.41

package/src/index.ts

@@ -0,0 +1,177 @@
+/**
+ * Teardown Launchpad
+ *
+ * A React Native Prebuild System Independent of Expo
+ *
+ * @packageDocumentation
+ */
+
+// CLI
+export { createProgram, run } from "./cli";
+export type {
+	AndroidConfig,
+	BuildConfig,
+	ConfigLoadResult,
+	DryRunResult,
+	FileChange,
+	iOSConfig,
+	PermissionConfig,
+	PermissionMapping,
+	PermissionStatus,
+	PluginEntry,
+	PrebuildError,
+	PrebuildOptions,
+	PrebuildWarning,
+	ProcessedAppConfig,
+	SplashConfig,
+	TeardownConfig,
+	TemplateContext,
+} from "./config";
+// Configuration
+export {
+	AndroidConfigSchema,
+	defineConfig,
+	findConfigFile,
+	generateDefaultConfig,
+	iOSConfigSchema,
+	loadConfig,
+	TeardownConfigSchema,
+	validateConfig,
+	watchConfig,
+} from "./config";
+export type { CacheEntry, PipelineResult, PipelineStage } from "./pipeline";
+// Pipeline
+export { createPipeline, IncrementalBuildCache, Pipeline } from "./pipeline";
+export type {
+	AndroidManifest,
+	CycleInfo,
+	Entitlements,
+	InfoPlist,
+	PluginConstructor,
+	PluginContext,
+} from "./plugins";
+// Plugins
+export {
+	BasePlugin,
+	createPluginContext,
+	DependencyResolver,
+	PluginResolutionError,
+} from "./plugins";
+export type {
+	BiometricsPluginConfig,
+	BluetoothPluginConfig,
+	CalendarPluginConfig,
+	CameraPluginConfig,
+	ContactsPluginConfig,
+	DeepLinkingPluginConfig,
+	FirebasePluginConfig,
+	LocationPluginConfig,
+	PhotoLibraryPluginConfig,
+	PushNotificationsPluginConfig,
+	SignInWithApplePluginConfig,
+} from "./plugins/capabilities";
+// Capability Plugins
+export {
+	BiometricsPlugin,
+	BluetoothPlugin,
+	CalendarPlugin,
+	CameraPlugin,
+	CapabilityPlugins,
+	ContactsPlugin,
+	DeepLinkingPlugin,
+	FirebasePlugin,
+	getPluginByName,
+	LocationPlugin,
+	PhotoLibraryPlugin,
+	PushNotificationsPlugin,
+	SignInWithApplePlugin,
+} from "./plugins/capabilities";
+export type {
+	AndroidManifestXml,
+	BuildSettings,
+	EntitlementsContent,
+	InfoPlistContent,
+} from "./transformers";
+// Transformers
+export {
+	AndroidManifestTransformer,
+	EntitlementsTransformer,
+	GradleTransformer,
+	PbxprojTransformer,
+	PlistTransformer,
+	StringsTransformer,
+} from "./transformers";
+export type { Logger, LogLevel, VirtualFileSystem } from "./utils";
+// Utilities
+export {
+	createLogger,
+	createVirtualFileSystem,
+	defaultLogger,
+	formatBytes,
+	formatDuration,
+	formatKeyValue,
+	formatList,
+} from "./utils";
+
+// Import types needed for prebuild function
+import type { PrebuildOptions } from "./config/types";
+import type { PipelineResult } from "./pipeline";
+import type { BasePlugin } from "./plugins/base";
+
+/**
+ * Prebuild the native projects
+ *
+ * This is the main entry point for programmatic usage.
+ *
+ * @example
+ * ```typescript
+ * import { prebuild } from '@teardown/cli';
+ *
+ * await prebuild({
+ *   platform: 'all',
+ *   projectRoot: process.cwd(),
+ * });
+ * ```
+ */
+export async function prebuild(options: PrebuildOptions): Promise<PipelineResult> {
+	const { createPipeline } = await import("./pipeline");
+	const { loadConfig } = await import("./config");
+	const { getPluginByName } = await import("./plugins/capabilities");
+
+	const projectRoot = options.projectRoot ?? process.cwd();
+	const configResult = await loadConfig(projectRoot);
+
+	if (!configResult.success || !configResult.config) {
+		return {
+			success: false,
+			warnings: [],
+			errors: configResult.errors?.map((e) => ({
+				code: "CONFIG_ERROR",
+				message: e.message,
+			})) ?? [{ code: "CONFIG_ERROR", message: "Failed to load configuration" }],
+			duration: 0,
+		};
+	}
+
+	const pipeline = createPipeline();
+
+	// Register plugins from configuration
+	const plugins = configResult.config.plugins ?? [];
+	for (const pluginEntry of plugins) {
+		if (typeof pluginEntry === "string") {
+			const PluginClass = getPluginByName(pluginEntry);
+			if (PluginClass) {
+				const plugin = new (PluginClass as new () => BasePlugin)();
+				pipeline.registerPlugin(plugin);
+			}
+		} else if (Array.isArray(pluginEntry)) {
+			const [PluginClass, pluginConfig] = pluginEntry;
+			if (typeof PluginClass === "function") {
+				const plugin = new PluginClass();
+				pipeline.registerPlugin(plugin, pluginConfig);
+			}
+		}
+	}
+
+	return pipeline.execute(options);
+}

package/src/pipeline/cache.ts

@@ -0,0 +1,179 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { TeardownConfig } from "../config/types";
+import type { Logger } from "../utils/logger";
+
+/**
+ * Cache entry stored on disk
+ */
+export interface CacheEntry {
+	/** Hash of the configuration */
+	configHash: string;
+
+	/** Timestamp of the last build */
+	timestamp: number;
+
+	/** List of generated file paths */
+	outputs: string[];
+
+	/** Hash of plugin configurations */
+	pluginsHash: string;
+}
+
+/**
+ * Cache directory name
+ */
+const CACHE_DIR = ".teardown";
+const CACHE_FILE = "prebuild-cache.json";
+
+/**
+ * Incremental build cache manager
+ *
+ * Tracks configuration changes to avoid unnecessary rebuilds
+ */
+export class IncrementalBuildCache {
+	private logger: Logger;
+
+	constructor(logger: Logger) {
+		this.logger = logger;
+	}
+
+	/**
+	 * Get the cache directory path
+	 */
+	private getCacheDir(projectRoot: string): string {
+		return path.join(projectRoot, CACHE_DIR);
+	}
+
+	/**
+	 * Get the cache file path
+	 */
+	private getCachePath(projectRoot: string): string {
+		return path.join(this.getCacheDir(projectRoot), CACHE_FILE);
+	}
+
+	/**
+	 * Load the cache entry from disk
+	 */
+	private async loadCache(projectRoot: string): Promise<CacheEntry | null> {
+		const cachePath = this.getCachePath(projectRoot);
+
+		try {
+			const content = await fs.promises.readFile(cachePath, "utf-8");
+			return JSON.parse(content) as CacheEntry;
+		} catch {
+			return null;
+		}
+	}
+
+	/**
+	 * Save the cache entry to disk
+	 */
+	private async saveCache(projectRoot: string, entry: CacheEntry): Promise<void> {
+		const cacheDir = this.getCacheDir(projectRoot);
+		const cachePath = this.getCachePath(projectRoot);
+
+		await fs.promises.mkdir(cacheDir, { recursive: true });
+		await fs.promises.writeFile(cachePath, JSON.stringify(entry, null, 2), "utf-8");
+	}
+
+	/**
+	 * Compute a hash of the configuration
+	 */
+	private computeConfigHash(config: TeardownConfig): string {
+		const content = JSON.stringify(config, null, 0);
+		return crypto.createHash("sha256").update(content).digest("hex").substring(0, 16);
+	}
+
+	/**
+	 * Check if the prebuild can be skipped (no changes detected)
+	 */
+	async shouldSkip(config: TeardownConfig, projectRoot: string): Promise<boolean> {
+		const cached = await this.loadCache(projectRoot);
+
+		if (!cached) {
+			this.logger.debug("No cache found, full rebuild required");
+			return false;
+		}
+
+		const currentHash = this.computeConfigHash(config);
+
+		if (cached.configHash !== currentHash) {
+			this.logger.debug("Configuration changed, rebuild required");
+			return false;
+		}
+
+		// Verify all cached outputs still exist
+		for (const output of cached.outputs) {
+			try {
+				await fs.promises.access(output);
+			} catch {
+				this.logger.debug(`Output file missing: ${output}, rebuild required`);
+				return false;
+			}
+		}
+
+		this.logger.debug("Cache valid, prebuild can be skipped");
+		return true;
+	}
+
+	/**
+	 * Update the cache after a successful build
+	 */
+	async update(config: TeardownConfig, projectRoot: string, outputs: string[]): Promise<void> {
+		const entry: CacheEntry = {
+			configHash: this.computeConfigHash(config),
+			timestamp: Date.now(),
+			outputs,
+			pluginsHash: this.computePluginsHash(config),
+		};
+
+		await this.saveCache(projectRoot, entry);
+		this.logger.debug("Build cache updated");
+	}
+
+	/**
+	 * Compute hash of plugin configurations
+	 */
+	private computePluginsHash(config: TeardownConfig): string {
+		const plugins = config.plugins || [];
+		const content = JSON.stringify(plugins, null, 0);
+		return crypto.createHash("sha256").update(content).digest("hex").substring(0, 16);
+	}
+
+	/**
+	 * Clear the cache
+	 */
+	async clear(projectRoot: string): Promise<void> {
+		const cacheDir = this.getCacheDir(projectRoot);
+
+		try {
+			await fs.promises.rm(cacheDir, { recursive: true, force: true });
+			this.logger.debug("Build cache cleared");
+		} catch {
+			// Cache dir might not exist
+		}
+	}
+
+	/**
+	 * Get cache statistics
+	 */
+	async getStats(projectRoot: string): Promise<{
+		exists: boolean;
+		lastBuild?: Date;
+		outputCount?: number;
+	}> {
+		const cached = await this.loadCache(projectRoot);
+
+		if (!cached) {
+			return { exists: false };
+		}
+
+		return {
+			exists: true,
+			lastBuild: new Date(cached.timestamp),
+			outputCount: cached.outputs.length,
+		};
+	}
+}

package/src/pipeline/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Build pipeline for Teardown Launchpad
+ *
+ * Orchestrates the transformation of configuration into native projects
+ */
+
+export type { CacheEntry } from "./cache";
+export { IncrementalBuildCache } from "./cache";
+export type { PipelineResult, PipelineStage } from "./stages";
+export { createPipeline, Pipeline } from "./stages";