node-bundle/index.js

if (process.env.NODE_ENV === 'development') {
    require('longjohn');
}

var fs = require('fs');
var path = require('path');
var crypto = require('crypto');
var esprima = require('esprima');
var resolve = require('resolve');
var browserResolve = require('browser-resolve');
var events = require('events');

var core = {
    "assert": "assert",
    "buffer_ieee754": "buffer-browserify/buffer_ieee754",
    "buffer": "buffer-browserify",
    "child_process": "",
    "cluster": "",
    "console": "console-browserify",
    "constants": "constants-browserify",
    "crypto": "crypto-browserify",
    "_debugger": "",
    "dgram": "",
    "dns": "",
    "domain": "",
    "events": "events",
    "freelist": "",
    "fs": "browserify-fs",
    "http": "http-browserify",
    "https": "https-browserify",
    "_linklist": "",
    "module": "",
    "net": "",
    "os": "os-browserify",
    "path": "path-browserify",
    "punycode": "punycode",
    "querystring": "querystring",
    "readline": "",
    "repl": "",
    "stream": "stream-browserify",
    "string_decoder": "string_decoder",
    "sys": "",
    "timers": "timers-browserify",
    "tls": "",
    "tty": "tty-browserify",
    "url": "url",
    "util": "util",
    "vm": "vm-browserify",
    "zlib": "browserify-zlib"
};

var mainHeader = function (main, globalVal) {
    globalVal = typeof global !== 'undefined' ? global : globalVal;
    var cached = {};
    var loading = {};
    /*core*/
    function bundleRequire(id) {
        var bundle = main[id];
        if (!bundle) {
            throw new Error('Invalid module id ' + id);
        }
        if (cached[id]) {
            return cached[id];
        }
        if (loading[id]) {
            return loading[id];
        }
        var module = {exports: loading[id] = {}};
        bundle[0].call(module.exports, module.exports, function bundlerRequire(moduleName) {
            if (typeof core != 'undefined' && core.indexOf(moduleName) > -1) {
                return require(moduleName); // fallback to node require
            }
            return bundleRequire(bundle[1][moduleName] || moduleName);
        }, module, globalVal);
        loading[id] = null;
        return cached[id] = module.exports;
    }

    bundleRequire(0);
}.toString();

function Bundler(options) {
    events.EventEmitter.call(this);
    var defaults = {
        directory: process.cwd(), // the main directory
        strict: false, // if to append 'use strict'; in the header
        web: false, // if to add core node modules
        extensions: ['.js', '.json'], // files to require
        out: null, // file to save as
        wait: 1 // how long to wait
    };
    if (options) {
        for (var property in defaults) {
            if (defaults.hasOwnProperty(property) && options.hasOwnProperty(property)) {
                defaults[property] = options[property];
            }
        }
    }
    this.options = defaults;
}

Bundler.prototype = events.EventEmitter.prototype;

Bundler.prototype.files = {};

Bundler.prototype.addFile = function (file, directory) {
    if (!fs.existsSync(file)) {
        throw new Error('File ' + file + ' not found');
    }
    if (!directory) {
        file = path.join(this.options.directory, file);
        this.main = file;
    }
    var bundled = this.files[file] = new BundledFile(file, directory || '', this);
    bundled.checkContents(); // check AFTER setting file
    this.needsRebundle();
};

Bundler.prototype.reloadFile = function (file, directory) {
    var bundled = this.files[file];
    if (bundled) {
        bundled.checkContents();
    } else {
        this.addFile(file, directory);
    }
};

Bundler.prototype.loadDependencies = function (contents, file, directory) {
    var tokens;
    try {
        tokens = esprima.tokenize(contents);
    } catch (e) {
        console.error('Failed to tokenize ' + file, e.stack);
        return [];
    }
    var dependencies = [];
    for (var i = 0, length = tokens.length; i < length; i++) {
        var token = tokens[i];
        if (token.type === 'Identifier' && token.value === 'require' && i < length - 3) {
            // check the require statement, it should start with a (, have a string, then end with a )
            var next = tokens[i + 1];
            if (next.type !== 'Punctuator' || next.value !== '(') {
                continue;
            }
            next = tokens[i + 3];
            if (next.type !== 'Punctuator' || next.value !== ')') {
                // loop until we find a string
                while (next.type !== 'String' && next.value !== ')' && i < length - 3) {
                    next = tokens[++i];
                }
                i -= 2;
            }
            next = tokens[i + 2];
            if (next.type !== 'String') {
                continue;
            }
            var value = next.value.replace(/['"]+/g, '');
            if (resolve.isCore(value)) {
                if (this.options.web) {
                    // use special modules if available
                    var specialModule = core[value];
                    if (specialModule.length === 0) {
                        throw new Error('There is no web version of the core module ' + value + '!');
                    }
                    var module = resolve.sync(specialModule, {basedir: __dirname});
                    if (!this.files[module]) {
                        this.reloadFile(module, path.dirname(module));
                    }
                    dependencies.push({module: module, value: value});
                } else {
                    dependencies.push(value); // regular node importing
                }
            } else {
                try {
                    var module;
                    if (this.options.web) {
                        module = browserResolve.sync(value, {filename: file, extensions: this.options.extensions});
                    } else {
                        module = resolve.sync(value, {basedir: directory || this.options.directory, extensions: this.options.extensions});
                    }
                    if (!this.files[module]) {
                        this.reloadFile(module, path.dirname(module));
                    }
                    dependencies.push({module: module, value: value});
                } catch (e) {
                    console.error('Failed to load module', value, e.message);
                }
            }
        }
    }
    return dependencies;
};

Bundler.prototype.needsRebundle = function () {
    if (this._bundling) {
        return;
    }
    this._bundling = true;
    setTimeout(() => {
        this._bundling = false;
        this.bundle();
    }, this.options.wait); // allow other processes to run and cancel
};

Bundler.prototype.bundle = function () {
    var start = Date.now();
    this.emit('bundleStart', start);
    var array = [];
    var i = 0;
    var reverseIds = {};
    // first loop, assign ids
    for (var property in this.files) {
        if (this.files.hasOwnProperty(property)) {
            if (reverseIds[property]) {
                continue; // already bundled
            }
            reverseIds[property] = i++;
        }
    }
    // second loop, build code
    for (var property in this.files) {
        if (this.files.hasOwnProperty(property)) {
            // todo check if previously bundled
            var bundled = this.files[property];
            var dependencies = {};

            for (var j = 0, length = bundled.dependencies.length; j < length; j++) {
                var dependency = bundled.dependencies[j];
                if (typeof dependency !== 'string') {
                    dependencies[dependency.value] = reverseIds[dependency.module];
                }
            }

            var event = {
                file: property,
                content: bundled.contents
            };
            if (bundled.changed) {
                this.emit('bundleFile', event);
                bundled.changed = false;
            }
            if (path.extname(event.file) === '.json') {
                array.push(reverseIds[bundled.file] + `: [function (exports, require, module, global) {module.exports = ${event.content}}, ${JSON.stringify(dependencies)}]`);
            } else {
                array.push(reverseIds[bundled.file] + `: [function (exports, require, module, global) {${event.content}}, ${JSON.stringify(dependencies)}]`);
            }
        }
    }
    var header = mainHeader;
    header = header.replace('/*main*/', this.main);
    header = header.replace('/*core*/', this.options.web ? '' : 'var core = ' + JSON.stringify(Object.keys(core)) + ';');

    var text = '(' + header + ')({' + array.join(',') + '}, this);';
    if (this.options.strict) {
        text = '\'use strict\';\n' + text;
    }

    var event = {content: text, time: Date.now() - start, files: array.length};
    this.emit('bundle', event);
    if (typeof this.options.out === 'string') {
        fs.writeFileSync(this.options.out, event.content);
    } else if (this.options.out) {
        this.options.out(event.content);
    } else {
        process.stdout.write(event.content);
    }
};

module.exports = Bundler;

function BundledFile(file, directory, bundler) {
    this.file = file;
    this.directory = directory;
    this.bundler = bundler;
    this.changed = false;
}

BundledFile.prototype.checkContents = function () {
    try {
        var contents = fs.readFileSync(this.file);
        var newHash;
        if (!this.contents || this.contents.length != contents.length || this.hash != (newHash = calculateHash(contents))) {
            this.hash = newHash;
            this.contents = contents;
            this.changed = true;
            var event = {contents: this.contents, file: this.file};
            this.bundler.emit('fileUpdate', event);
            this.contents = event.contents;
            this.dependencies = this.bundler.loadDependencies(this.contents, this.file, this.directory);
            this.bundler.needsRebundle();
        }
    } catch (e) {
        e.message = this.file + '\n' + (e.message || '');
        throw e;
    }
};

function calculateHash(contents) {
    return crypto.createHash('sha512').update(contents).digest('hex');
}