injecty/lib/container.js

Micro library for dependency injection and inversion of control containers

{
    var _ns_ = {
        id: 'injecty.lib.macros',
        doc: void 0
    };
}
void 0;
void 0;
void 0;
{
    var _ns_ = {
        id: 'injecty.lib.container',
        doc: void 0
    };
    var injecty_lib_types = require('./types');
    var newPool = injecty_lib_types.newPool;
    var injecty_lib_utils = require('./utils');
    var isFn = injecty_lib_utils.isFn;
    var isArr = injecty_lib_utils.isArr;
    var isStr = injecty_lib_utils.isStr;
    var chain = injecty_lib_utils.chain;
    var fnName = injecty_lib_utils.fnName;
    var parseArgs = injecty_lib_utils.parseArgs;
}
var getter = function getter(pool) {
    return function (name) {
        return pool.map[name];
    };
};
var remove = function remove(pool) {
    return function (name) {
        return (pool.map[name] === void 0 ? false : true) ? pool.map[name] = void 0 : void 0;
    };
};
var register = function register(pool) {
    return function (name, value) {
        return isFn(name) ? function () {
            var lambdaø1 = name;
            var nameø2 = fnName(lambdaø1);
            return nameø2 ? pool.map[nameø2] = lambdaø1 : (function () {
                throw new TypeError('Function must have a name');
            })();
        }.call(this) : isStr(name) ? pool.map[name] = value : (function () {
            throw new TypeError('First argument is invalid');
        })();
    };
};
var flush = function flush(pool) {
    return function () {
        return pool.map = {};
    };
};
var getLambda = function getLambda(lambda) {
    return isArr(lambda) ? lambda.filter(function (val) {
        return isFn(val);
    })[0] : lambda;
};
var getArgs = function getArgs(lambda) {
    return isFn(lambda) ? isArr(lambda.$inject) ? lambda.$inject : parseArgs(lambda) : isArr(lambda) ? lambda.filter(isStr) : void 0;
};
var annotateArgs = function annotateArgs(lambda) {
    return function () {
        var argsø1 = getArgs(lambda);
        return isArr(argsø1) ? argsø1 : [];
    }.call(this);
};
var injector = function injector(getter, deps) {
    return isArr(deps) ? deps.map(function (name) {
        return function () {
            var depø1 = getter(name);
            return depø1 === void 0 ? (function () {
                throw new Error('Dependency not registered: ' + name);
            })() : depø1;
        }.call(this);
    }) : void 0;
};
var invoke = function invoke(getter) {
    return function (lambda) {
        return function () {
            var argsø1 = getArgs(lambda);
            var lambdaø2 = getLambda(lambda);
            var injectionsø1 = injector(getter, argsø1);
            return lambdaø2.apply(void 0, injectionsø1);
        }.call(this);
    };
};
var inject = function inject(invoke) {
    return function (lambda) {
        return function () {
            return invoke(lambda);
        };
    };
};
var injectable = function injectable(getter) {
    return function (name) {
        return getter(name) === void 0 ? false : true;
    };
};
var annotate = function annotate(getter) {
    return function (lambda) {
        return isStr(lambda) ? annotateArgs(getter(lambda)) : annotateArgs(lambda);
    };
};
var chainableMethods = [
    'register',
    'set',
    'flush',
    'remove'
];
var chainMethods = function chainMethods(ctx) {
    Object.keys(ctx).forEach(function (name) {
        return (chainableMethods.indexOf(name) === -1 ? false : true) ? function () {
            var methodø1 = ctx[name];
            return isFn(methodø1) ? ctx[name] = chain(ctx, methodø1) : void 0;
        }.call(this) : void 0;
    });
    return ctx;
};
var satisfies = function satisfies(getter) {
    return function (lamdba) {
        return function () {
            var argsø1 = annotateArgs(lamdba);
            return argsø1.filter(function (name) {
                return getter(name) === void 0 ? false : true;
            }).length === argsø1.length;
        }.call(this);
    };
};
var poolAccessor = function poolAccessor(pool) {
    return function () {
        return pool.map;
    };
};
var container = exports.container = function container(parent) {
    return function () {
        var poolø1 = newPool(parent);
        var getø1 = getter(poolø1);
        var setø1 = register(poolø1);
        var invokeø1 = invoke(getø1);
        var ctx = {
            'get': getø1,
            'require': getø1,
            'set': setø1,
            'register': setø1,
            'invoke': invokeø1,
            'inject': inject(invokeø1),
            'flush': flush(poolø1),
            'remove': remove(poolø1),
            '$$pool': poolAccessor(poolø1),
            'annotate': annotate(getø1),
            'satisfies': satisfies(getø1),
            'dependencies': Object.keys(poolø1),
            'injectable': injectable(getø1)
        };
        return chainMethods(ctx);
    }.call(this);
};