vdev/dist/processors.js

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.rollupFiles = exports.pcssFiles = exports.tmplFiles = void 0;
const plugin_commonjs_1 = __importDefault(require("@rollup/plugin-commonjs"));
const plugin_multi_entry_1 = __importDefault(require("@rollup/plugin-multi-entry"));
const plugin_node_resolve_1 = __importDefault(require("@rollup/plugin-node-resolve"));
const backlib_1 = require("backlib");
const fs = __importStar(require("fs-extra"));
/////// for handlebars
const hbsp_1 = require("hbsp"); // promise style
const Path = __importStar(require("path"));
//////// for Postcss
const postcss_1 = __importDefault(require("postcss"));
/////// for JS
const rollup = __importStar(require("rollup"));
const rollup_plugin_typescript2_1 = __importDefault(require("rollup-plugin-typescript2")); // TODO: might want to update to @rollup/plugin-typescript (But it is a different implementation)
const utils_1 = require("./utils");
const processors = [
    require("autoprefixer"),
    require("postcss-import"),
    require("postcss-mixins"),
    require("postcss-nested")
];
// --------- For Handlebars --------- //
async function tmplFiles(files, distFile) {
    await backlib_1.saferRemove([distFile]);
    const templateContent = [];
    for (let file of files) {
        const htmlTemplate = await fs.readFile(file, "utf8");
        const 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) {
    const mapFile = distFile + ".map";
    let pcssResult;
    try {
        await backlib_1.saferRemove([distFile, mapFile]);
        const processor = postcss_1.default(processors);
        const pcssNodes = [];
        // we parse all of the .pcss files
        for (let srcFile of entries) {
            // read the file
            let pcss = await fs.readFile(srcFile, "utf8");
            const pcssNode = postcss_1.default.parse(pcss, {
                from: srcFile
            });
            pcssNodes.push(pcssNode);
        }
        // build build the combined rootNode and its result
        let rootNode = null;
        for (let pcssNode of pcssNodes) {
            rootNode = (rootNode) ? rootNode.append(pcssNode) : pcssNode;
        }
        const rootNodeResult = rootNode.toResult();
        // we process the rootNodeResult
        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.toString(), "utf8");
}
exports.pcssFiles = pcssFiles;
const 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 backlib_1.saferRemove("./.rpt2_cache");
    // delete the previous ouutput files
    const 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 backlib_1.saferRemove(distFile);
        }
        await backlib_1.saferRemove(mapFile);
    }
    catch (ex) {
        console.log(`Can't delete dist files`, ex);
    }
    // set the default rollup input options
    const inputOptions = {
        input: entries,
        plugins: [plugin_multi_entry_1.default(), plugin_commonjs_1.default(), plugin_node_resolve_1.default()]
    };
    // --------- Exclude 3rd Party circular Dependencies --------- //
    const excludeCircularWarningByImporters = ['node_modules/d3', 'node_modules/moment'];
    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"
    const name = Path.parse(distFile).name.replace(/\W+/g, "_");
    const outputOptions = {
        file: distFile,
        format: 'iife',
        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_plugin_typescript2_1.default(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 = { ...inputOptions };
            watchOptions.output = outputOptions;
            watchOptions.watch = { chokidar: true };
            const watcher = rollup.watch(watchOptions);
            let startTime;
            watcher.on('event', async function (evt) {
                // console.log('rollup watch', evt.code, evt.output);
                if (evt.code === 'START') {
                    startTime = utils_1.now();
                }
                else if (evt.code === 'END') {
                    let size = (await fs.stat(distFile)).size;
                    size = Math.round(size / 1000.0);
                    console.log(`Recompile ${distFile} - ${Math.round(utils_1.now() - startTime)}ms -  ${size} kb`);
                }
                else if (evt.code === 'ERROR') {
                    console.log(`ERROR - Rollup/Typescript error when processing: ${distFile}`);
                    console.log("\t" + 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) --------- //