jpex-defaults/dist/jpex-defaults.js

Core factories for Jpex

(function(){
  var __jpex_modules__ = [];
  // /src/$copy.js
__jpex_modules__[1] = function(require, module, exports){
  module.exports = function ($typeof) {
    var exists;
    var alreadyCopied = function (obj, hash) {
        for (var x = 0, l = hash.length; x < l; x++){
            if (hash[x].from === obj){
                return obj;
            }
        }
    };
    var copier = function (from, to, recur, hash) {
        hash = hash || [];

        switch($typeof(from)){
        case 'string':
        case 'number':
        case 'boolean':
        case 'function':
        case 'null':
        case 'undefined':
            return from;

        case 'date':
            return new Date(from);

        case 'regexp':
            var flags = [];
            if (from.global){flags.push('g');}
            if (from.ignoreCase){flags.push('i');}
            return new RegExp(from.source, flags.join(''));

        case 'array':
            exists = alreadyCopied(from, hash);
            if (exists){
                return exists.to;
            }else{
                to = [];
                hash.push({from : from, to : to});
                from.forEach(function (item) {
                    to.push(recur ? copier(item, undefined, true, hash) : item);
                });
                return to;
            }

        case 'object':
            exists = alreadyCopied(from, hash);
            if (exists){
                return exists.to;
            }else{
                to = to || {};
                hash.push({from : from, to : to});
            }

            Object.keys(from).forEach(function (key) {
                to[key] = recur ? copier(from[key], to[key], recur, hash) : from[key];
            });
            return to;

        default:
            throw new Error('Unexpected type: ' + $typeof(from));
        }
    };

    var $copy = function (obj) {
        return $copy.shallow(obj);
    };
    $copy.shallow = function (obj) {
        return copier(obj);
    };
    $copy.deep = function (obj) {
        return copier(obj, null, true);
    };
    $copy.extend = function () {
        var args = Array.prototype.slice.call(arguments);
        var target = args.shift();
        args.forEach(function (arg) {
            copier(arg, target, true);
        });
        return target;
    };
    return $copy;
};

};

// /src/$log.js
__jpex_modules__[2] = function(require, module, exports){
  module.exports = function () {
    /* eslint-disable no-console*/
    var $log = function () {
        return $log.log.apply(null, arguments);
    };
    $log.log = function () {
        return console.log.apply(null, arguments);
    };
    $log.info = function () {
        return console.info.apply(null, arguments);
    };
    $log.warn = function () {
        return console.warn.apply(null, arguments);
    };
    $log.error = function () {
        return console.error.apply(null, arguments);
    };
    return $log;
};

};

// /src/$$promise.js
__jpex_modules__[3] = function(require, module, exports){
  module.exports = function () {
    return Promise; // eslint-disable-line
};

};

// /src/$promise.js
__jpex_modules__[4] = function(require, module, exports){
  module.exports = function (Promise) {
    var $promise = function (fn) {
        return new Promise(fn);
    };
    $promise.all = Promise.all.bind(Promise);
    $promise.race = Promise.race.bind(Promise);
    $promise.reject = Promise.reject.bind(Promise);
    $promise.resolve = Promise.resolve.bind(Promise);

    return $promise;
};

};

// /src/$timeout.js
__jpex_modules__[5] = function(require, module, exports){
  module.exports = function () {
    function timeout(cb, delay){
        return setTimeout(cb, delay);
    }
    timeout.clear = function(t){
        return clearTimeout(t);
    };
    return timeout;
};

};

// /src/$interval.js
__jpex_modules__[6] = function(require, module, exports){
  module.exports = function(){
    function interval(cb, delay){
        return setInterval(cb, delay);
    }
    interval.clear = function (t) {
        return clearInterval(t);
    };
    return interval;
};

};

// /src/$immediate.js
__jpex_modules__[7] = function(require, module, exports){
  module.exports = function ($timeout) {
    var native = (typeof setImmediate === 'function');
    function immediate(cb) {
        return native ? setImmediate(cb) : $timeout(cb, 0); // eslint-disable-line
    }
    immediate.clear = function (t) {
        return native ? clearImmediate(t) : $timeout.clear(t); // eslint-disable-line
    };
    return immediate;
};

};

// /src/$typeof.js
__jpex_modules__[8] = function(require, module, exports){
  module.exports = function () {
    var standardTypes = ['number', 'boolean', 'string', 'array', 'function', 'date', 'regexp', 'null', 'undefined'];

    return function(obj, returnClassName){
        var t = Object.prototype.toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase();
        return (!returnClassName && standardTypes.indexOf(t) < 0) ? 'object' : t;
    };
};

};

// /src/index.js
__jpex_modules__[0] = function(require, module, exports){
  var $copy = require(1);
var $log = require(2);
var $$promise = require(3);
var $promise = require(4);
var $timeout = require(5);
var $interval = require(6);
var $immediate = require(7);
var $typeof = require(8);

exports.name = 'jpex-defaults';
exports.silent = true;

exports.install = function (options) {
    var Jpex = options.Jpex;

    Jpex.register.factory('$copy', ['$typeof'], $copy).lifecycle.application();

    Jpex.register.factory('$log', [], $log).lifecycle.application();

    Jpex.register.factory('$$promise', [], $$promise).lifecycle.application();

    Jpex.register.factory('$promise', ['$$promise'], $promise).lifecycle.application();

    Jpex.register.factory('$timeout', [], $timeout).lifecycle.application();

    Jpex.register.factory('$interval', [], $interval).lifecycle.application();

    Jpex.register.factory('$immediate', ['$timeout'], $immediate).lifecycle.application();

    Jpex.register.factory('$typeof', [], $typeof).lifecycle.application();
};

if (typeof window !== 'undefined' && window.Jpex && typeof window.Jpex.use === 'function'){
    window.Jpex.use(exports);
}

};

  var __jpex_require__ = function(target){
    if (__jpex_require__.cache[target]){
      return __jpex_require__.cache[target];
    }
    var module = { exports : {} };
    var fn = __jpex_modules__[target];
    if (!fn){
      throw new Error('Could not find module ' + target);
    }
    fn(__jpex_require__, module, module.exports);
    __jpex_require__.cache[target] = module.exports;

    return module.exports;
  };
  __jpex_require__.cache = [];

  if (typeof module !== 'undefined'){
    module.exports = __jpex_require__(0);
  }else if (typeof window !== 'undefined'){
    window['jpexDefaults'] = __jpex_require__(0);
  }
}());