bundilio/src/index.js

#!/usr/bin/env node

const Path = require('path');
const Json5 = require('json5');
const Util = require('util');
const FS = require('./fs2');
const Rollup = require('rollup');
const nodeResolve = require('rollup-plugin-node-resolve');
const commonjs = require('rollup-plugin-commonjs');
const babel = require('rollup-plugin-babel');
const del = require('del');
const builtinModules = require('builtin-modules');
const {ArgumentParser} = require('argparse');
const npm = require('npm');
const {codeFrameColumns} = require('@babel/code-frame');
const Chalk = require('chalk');

// secret multi-rollup: https://github.com/rollup/rollup/issues/863#issuecomment-306061779  https://github.com/rollup/rollupjs.org/blob/b9fe8623f2d958fd15a524235a6eb05900c2b9f1/rollup.config.js

// https://medium.com/@tarkus/how-to-build-and-publish-es6-modules-today-with-babel-and-rollup-4426d9c7ca71
process.on('unhandledRejection', dump);


function* findPlugins(searchString, obj, path) {
    if(obj[searchString]) {
        for(let i=0; i<obj[searchString].length; ++i) {
            if(Array.isArray(obj[searchString][i])) {
                yield [[...path, searchString, i, 0], obj[searchString][i][0]];
            } else {
                yield [[...path, searchString, i], obj[searchString][i]];
            }
        }
    }
    for(let key of Object.keys(obj)) {
        if(key !== searchString && typeof obj[key] === 'object') {
            let newPath = [...path, key];
            for(let x of findPlugins(searchString, obj[key], newPath)) {
                yield x;
            }
        }
    }
}

// https://github.com/babel/babel/blob/70361f12005e9ce0f9b961097006ff89f07c34a7/packages/babel-preset-env/src/normalize-options.js#L45-L46
const normalizePluginName = (plugin) => plugin.replace(/^babel-plugin-/, "");

(async () => {
    const argparse = new ArgumentParser({
        // version: pkg.version,
        // description: pkg.description,
        addHelp: true,
    });


    argparse.addArgument(['-w', '--watch'], {
        help: "Watch source files for changes",
        dest: 'watch',
        action: 'storeTrue',
    });
    
    const cliArgs = argparse.parseArgs();
    
    const pkgFile = await FS.closest('package.json');
    const pkgJson = await FS.readText(pkgFile);
    const pkg = Json5.parse(pkgJson);
    const mainFields = ['browser', 'module', 'main']; // https://webpack.js.org/configuration/resolve/#resolve-mainfields
    const pkgDeps = objectKeys(pkg.dependencies).concat(objectKeys(pkg.peerDependencies));
    const pkgDir = Path.dirname(pkgFile);
    const distDir = Path.join(pkgDir, 'dist');
    const babelRcFile = Path.join(pkgDir, '.babelrc');

    // await del(distDir);
    // TODO: only delete the files that weren't re-written?
    
    let babelOptions;
    let useBabel = await FS.exists(babelRcFile);
    if(useBabel) {
        babelOptions = Json5.parse(await FS.readText(babelRcFile));
        // fixme: a bunch of BS to solve this: https://stackoverflow.com/q/47660601/65387
        let pluginPaths = findPlugins('plugins', babelOptions, []);
        // dump('pluginPaths',Array.from(pluginPaths));
        for(let [path,plug] of pluginPaths) {
            let plugMod;
            // TODO: check if path is relative
            try {
                plugMod = require.resolve(plug)
            } catch(_) {
                try {
                    plugMod = require.resolve(`babel-plugin-${plug}`);
                } catch(_) {
                    plugMod = plug;
                }
            }
            setValue(babelOptions, path, plugMod);
        }

        let presetPaths = findPlugins('presets', babelOptions, []);
        // dump('presetPaths',Array.from(presetPaths));

        for(let [path,preset] of presetPaths) {
            let plugMod;
            // TODO: check if path is relative
            try {
                plugMod = require.resolve(preset)
            } catch(_) {
                try {
                    plugMod = require.resolve(`babel-preset-${preset}`);
                } catch(_) {
                    plugMod = preset;
                }
            }
            setValue(babelOptions, path, plugMod);
        }
    }
    
    // dump('babelOptions',babelOptions);
    
    // process.exit();
    
    let rollupConfigs = [];
    
    await forAll(mainFields, field => forAll(toArray(pkg[field]), async filename => {
        const srcFile = Path.resolve(pkgDir, filename);
        
        if(!(await FS.exists(srcFile))) {
            console.log(`Entry file does not exist: ${srcFile}`);
            delete pkg[field];
            return;
        }
        
        const distFile = `${field}.js`;
        const distPath = Path.join(distDir, distFile);
        pkg[field] = distFile;
        
        let rollupOptions = {
            input: srcFile,
            external: field === 'main' ? [...pkgDeps, ...builtinModules] : pkgDeps,
            name: pkg.name,
            plugins: [
                nodeResolve({
                    jail: pkgDir,
                    // jsnext: true,
                }),
                commonjs(),
            ],
            output: {
                file: distPath,
                format: field === 'main' ? 'cjs' : 'es',  // since browsers are now starting to support ES-modules, assume both "browser" and "module" mean ES-modules.
                sourcemap: true,
            },
            watch: {
                chokidar: true,
            }
        };
        
        if(useBabel) {
            rollupOptions.plugins.unshift(babel({
                ...babelOptions,
                babelrc: false,
            }));
        }

        // dump(babelOptions);
        // dump(inputOptions);

 
        
        rollupConfigs.push(rollupOptions);
    }));
    
    // dump('rollupConfigs',rollupConfigs);

    delete pkg.devDependencies;
    delete pkg.scripts;
    delete pkg.eslintConfig;
    delete pkg.babel;

    await FS.writeText(Path.join(distDir, 'package.json'), JSON.stringify(pkg, null, 2));
    
    // TODO: copy over LICENSE, LICENSE.txt, LICENSE.md etc.
    // and README.md

    if(cliArgs.watch) {
        // FIXME: this watcher *really* sucks under Ubuntu+PhpStorm, even with chokidar: true
        // Easier to create a "File Watcher" from inside PhpStorm
        let watcher = Rollup.watch(rollupConfigs);

        watcher.on('event', ev => {
            // https://rollupjs.org/#rollup-watch
            switch(ev.code) {
                case 'START':
                    break;
                case 'END':
                    break;
                case 'BUNDLE_START':
                    // let now = new Date();
                    // process.stdout.write(`${Chalk.grey(`[${String(now.getHours()).padStart(2,'0')}:${String(now.getMinutes()).padStart(2,'0')}:${String(now.getSeconds()).padStart(2,'0')}]`)} compiling...`);
                    break;
                case 'BUNDLE_END':
                    // process.stdout.write(` done\n`);
                    break;
                default:
                    dump(ev);
                    break;
            }
        });
    } else {
        try {
            // let bundle = await Rollup.write(rollupConfigs);
            // await bundle.write(outputOptions);
            
            // rollup decided it would be too convenient to have a method that does this...? https://github.com/rollup/rollup/issues/863#issuecomment-349426989
            await Promise.all(rollupConfigs.map(({output, ...input}) => Rollup.rollup(input).then(bundle => bundle.write(output))));
        } catch(err) {
            // console.dir(err);
            // console.log(Reflect.ownKeys(err));
            console.log(Chalk.red(err.message));
            if(err.id && err.loc) {
                let srcCode = await FS.readText(err.id);
                console.log(codeFrameColumns(srcCode, {
                    start: {
                        line: err.loc.line,
                        column: err.loc.column + 1,
                    }
                }, {forceColor: true}));
            }// else {
            dump(err);
            //}
        }
    }
})();

function objectKeys(obj) {
    return obj ? Object.keys(obj) : [];
}

function toArray(x) {
    if(x == null) return [];
    if(Array.isArray(x)) return x;
    return [x];
}

function dump(...args) {
    console.log(...args.map(o => Util.inspect(o, {colors: true, depth: 10})));
}

function forAll(iterable, callback) {
    let promises = [];
    for(let x of iterable) {
        promises.push(callback(x));
    }
    return Promise.all(promises);
}

function setValue(obj, path, value) {
    const end = path.length - 1;
    for(let i=0; i<end; ++i) {
        obj = obj[path[i]];
    }
    obj[path[end]] = value;
}