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

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
Object.defineProperty(exports, "default", {
    enumerable: true,
    get: function() {
        return CommandProcessor;
    }
});
const _compiler = /*#__PURE__*/ _interop_require_default(require("../../compiler/compiler.js"));
const _filewriter = /*#__PURE__*/ _interop_require_default(require("../writer/file.writer.js"));
const _pathresolver = /*#__PURE__*/ _interop_require_default(require("../../resolvers/path.resolver.js"));
const _writefilecommand = /*#__PURE__*/ _interop_require_default(require("../writer/write.file.command.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;
}
function _interop_require_default(obj) {
    return obj && obj.__esModule ? obj : {
        default: obj
    };
}
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.default(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.default(), fileWriter = new _filewriter.default(), resolver = _pathresolver.default.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;
    }
}

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