vdev/dist/processors.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const utils_1 = require("./utils");
const Path = require("path");
const fs = require("fs-extra-plus");
//////// for Postcss
const postcss = require("postcss");
const processors = [
    require("autoprefixer"),
    require("postcss-import"),
    require("postcss-mixins"),
    require("postcss-nested")
];
/////// for JS
const rollup = require("rollup");
const rollup_cjs = require("rollup-plugin-commonjs");
const rollup_re = require("rollup-plugin-node-resolve");
const rollup_ts = require("rollup-plugin-typescript2");
const rollup_multi = require("rollup-plugin-multi-entry");
/////// for handlebars
const hbsp_1 = require("hbsp"); // promise style
// --------- For Handlebars --------- //
async function tmplFiles(files, distFile) {
    await fs.saferRemove([distFile]);
    var templateContent = [];
    for (let file of files) {
        let htmlTemplate = await fs.readFile(file, "utf8");
        let template = await hbsp_1.precompile(file, htmlTemplate);
        templateContent.push(template);
    }
    await fs.writeFile(distFile, templateContent.join("\n"), "utf8");
}
exports.tmplFiles = tmplFiles;
// --------- /For Handlebars --------- //
// --------- For postCss --------- //
async function pcssFiles(entries, distFile) {
    var mapFile = distFile + ".map";
    try {
        await fs.saferRemove([distFile, mapFile]);
        var processor = postcss(processors);
        var pcssNodes = [];
        // we parse all of the .pcss files
        for (let srcFile of entries) {
            // read the file
            let pcss = await fs.readFile(srcFile, "utf8");
            var pcssNode = postcss.parse(pcss, {
                from: srcFile
            });
            pcssNodes.push(pcssNode);
        }
        // build build the combined rootNode and its result
        var rootNode = null;
        for (let pcssNode of pcssNodes) {
            rootNode = (rootNode) ? rootNode.append(pcssNode) : pcssNode;
        }
        var rootNodeResult = rootNode.toResult();
        // we process the rootNodeResult
        var pcssResult = await processor.process(rootNodeResult, {
            from: "undefined",
            to: distFile,
            map: { inline: false }
        });
    }
    catch (ex) {
        console.log(`postcss ERROR - Cannot process ${distFile} because (setting css empty file) \n${ex}`);
        // we write the .css and .map files
        await fs.writeFile(distFile, "", "utf8");
        await fs.writeFile(mapFile, "", "utf8");
        return;
    }
    // we write the .css and .map files
    await fs.writeFile(distFile, pcssResult.css, "utf8");
    await fs.writeFile(mapFile, pcssResult.map, "utf8");
}
exports.pcssFiles = pcssFiles;
var defaultOpts = {
    ts: true,
    watch: false
};
/**
 * @param {*} opts
 *    - ts?: boolean - (default true)
 *    -
 *    - watch: true | false (default false)
 */
async function rollupFiles(entries, distFile, opts) {
    opts = Object.assign({}, defaultOpts, opts);
    await utils_1.saferRemove("./.rpt2_cache", false);
    // delete the previous ouutput files
    var mapFile = distFile + ".map";
    try {
        // Note: Do not delete the distFile if we are in watch mode, otherwise, rollup throw an uncatched promise exception
        if (!opts.watch) {
            await utils_1.saferRemove(distFile, false);
        }
        await utils_1.saferRemove(mapFile, false);
    }
    catch (ex) {
        console.log(`Can't delete dist files`, ex);
    }
    // set the default rollup input options
    const inputOptions = {
        input: entries,
        plugins: [rollup_multi(), rollup_cjs(), rollup_re()]
    };
    // --------- Exclude 3rd Party circular Dependencies --------- //
    const excludeCircularWarningByImporters = ['node_modules/d3'];
    inputOptions.onwarn = function onwarn(warning) {
        let skip = false;
        if (warning.code === 'CIRCULAR_DEPENDENCY') {
            for (let skipImporter of excludeCircularWarningByImporters) {
                if (warning.importer.startsWith(skipImporter)) {
                    skip = true;
                    break;
                }
            }
        }
        // NOTE: 2019-01-10 for now skip the plugin warning because of ONGENERATE_HOOK_DEPRECATED on rpt2
        if (warning.code === 'PLUGIN_WARNING') {
            skip = true;
        }
        if (!skip) {
            console.log(`rollup warning - ${warning.message}`);
        }
    };
    // --------- /Exclude 3rd Party circular Dependencies --------- //
    // set the default rollup output options
    // make the name from file name "web/js/lib-bundle.js" : "lib_bundle"
    var name = Path.parse(distFile).name.replace(/\W+/g, "_");
    const outputOptions = {
        file: distFile,
        format: 'iife',
        name: name,
        sourcemap: true,
        sourcemapFile: mapFile
    };
    // if ts, then, we add the rollup_ts plugin
    if (opts.ts || opts.tsconfig) {
        let tsOpts = {
            clean: true
        };
        if (opts.tsconfig) {
            tsOpts.tsconfig = opts.tsconfig;
        }
        // Note: if we do not have clean:true, we get some exception when watch.
        inputOptions.plugins.push(rollup_ts(tsOpts));
    }
    // if we have some globals, we add them accordingly
    if (opts.globals) {
        // for input, just set the external (clone to be safe(r))
        inputOptions.external = Object.keys(opts.globals);
        outputOptions.globals = opts.globals;
    }
    try {
        // if it is watch mode, we do the watch
        if (opts.watch) {
            //wathOptions = { inputOptions };
            let watchOptions = Object.assign({}, inputOptions);
            watchOptions.output = outputOptions;
            watchOptions.watch = { chokidar: true };
            const watcher = rollup.watch(watchOptions);
            let startTime;
            watcher.on('event', function (evt) {
                // console.log('rollup watch', evt.code, evt.output);
                if (evt.code === 'START') {
                    startTime = utils_1.now();
                }
                else if (evt.code === 'END') {
                    console.log(`Recompile ${distFile} done: ${Math.round(utils_1.now() - startTime)}ms`);
                }
                else if (evt.code === 'ERROR') {
                    console.log(`ERROR - Rollup/Typescript error when processing: ${distFile}`);
                    console.log("\t" + evt.error);
                }
                else if (evt.code === 'FATAL') {
                    console.log(`FATAL ERROR - Rollup/Typescript fatal error when processing ${distFile}\n
					>>>>>>>> MUST RESTART WATCH SESSION <<<<<<<<\n\n`, evt.error);
                }
            });
        }
        // otherwise, we do the full build
        else {
            // bundle
            const bundle = await rollup.rollup(inputOptions);
            // write
            await bundle.write(outputOptions);
        }
        // make sure the .rpt2_cache/ folder is delete (apparently, clean:true does not work)
        //await fs.remove("./.rpt2_cache");
    }
    catch (ex) {
        // make sure we write nothing in the file, to know nothing got compiled and fail early
        await fs.writeFile(distFile, "", "utf8");
        throw ex;
    }
}
exports.rollupFiles = rollupFiles;
// --------- /For Rollup (JavaScript) --------- //