mili/es/src/render/index.js

Scaffolding with continuous control over the development of the project.

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());
    });
};
import AJV from 'ajv8';
import * as R from 'ramda';
import * as path from 'path';
import { parseTemplate } from "../util/parse-template";
import * as logger from "../util/logger";
import { download } from './download';
import { loadConfig } from './load-config';
import { inquire } from './inquire';
import { execLoader } from './exec-loader';
import { compile } from './compile';
const ajv = new AJV();
export function render(cwd, repository, answers, initResource) {
    return __awaiter(this, void 0, void 0, function* () {
        const templatePath = yield download(repository, cwd);
        const config = yield 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 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 = 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 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 compile(cwd, path.join(templatePath, 'templates'), config.templates, resource);
    });
}