@ywfe/cli/lib/module/create/generate.js

遥望前端开发命令行工具

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.generate = void 0;
const metalsmith_1 = __importDefault(require("metalsmith"));
const path_1 = __importDefault(require("path"));
const chalk = require('chalk');
const multimatch = require('multimatch');
const handlebars = require('handlebars');
const async = require('async');
const render = require('consolidate').handlebars.render;
const getOptions = require('./options').getOptions;
const ask_1 = require("./ask");
const filter_1 = require("./filter");
const logger = require('./logger');
handlebars.registerHelper('if_eq', function (a, b, opts) {
    return a === b
        ? opts.fn(this)
        : opts.inverse(this);
});
handlebars.registerHelper('unless_eq', function (a, b, opts) {
    return a === b
        ? opts.inverse(this)
        : opts.fn(this);
});
const generate = (name, src, dest, done) => {
    const opts = getOptions(name, src);
    const metalsmith = (0, metalsmith_1.default)(path_1.default.join(src, 'template'));
    let data = Object.assign(metalsmith.metadata(), {
        destDirName: name,
        inPlace: dest === process.cwd(),
        noEscape: true
    });
    opts.helpers && Object.keys(opts.helpers).map(function (key) {
        handlebars.registerHelper(key, opts.helpers[key]);
    });
    const helpers = { chalk, logger };
    if (opts.metalsmith && typeof opts.metalsmith.before === 'function') {
        opts.metalsmith.before(metalsmith, opts, helpers);
    }
    metalsmith.use(askQuestions(opts.prompts))
        .use(filterFiles(opts.filters))
        .use(renderTemplateFiles(opts.skipInterpolation));
    if (typeof opts.metalsmith === 'function') {
        opts.metalsmith(metalsmith, opts, helpers);
    }
    else if (opts.metalsmith && typeof opts.metalsmith.after === 'function') {
        opts.metalsmith.after(metalsmith, opts, helpers);
    }
    metalsmith.clean(false)
        .source('.')
        .destination(dest)
        .build((err, files) => {
        done(err);
        if (typeof opts.complete === 'function') {
            const helpers = { chalk, logger, files };
            opts.complete(data, helpers);
        }
        else {
            logMessage(opts.completeMessage, data);
        }
    });
    return data;
};
exports.generate = generate;
const askQuestions = (prompts) => {
    return (files, metalsmith, done) => {
        (0, ask_1.ask)(prompts, metalsmith.metadata(), done);
    };
};
const filterFiles = (filters) => {
    return (files, metalsmith, done) => {
        (0, filter_1.filter)(files, filters, metalsmith.metadata(), done);
    };
};
const renderTemplateFiles = (skipInterpolation) => {
    skipInterpolation = typeof skipInterpolation === 'string' ? [skipInterpolation] : skipInterpolation;
    return (files, metalsmith, done) => {
        const keys = Object.keys(files);
        const metalsmithMetadata = metalsmith.metadata();
        async.each(keys, (file, next) => {
            if (skipInterpolation && multimatch([file], skipInterpolation, { dot: true }).length) {
                return next();
            }
            const str = files[file].contents.toString();
            if (!/{{([^{}]+)}}/g.test(str)) {
                return next();
            }
            render(str, metalsmithMetadata, (err, res) => {
                if (err) {
                    err.message = `[${file}] ${err.message}`;
                    return next(err);
                }
                files[file].contents = Buffer.from(res);
                next();
            });
        }, done);
    };
};
const logMessage = (message, data) => {
    if (!message)
        return;
    render(message, data, (err, res) => {
        if (err) {
            console.error('\n   Error when rendering template complete message: ' + err.message.trim());
        }
        else {
            console.log('\n' + res.split(/\r?\n/g).map((line) => {
                return '   ' + line;
            }).join('\n'));
        }
    });
};