mili/lib/src/render/index.js

Scaffolding with continuous control over the development of the project.

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.render = void 0;
const ajv8_1 = require("ajv8");
const R = require("ramda");
const path = require("path");
const parse_template_1 = require("../util/parse-template");
const logger = require("../util/logger");
const download_1 = require("./download");
const load_config_1 = require("./load-config");
const inquire_1 = require("./inquire");
const exec_loader_1 = require("./exec-loader");
const compile_1 = require("./compile");
const ajv = new ajv8_1.default();
function render(cwd, repository, answers, initResource) {
    return __awaiter(this, void 0, void 0, function* () {
        const templatePath = yield (0, download_1.download)(repository, cwd);
        const config = yield (0, load_config_1.loadConfig)(templatePath);
        if (!initResource.mili) {
            initResource.mili = {
                stack: [],
            };
        }
        if (!initResource.mili.stack) {
            initResource.mili.stack = [];
        }
        initResource.mili.stack.push(Object.assign(Object.assign({}, repository), { version: config.version }));
        answers = yield (0, inquire_1.inquire)(config.questions, answers);
        for (const extension of config.extends) {
            if (extension.when) {
                const validate = ajv.compile(extension.when);
                const valid = validate(answers);
                if (!valid)
                    continue;
            }
            const subRepository = (0, parse_template_1.parseTemplate)(extension.template, extension.version, {
                registry: initResource.mili.registry,
                cwd,
            });
            let subAnwsers = R.clone(answers);
            if (extension.answers)
                subAnwsers = Object.assign(Object.assign({}, subAnwsers), extension.answers);
            yield render(cwd, subRepository, subAnwsers, R.clone(initResource));
        }
        logger.info(`compile template ${repository.name}...`);
        const resource = new Map(Object.entries(initResource));
        for (const loader of config.loaders) {
            const result = yield (0, exec_loader_1.execLoader)(cwd, loader);
            for (const [key, value] of Object.entries(result)) {
                if (resource.has(key))
                    throw new Error(`Key Confilct - Loader:${loader.name}, key:${key}`);
                resource.set(key, value);
            }
        }
        resource.set('answers', answers);
        yield (0, compile_1.compile)(cwd, path.join(templatePath, 'templates'), config.templates, resource);
    });
}
exports.render = render;