bundilio/bundilio.js

#!/usr/bin/env node
const FileSystem = require('fs');
const Path = require('path');
const {ArgumentParser} = require('argparse');
const pkg = require('./package.json');
const Babel = require('babel-core');
const {promisify, readDirR, copyFile, log, splice, mapToObject, mergeDeep, getFiles, readDir, fileStat, readText, forAll} = require('./util');
const mkdirp = promisify(require('mkdirp'));
const writeFile = promisify(FileSystem.writeFile);
const BabelTypes = require('babel-types');
const traverseAst = require('babel-traverse').default;
const babelGenerator = require('babel-generator').default;
const babelTemplate = require('babel-template');
const Babylon = require('babylon');
const Chalk = require('chalk');

let parser = new ArgumentParser({
    version: pkg.version,
    description: pkg.description,
    addHelp: true,
});

parser.addArgument('pkgDir', {
    help: "Directory with package.json",
    metavar: "package-dir",
    defaultValue: '.',
});

parser.addArgument(['-s', '--src-dir'], {
    help: "Source directory to bundle up",
    metavar: "src-dir",
    dest: 'srcDir',
});

parser.addArgument(['-d', '--out-dir'], {
    help: "Output directory",
    metavar: "out-dir",
    dest: 'outDir',
});

parser.addArgument(['-t', '--target'], {
    help: "Target environment",
    metavar: "target",
    dest: 'target',
    defaultValue: 'node:6,webpack:2'
});

parser.addArgument(['--index'], {
    help: "Generate an index file for each directory where it is missing",
    // defaultValue: true,
    // type: x => x !== 'false',
    // storeConst: 'bacon',
    // action: 'storeFalse',
    // constant: true,
    // defaultValue: false,
    // dest: 'index',
    dest: 'index',
    defaultValue: 'shallow', // or "deep" or "false"
});


let args = parser.parseArgs();


const SRC_DIR = args.srcDir || Path.join(args.pkgDir, 'src');
// TODO: read package.json to make a better guess about the dist dir?
const DIST_DIR = args.outDir || Path.join(SRC_DIR, '..', 'dist');


// log(srcDir,outDir);return;

// console.log(require('util').inspect(args,{colors:true}));return;

let sourceFiles = readDirR(SRC_DIR);
sourceFiles.sort();

// console.log(require('util').inspect(files,{colors:true}));return;
const transformFile = promisify(Babel.transformFile);
// const transpile = promisify(Babel.transform);

const babelEnvs = {
    node: {
        plugins: [
            require.resolve('babel-plugin-dynamic-import-node'),
        ],
        presets: [
            [
                require.resolve('babel-preset-env'),
                {
                    modules: 'commonjs',
                    loose: true,
                    targets: {
                        node: 6
                    }
                }
            ]
        ],
    },
    web: {
        plugins: [
            // require.resolve('babel-plugin-dynamic-import-webpack'), //needed for webpack 1    
        ],
        presets: [
            [
                require.resolve('babel-preset-env'),
                {
                    modules: false,
                    loose: true,
                    targets: {
                        browsers: [
                            "> 1%",
                            "last 2 Firefox versions",
                            "last 2 Chrome versions",
                            "last 2 Edge versions",
                            "last 2 Safari versions",
                            "Firefox ESR",
                            "IE >= 8"
                        ]
                    }
                }
            ]
        ],
    },
};

// let outDirs = [...new Set(files.map(f => Path.dirname(f)))];


async function processDir(inputDir) {
    let srcEntries = await readDir(inputDir);

    let hasIndex = srcEntries.map(p => Path.parse(p).name).includes('index');
    let indexLines = [];
    // log(inputDir,hasIndex);

    await forAll(srcEntries, async srcFile => {
        let srcStat = await fileStat(srcFile);

        if(srcStat.isDirectory()) {
            processDir(srcFile);
        } else {
            let srcParsed = Path.parse(srcFile);
            let destFileBase = srcParsed.base.replace(/\.(web|node)\./, '.');
            
            if(/\.jsx?/.test(srcFile)) {
                let fileContents = await readText(srcFile);
                
                if(!hasIndex) {
                    let ast;
                    try {
                        ast = Babylon.parse(fileContents, {
                            sourceType: 'module',
                            plugins: [
                                // https://github.com/babel/babylon#plugins
                                'jsx',
                                'doExpressions',
                                'objectRestSpread',
                                'classProperties',
                                'exportExtensions',
                                'dynamicImport',
                                'functionBind',
                            ]
                        });
                    } catch(parseErr) {
                        console.log(`${Chalk.red(`Parse error in ${Chalk.underline(srcFile)}`)}`, parseErr.message);
                        return;
                    }

                
                    let destParsed = Path.parse(destFileBase);
                    let defaultId = destParsed.name; // TODO: make sure this is a valid JS dentifier
                    let srcString = JSON.stringify(`./${destParsed.name}`);


                    let hasDefaultExport = ast.program.body.some(x => x.type === 'ExportDefaultDeclaration');
                    let hasNamedExport = ast.program.body.some(x => x.type === 'ExportNamedDeclaration');
                    

                    if(hasDefaultExport) {
                        indexLines.push(`export {default as ${defaultId}} from ${srcString};`);
                    }
                    if(hasNamedExport) {
                        // this is "shallow" -- export {* as FILE} from 'xxx'; would be deep
                        indexLines.push(`export * from ${srcString};`);
                    }
                }

                ['node', 'web'].forEach(async target => {
                    
                    let result = transpile(target, fileContents, srcFile);

                    let destDir = Path.join(DIST_DIR, target, Path.relative(SRC_DIR, inputDir));
                    let destFile = Path.join(destDir, destFileBase);

                    await mkdirp(destDir);
                    await writeFile(destFile, result.code);
                    console.log(`compiled ${srcFile} -> ${destFile}`);
                });
            } else {
                ['node', 'web'].forEach(async target => {
                    // TODO: remove code repeittion
                    let destDir = Path.join(DIST_DIR, target, Path.relative(SRC_DIR, inputDir));
                    let destFile = Path.join(destDir, destFileBase);

                    await mkdirp(destDir);
                    await copyFile(srcFile, destFile);
                    console.log(`copied ${srcFile} -> ${destFile}`);
                });
            }
        }
    });
    
    
    if(indexLines.length) {
        indexLines.push(`import * as __self__ from './index';`);
        indexLines.push(`export default __self__;`);
        let indexFileContents = indexLines.join('\n');

        ['node', 'web'].forEach(async target => {
            let destDir = Path.join(DIST_DIR, target, Path.relative(SRC_DIR, inputDir));
            let destFile = Path.join(destDir, 'index.js');
            let result = transpile(target, indexFileContents, destFile);
            await mkdirp(destDir);
            await writeFile(destFile, result.code);
            console.log(`wrote ${destFile}`);
        });
    }
}

function transpile(target, fileContents, filename) {
    const babelPlugins = [
        require.resolve('babel-plugin-transform-function-bind'),
        require.resolve('babel-plugin-syntax-do-expressions'),
        require.resolve('babel-plugin-syntax-dynamic-import'),
        require.resolve('babel-plugin-transform-class-properties'),
        require.resolve('babel-plugin-transform-do-expressions'),
        require.resolve('babel-plugin-transform-function-bind'),
        require.resolve('babel-plugin-transform-object-rest-spread'),
        require.resolve('babel-plugin-transform-react-jsx'),
        // require.resolve('babel-plugin-transform-runtime'),
        [require.resolve('babel-plugin-transform-define'), {'BUNDILIO_TARGET': target}],
    ];

    return Babel.transform(fileContents, mergeDeep({
        ast: false,
        code: true,
        babelrc: false,
        plugins: babelPlugins,
        filename,
    }, babelEnvs[target]));
}

processDir(SRC_DIR);

// TODO: generate API documentation too?