nucleo-amd/bin/nucleo-amd.browser.js

(function(mainContext) {
var Core = function() { // jshint ignore:line

    var registry = {}
    var seen = {}
    var helpers = {}
    var customRequireDepsHandler = {
        requireDeps: function (name, submodule, referrer) {
            return require(name, submodule, referrer)
        },
        catchErrors: function (err, name, referrer) {
            helpers.throwError('Could not find module ' + name + ' required by: ' + referrer)
        }
    }

    helpers.isArray = function(myArray) {
        return Object.prototype.toString.call(myArray).indexOf('Array') > -1;
    }
    helpers.isPlainObject = function(value) {
        return value && (value.constructor === Object || value.constructor === undefined);
    }
    helpers.unreferencePlainObjectsAndArrays = function(source) {

        if(helpers.isArray(source)) {

            var length = source.length;
            var unreferencedArray = [];

            for (var i = 0; i < length; i++) {
                unreferencedArray.push(helpers.unreferencePlainObjectsAndArrays(source[i]))
            }

            return unreferencedArray;

        } else if(helpers.isPlainObject(source)) {

            var name, s, empty = {}, dest = {};

            for(name in source) {
                /*jshint -W089 */
                // the (!(name in empty) || empty[name] !== s) condition avoids copying properties in "source"
                // inherited from Object.prototype.  For example, if dest has a custom toString() method,
                // don't overwrite it with the toString() method that source inherited from Object.prototype
                s = source[name];
                if(!(name in dest) || (dest[name] !== s && (!(name in empty) || empty[name] !== s))) {
                    dest[name] = helpers.unreferencePlainObjectsAndArrays(s);
                }
            }

            // ugly, but I don't have other option: http://stackoverflow.com/questions/18563716/how-to-loop-through-object-propertys-created-by-object-defineproperty
            if(source.__esModule){
                dest.__esModule = source.__esModule;
            }

            return dest;
        }

        return source;
    }
    helpers.internalRequire = function(name) {

        if (seen[name]) {
            return seen[name];
        }

        if(!registry[name]) {
            helpers.throwError('Could not find module: ' + name)
        }

        var exports = {};
        var reified = helpers.getDependenciesValues(exports, name);

        registry[name].callback.apply(this, reified);
        seen[name] = exports

        return exports;
    }
    helpers.getDependenciesValues = function(exports, name) {
        var deps = registry[name].deps;
        var reified = [];
        var length = deps.length;
        var dep;

        for (var i = 0; i < length; i++) {

            if (deps[i] === 'exports') {

                reified.push(exports);

            } else {
                try {

                    dep = customRequireDepsHandler.requireDeps(deps[i], null, name)

                    reified.push(dep)

                } catch(err) {
                    customRequireDepsHandler.catchErrors(err, deps[i], name)
                }
            }

        }

        return reified;
    }
    helpers.throwError = function(msg) {
        throw new Error(msg);
    }

    var define = function(name, deps, callback) {

        var value = {};

        if (!callback) {

            value.deps = [];
            value.callback = deps;

        } else {

            value.deps = deps;
            value.callback = callback;

        }

        if(registry[name]) {
            helpers.throwError('duplicatedModule ' + name);
        }

        registry[name] = value;
    }

    var require = function(name, submodule) {
        var module = helpers.internalRequire(name);
        var amd_package = submodule ? module[submodule] : module;
        var result = helpers.unreferencePlainObjectsAndArrays(amd_package);

        return result;
    }

    var list_entries = function(options) {

        var names = [];
        var moduleName;
        var regex = options && options.regex ? options.regex : '';
        var shouldAddModule;

        for (moduleName in registry) {

            shouldAddModule = (regex && moduleName.match(regex)) || !regex;

            if(shouldAddModule) {

                names.push(moduleName);

            }

        }

        return names;

    }

    var setCustomRequireDeps = function(handler){
        customRequireDepsHandler = handler
    }

    return {
        define: define,
        require: require,
        list_entries: list_entries,
        setCustomRequireDeps: setCustomRequireDeps
    }
}

var Errar = function() {

    this.errors = [];
    this.delimiter = '{{DELIMITER}}';
    this.stackDelimiter = '{{>>>}}';
    this.template = [
        '{{title}}',
        'PLUGINS:',
        '{{plugins}}',
        'STACKTRACE:',
        '{{stacktrace}}'
    ].join('\n');

};

Errar.prototype.hasErrors = function() {
    return !!this.errors.length;
};

Errar.prototype.add = function(obj) {
    this.errors.push(obj);
};

Errar.prototype.stringify = function() {

    var summary = this.summary();
    var template = this.template;
    var isArray = function(myArray) {return Object.prototype.toString.call(myArray).indexOf('Array') > -1;};

    for(var key in summary) {
        template = template.replace('{{' + key + '}}', isArray(summary[key]) ? summary[key].join('\n') : summary[key]);
    }

    return template;
};

Errar.prototype.submodulesStringify = function() {

    var hasDelimiter;
    var nestedErrors = '';

    for (var i = 0; i < this.errors.length; i++) {

        if(this.errors[i].content.indexOf(this.delimiter) > -1) {
            hasDelimiter = true;
            nestedErrors = this.errors[i].content;
        }

    }

    var moduleName = this.errors[0].name;
    var result = hasDelimiter ? moduleName + this.stackDelimiter + nestedErrors : this.delimiter + JSON.stringify(this.errors);

    return result;
};

Errar.prototype.summary = function() {

    if(!this.errors.length) {

        var defaultMessage = 'No errors available';

        return {
            title: defaultMessage,
            plugins: defaultMessage,
            stacktrace: defaultMessage
        };
    }

    var errors = this.getRelevantErrors();

    var result = {
        title: this.formatTitle(errors),
        plugins: this.formatPlugins(errors),
        stacktrace: this.parseStacktrace(errors)
    };

    return result;
};

Errar.prototype.getRelevantErrors = function() {

    var errors;

    for (var i = 0; i < this.errors.length; i++) {

        if(this.errors[i].content.indexOf(this.delimiter) > -1) {
            errors = JSON.parse(this.errors[i].content.split(this.delimiter)[1]);
            break;
        }

    }

    if(!errors) {
        errors = this.errors;
    }

    return errors;
};

Errar.prototype.formatTitle = function(errors) {

    var last_error = errors[errors.length - 1];
    var requiredBy = last_error.referrer ? ' required by ' + last_error.referrer : '';
    var result = 'Error at the module: ' + last_error.name + requiredBy;

    return result;
};

Errar.prototype.formatPlugins = function(errors) {

    var result = [];

    for (var i = 0; i < errors.length; i++) {
        result.push('(' + errors[i].plugin + ') ' + errors[i].content);
    }

    return result;
};

Errar.prototype.parseStacktrace = function(errors) {

    var first_module_from_trace = this.errors[0].name;
    var middle_stack = this.getMiddleStacktrace();
    var last_module_from_trace = errors[errors.length - 1].name;

    var result = [];

    for (var i = 0; i < middle_stack.length; i++) {

        if(middle_stack[i]) {
            result.push(middle_stack[i]);
        }

    }

    if(first_module_from_trace && first_module_from_trace !== result[0]) {
        result.splice(0, 0, first_module_from_trace);
    }

    if(last_module_from_trace && last_module_from_trace !== result[result.length - 1]) {
        result.push(last_module_from_trace);
    }

    return result.reverse();
};

Errar.prototype.getMiddleStacktrace = function() {

    var stacktrace = '';

    for (var i = 0; i < this.errors.length; i++) {

        if(this.errors[i].content.indexOf(this.delimiter) > -1) {
            stacktrace = this.errors[i].content.split(this.delimiter)[0];
            break;
        }

    }

    var result = stacktrace.length ? stacktrace.split(this.stackDelimiter) : [];

    return result;
};

/* global Errar */
var NMD = function() { // jshint ignore:line

    var amd = new Core();
    var pipeline = ['default'];
    var PLUGINS_configs = {};

    var define = function(name, deps, callback) {
        amd.define(name, deps, callback);
    }

    var require = function(name, submodule, referrer) {
        /*
            iterate over plugins
            if the current plugin throws an error, move to the next plugin
            if not, return the module
        */
        var result;
        var hasResult;
        var errorManager = new Errar();

        for (var i = 0; i < pipeline.length; i++) {

            try {

                if(!NMD_PLUGINS[pipeline[i]]) {
                    throw new Error('Missing plugin definition for: ' + pipeline[i]);
                }

                result = NMD_PLUGINS[pipeline[i]].call(this, amd.require, PLUGINS_configs[pipeline[i]], name, submodule, referrer);
                hasResult = true;

            } catch(err) {

                errorManager.add({
                    name: name,
                    plugin: pipeline[i],
                    submodule: submodule,
                    referrer: referrer,
                    content: err.message,
                    stack: err.stack
                });

                continue;
            }

            break;

        }

        if(!hasResult) {

            throw new Error(referrer ? errorManager.submodulesStringify() : errorManager.stringify());

        }

        return result;
    }

    var catchErrors = function(err/*, name, referrer*/) {
        throw new Error(err.message);
    }

    amd.setCustomRequireDeps({requireDeps: require, catchErrors: catchErrors})

    return {
        define: define,
        require: require,
        list_entries: amd.list_entries,
        plugins: function(obj) {

            for (var name in obj) {
                PLUGINS_configs[name] = obj[name]
            }

        },
        pipeline: function(list) {

            if(list) {
                pipeline = list
            }

            return pipeline

        },
        version: '0.4.3'
    };

};

var NMD_PLUGINS = {}

NMD_PLUGINS['default'] = function(amd_require, config, name, submodule, referrer) {
    return amd_require(name, submodule, referrer)
}

NMD_PLUGINS.shortcuts = function(amd_require, config, name, submodule) {

    var isShortcut = name.indexOf('@') === 0

    if(!isShortcut) {
        throw new Error(name + ' is not a shortcut')
    }

    var split = name.substring(1).split('/')
    var shortcut = {
        name: split[0],
        value: split.slice(1).join('/')
    }
    var result = amd_require(config[shortcut.name] + shortcut.value, submodule)

    return result

}

NMD_PLUGINS.defaultFile = function(amd_require, config, name, submodule) {

    var hasDelimiter = name.lastIndexOf('/') === (name.length - 1)
    var newModulePath = name + (hasDelimiter ? '' : '/') + config

    return amd_require(newModulePath, submodule)

}

NMD_PLUGINS.relativePaths = function(amd_require, config, name, submodule, referrer) {

    if (name.charAt(0) !== '.') {
        throw new Error(name + ' is not a relative path')
    }

    if(!config) {
        throw new Error('Relative paths are not allowed: ' + name)
    }

    var parts = name.split('/')
    var parentBase = referrer.split('/').slice(0, -1)

    for (var i = 0; i < parts.length; i++) {

        var part = parts[i];

        if (part === '..') {

            parentBase.pop();

        } else if (part === '.') {

            continue;

        } else {

            parentBase.push(part);

        }

    }

    var result = parentBase.join('/')

    return amd_require(result, submodule, referrer)

}

 mainContext.nucleoAMD = NMD;})(this);