nucleus-ui-builder/dist/esm/lib/commands/processor/command.processor.js

function _define_property(obj, key, value) {
    if (key in obj) {
        Object.defineProperty(obj, key, {
            value: value,
            enumerable: true,
            configurable: true,
            writable: true
        });
    } else {
        obj[key] = value;
    }
    return obj;
}
import Compiler from "../../compiler/compiler.js";
import FileWriter from "../writer/file.writer.js";
import PathResolver from "../../resolvers/path.resolver.js";
import WriteFileCommand from "../writer/write.file.command.js";
class CommandProcessor {
    execute(argv) {
        const config = this.loader.config;
        if (!config) throw new Error(`config is missing`);
        this.validateArgs(argv, config);
        const template = config.templates[argv.templateName];
        const category = config.categories.find((c)=>c.name === argv.category);
        const replacements = {
            category: argv.category,
            componentName: argv.componentName,
            subcategory: argv.subcategory || ``,
            extensions: argv.extensions || ``
        };
        const filteredFiles = template.files.filter((file)=>!(file.condition && !argv.extensions));
        filteredFiles.forEach((file)=>{
            const resolvedPath = this.resolver(config.settings.rootDirectory, category.path, argv.componentName, file.name.replace(/\{\{(.*?)}}/g, (_, key)=>replacements[key] || key), argv.subcategory);
            const compiledContent = this.compiler.compile(file.content, replacements);
            this.fileWriter.addCommand(new WriteFileCommand(resolvedPath, compiledContent));
        });
        this.fileWriter.executeAll();
    }
    validateArgs(argv, config) {
        if (!argv.componentName) throw new Error(`Missing required argument: componentName`);
        if (!argv.templateName) throw new Error(`Missing required argument: templateName`);
        if (!config.templates[argv.templateName]) throw new Error(`Invalid template: ${argv.templateName} does not exist in the configuration.`);
        if (!argv.category) throw new Error(`Missing required argument: category`);
        if (!config.categories.some((c)=>c.name === argv.category)) throw new Error(`Invalid category: ${argv.category} does not exist in the configuration.`);
        if (argv.extensions) {
            const validExtensions = config.templates[argv.templateName].extensions || [];
            const providedExtensions = argv.extensions.split(`,`);
            providedExtensions.forEach((ext)=>{
                if (!validExtensions.includes(ext.trim())) throw new Error(`Invalid extension: ${ext} is not allowed for this template.`);
            });
        }
    }
    constructor(loader, compiler = new Compiler(), fileWriter = new FileWriter(), resolver = PathResolver.resolve){
        _define_property(this, "loader", void 0);
        _define_property(this, "compiler", void 0);
        _define_property(this, "fileWriter", void 0);
        _define_property(this, "resolver", void 0);
        this.loader = loader;
        this.compiler = compiler;
        this.fileWriter = fileWriter;
        this.resolver = resolver;
    }
}
export { CommandProcessor as default };

//# sourceMappingURL=command.processor.js.map