@reuvenorg/react-native-boilerplate-ultimate/dist/utils/template-engine.js

A powerful CLI tool for creating React Native projects with modular architecture. Generate, manage, and scaffold React Native applications with pre-built modules and best practices.

import fs from 'fs-extra';
import * as path from 'path';
import { JsonProcessor } from '../processors/json-processor.js';
import { XmlProcessor } from '../processors/xml-processor.js';
import { KotlinProcessor } from '../processors/kotlin-processor.js';
import { GradleProcessor } from '../processors/gradle-processor.js';
import { XcodeProcessor } from '../processors/xcode-processor.js';
import { ScriptProcessor } from '../processors/script-processor.js';
import { GenericProcessor } from '../processors/generic-processor.js';
export class TemplateEngine {
    constructor() {
        this.processors = [
            new JsonProcessor(),
            new XmlProcessor(),
            new KotlinProcessor(),
            new GradleProcessor(),
            new XcodeProcessor(),
            new ScriptProcessor(),
            new GenericProcessor(), // fallback - must be last
        ];
    }
    async processProject(projectPath, context) {
        // Process all files
        await this.processFiles(projectPath, context);
        // Rename directories
        await this.renameDirectories(projectPath, context);
    }
    async processFiles(projectPath, context) {
        const allFiles = await this.getAllFiles(projectPath);
        // Process files in parallel for better performance
        await Promise.all(allFiles.map(async (filePath) => {
            const processor = this.findProcessor(filePath);
            if (processor) {
                try {
                    await processor.process(filePath, context);
                }
                catch (error) {
                    console.warn(`Warning: Failed to process file ${filePath}:`, error);
                }
            }
        }));
    }
    async getAllFiles(projectPath) {
        const files = [];
        const skipPatterns = [
            'node_modules',
            '.git',
            'build',
            'dist',
            '.DS_Store',
            'Thumbs.db',
        ];
        const binaryExtensions = [
            '.png', '.jpg', '.jpeg', '.gif', '.ico', '.keystore', '.jar'
        ];
        await this.walkDirectory(projectPath, projectPath, files, skipPatterns, binaryExtensions);
        return files;
    }
    async walkDirectory(currentPath, rootPath, files, skipPatterns, binaryExtensions) {
        const items = await fs.readdir(currentPath);
        for (const item of items) {
            const itemPath = path.join(currentPath, item);
            // Skip unwanted patterns
            if (skipPatterns.some(pattern => itemPath.includes(pattern))) {
                continue;
            }
            const stats = await fs.stat(itemPath);
            if (stats.isDirectory()) {
                await this.walkDirectory(itemPath, rootPath, files, skipPatterns, binaryExtensions);
            }
            else {
                // Skip binary files
                if (!binaryExtensions.some(ext => itemPath.endsWith(ext))) {
                    files.push(itemPath);
                }
            }
        }
    }
    findProcessor(filePath) {
        return this.processors.find(processor => processor.canProcess(filePath));
    }
    async renameDirectories(projectPath, context) {
        const directoriesToRename = [
            {
                from: path.join(projectPath, 'ios', 'ExApp'),
                to: path.join(projectPath, 'ios', context.projectName),
            },
            {
                from: path.join(projectPath, 'ios', 'ExApp.xcodeproj'),
                to: path.join(projectPath, 'ios', `${context.projectName}.xcodeproj`),
            },
            {
                from: path.join(projectPath, 'ios', 'ExApp.xcworkspace'),
                to: path.join(projectPath, 'ios', `${context.projectName}.xcworkspace`),
            },
            {
                from: path.join(projectPath, 'android', 'app', 'src', 'main', 'java', 'com', 'anonymous', 'exapp'),
                to: path.join(projectPath, 'android', 'app', 'src', 'main', 'java', ...context.packagePath.split('/')),
            },
        ];
        for (const { from, to } of directoriesToRename) {
            await this.renameDirectory(from, to);
        }
    }
    async renameDirectory(from, to) {
        if (await fs.pathExists(from)) {
            try {
                // Ensure target directory's parent exists
                await fs.ensureDir(path.dirname(to));
                // Move the directory
                await fs.move(from, to);
                console.log(`Renamed: ${path.basename(from)} -> ${path.basename(to)}`);
            }
            catch (error) {
                console.warn(`Warning: Failed to rename directory ${from} to ${to}:`, error);
            }
        }
    }
}
//# sourceMappingURL=template-engine.js.map