iniettore/dist/iniettore.js

!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.iniettore=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
'use strict'

var mod$5 = _dereq_('./signals');var ACQUIRE = mod$5.ACQUIRE;var RELEASE = mod$5.RELEASE;var DISPOSE = mod$5.DISPOSE;
var mod$6 = _dereq_('./constants');var CONTAINER_ALIAS = mod$6.CONTAINER_ALIAS;var CONTEXT_ALIAS = mod$6.CONTEXT_ALIAS;
var VALUE = _dereq_('./options').VALUE;
var mod$7 = _dereq_('./utils');var generateMask = mod$7.generateMask;var noop = mod$7.noop;var isEagerSingleton = mod$7.isEagerSingleton;
var resolvers = _dereq_('./resolvers');
var createContext = _dereq_('./createContext');



	function Container(conf, logger, mappings, signalRelease) {
		var context

		if (typeof conf !== 'function') {
			throw new Error('Invalid container creation, missing contribution function')
		}

		this.$Container0 = mappings || {}
		this.$Container1 = resolvers
		this.$Container2 = logger
		this.$Container3 = {}
		this.$Container4 = []
		this.$Container5 = {}
		this.$Container6 = signalRelease || noop
		
		this.$Container7(CONTAINER_ALIAS, this, VALUE, [])
		context = this.$Container8 = createContext(this.$Container7.bind(this))
		this.$Container7(CONTEXT_ALIAS, context, VALUE, [])
		conf(context)
		context.flush()
		this.$Container9(CONTEXT_ALIAS)
	}

	Container.prototype.get=function(alias, transients) {
		return this.$Container2.log(("resolving '" + alias + "'"), function()  {
			if (this.$Container3[alias]) { throw new Error(("Circular dependency detected while resolving '" + alias + "'")) }
			if (!(alias in this.$Container0)) { throw new Error(("'" + alias + "' is not available. Has it ever been registered?.")) }

			this.$Container3[alias] = true
			try {
				return this.$Container0[alias](ACQUIRE)
			} catch(err) {
				err.message = ("Failed while resolving '" + alias + "' due to:\n\t" + err.message)
				throw err
			} finally {
				this.$Container3[alias] = false	
			}
		}.bind(this))
	};

	Container.prototype.using=function(transientsDeps) {
		return {
			get: function(alias)  {
				var context = this.$Container8
				var dep

				for (dep in transientsDeps) {
					context.map(dep).to(transientsDeps[dep]).as(VALUE)
				}
				context.flush()
				this.get(alias)
				for (dep in transientsDeps) {
					this.$Container9(dep)
				}
			}.bind(this)
		}
	};

	Container.prototype.release=function(alias) {
		try {
			this.$Container0[alias](RELEASE)
		} catch(err) {
			err.message = ("Failed while releasing '" + alias + "' due to:\n\t" + err.message)
			throw err
		}
	};

	Container.prototype.createChild=function(conf) {
		var id = Object.keys(this.$Container5).length + 1
		var child = new Container(conf, this.$Container2, Object.create(this.$Container0), this.$Containera.bind(this, id))

		this.$Container5[id] = child
		return child
	};

	Container.prototype.dispose=function() {
		this.$Containerb()
		this.$Containerc()
		this.$Container6()
		this.$Container6 = noop
	};

	Container.prototype.$Containerd=function(alias) {

	};

	Container.prototype.$Containerb=function() {
		var children = this.$Container5
		var id

		for (id in children) {
			/* istanbul ignore else  */
			if (children.hasOwnProperty(id)) {
				children[id].dispose()
				this.$Containera(id)
			}
		}
	};

	Container.prototype.$Containera=function(id) {
		delete this.$Container5[id]
	};

	Container.prototype.$Containerc=function() {
		var mappings = this.$Container0
		var alias

		for (alias in mappings) {
			/* istanbul ignore else  */
			if (mappings.hasOwnProperty(alias)) {
				try {
					mappings[alias](DISPOSE)
				} catch(err) {
					err.message = ("Failed while disposing '" + alias + "' due to:\n\t" + err.message)
					throw err
				}
				delete mappings[alias]
			}
		}
	};

	Container.prototype.$Container7=function(alias, value, type, deps) {
		if ( !(type in this.$Container1) ) {
			throw new Error('Invalid flags combination. See documentation for valid flags combinations.')
		}
		this.$Container0[alias] = this.$Container1[type].call(null, value, this.$Containere.bind(this, deps), this.$Containerf.bind(this, deps))
		if (isEagerSingleton(type)) {
			this.get(alias)
		}
	};

	Container.prototype.$Container9=function(alias) {
		this.$Container0[alias](DISPOSE)
		delete this.$Container0[alias]
	};

	Container.prototype.$Containerf=function(deps) {
		return deps.forEach(function(dep)  {
			this.release(dep)
		}.bind(this))
	};

	Container.prototype.$Containere=function(deps) {
		return deps.map(function(dep)  {
			return this.get(dep)
		}.bind(this))
	};


module.exports = Container

},{"./constants":3,"./createContext":4,"./options":7,"./resolvers":8,"./signals":9,"./utils":11}],2:[function(_dereq_,module,exports){
'use strict'


	function Logger(options) {
		this.$Logger0 = options
		this.$Logger1 = 0
		this.$Logger2 = {}
	}

	Logger.prototype.log=function(message, func) {
		var result

		if ("production" !== 'production' && this.$Logger0.debug) {
			this.$Logger3(message)
			result = func()
			this.$Logger4(message)
			return result
		}
		return func()
	};

	Logger.prototype.$Logger3=function(message) {
		var indentation = this.$Logger5()
		var now = new Date()

		this.$Logger2[message] = now

		console.log(("[" + now.toISOString() + "] " + indentation + "Starting " + message + "..."))
	};

	Logger.prototype.$Logger4=function(message) {
		var indentation = this.$Logger6()
		var now = new Date()
		var elapsed = now - this.$Logger2[message]

		console.log(("[" + now.toISOString() + "] " + indentation + "Finished " + message + " after " + elapsed + " ms"))
	};

	Logger.prototype.$Logger5=function() {
		return Array(++this.$Logger1).join('  ')
	};

	Logger.prototype.$Logger6=function() {
		return Array(this.$Logger1--).join('  ')
	};


module.exports = Logger

},{}],3:[function(_dereq_,module,exports){
'use strict'

var CONTAINER_ALIAS = '$container'
var CONTEXT_ALIAS = '$context'

module.exports.CONTAINER_ALIAS = CONTAINER_ALIAS;module.exports.CONTEXT_ALIAS = CONTEXT_ALIAS;

},{}],4:[function(_dereq_,module,exports){
'use strict';

var generateMask = _dereq_('./utils').generateMask;
var mod$14 = _dereq_('./options');var BLUEPRINT = mod$14.BLUEPRINT;var PROVIDER = mod$14.PROVIDER;
var mod$15 = _dereq_('./constants');var CONTAINER_ALIAS = mod$15.CONTAINER_ALIAS;var CONTEXT_ALIAS = mod$15.CONTEXT_ALIAS;

var ALIAS_IDX = 0
var VALUE_IDX = 1
var TYPE_IDX = 2
var DEPS_IDX = 3

function createChildContainerFactory(conf) {
	return function (container) {
		return container.createChild(conf)
	}
}

function createExporter(containerFactory, exportAlias) {
	return function (container) {
		return containerFactory(container).get(exportAlias)
	}
}

module.exports = function createContext(contribute) {

	var pending = []
	var context = {

		map: function(alias)  {
			context.flush()
			pending.push(alias)

			return {
				to: function(value)  {

					pending.push(value)

					return {
						as: function()  {var flags=Array.prototype.slice.call(arguments,0);
							var mask = generateMask(flags)

							if (mask === BLUEPRINT) {
								// test if VALUE is a function
								flags = [PROVIDER]
								pending[VALUE_IDX] = createChildContainerFactory(pending[VALUE_IDX])
								pending.push(generateMask(flags))
								pending.push([CONTAINER_ALIAS])
								
								return {
									exports: function(alias)  {
										pending[VALUE_IDX] = createExporter(pending[VALUE_IDX], alias)
										return {
											map: context.map
										}
									},
									map: context.map
								}
							}

							pending.push(mask)
							
							return {
								map: context.map,
								
								injecting: function()  {var deps=Array.prototype.slice.call(arguments,0);
									pending.push(deps)

									return {
										map: context.map
									}
								}
							}
						}
					}
				}
			}
		},

		flush: function()  {
			var deps = pending[DEPS_IDX] || []

			if (pending.length > 2) {
				contribute(pending[ALIAS_IDX], pending[VALUE_IDX], pending[TYPE_IDX], deps)
				pending = []
			}
		}
	}

	return context
}

},{"./constants":3,"./options":7,"./utils":11}],5:[function(_dereq_,module,exports){
'use strict'

var Container = _dereq_('./Container');
var Logger = _dereq_('./Logger');

function create(conf, options) {
	var logger

	options = options || {}
	logger = new Logger(options)

	return new Container(conf, logger)
} module.exports.create = create;

},{"./Container":1,"./Logger":2}],6:[function(_dereq_,module,exports){
'use strict'

module.exports = function instanciate(Ctor, deps) {
	var Surrogate, instance
	
	Surrogate = function () {}
	Surrogate.prototype = Ctor.prototype

	instance = new Surrogate()

	Ctor.apply(instance, deps)

	return instance
}

},{}],7:[function(_dereq_,module,exports){
'use strict'

module.exports = [
	'VALUE',
	'PROVIDER',
	'CONSTRUCTOR',
	'SINGLETON',
	'FUNCTION',
	'INSTANCE',
	'PERSISTENT',
	'TRANSIENT',
	'BLUEPRINT',
	'EAGER'
].reduce(function (options, flag, idx) {
	options[flag] = Math.pow(2, idx)
	return options
}, {})

},{}],8:[function(_dereq_,module,exports){
'use strict'

var mod$11 = _dereq_('./utils');
var leftCurryTwice = mod$11.leftCurryTwice;
var identity = mod$11.identity;
var compose = mod$11.compose;
var partial = mod$11.partial;

var resolveDeps = mod$11.resolveDeps;
var invoke = mod$11.invoke;

var instanciate = mod$11.instanciate;
var singletonify = mod$11.singletonify;

var generateMask = mod$11.generateMask;


var mod$12 = _dereq_('./options');
var VALUE = mod$12.VALUE;
var PROVIDER = mod$12.PROVIDER;
var CONSTRUCTOR = mod$12.CONSTRUCTOR;
var SINGLETON = mod$12.SINGLETON;
var FUNCTION = mod$12.FUNCTION;
var INSTANCE = mod$12.INSTANCE;
var TRANSIENT = mod$12.TRANSIENT;
var PERSISTENT = mod$12.PERSISTENT;
var EAGER = mod$12.EAGER;


var resolvers = {}

resolvers[ generateMask([VALUE]) ] = compose(leftCurryTwice, resolveDeps)(identity)
resolvers[ generateMask([FUNCTION]) ] = compose(leftCurryTwice, resolveDeps)(partial)
resolvers[ generateMask([CONSTRUCTOR]) ] = compose(leftCurryTwice, resolveDeps)(instanciate)
resolvers[ generateMask([TRANSIENT, CONSTRUCTOR, SINGLETON]) ] = singletonify(instanciate)
resolvers[ generateMask([PERSISTENT, CONSTRUCTOR, SINGLETON]) ] = singletonify(instanciate, true)
resolvers[ generateMask([PROVIDER]) ] = compose(leftCurryTwice, resolveDeps)(invoke)
resolvers[ generateMask([TRANSIENT, SINGLETON, PROVIDER]) ] = singletonify(invoke)
resolvers[ generateMask([PERSISTENT, SINGLETON, PROVIDER]) ] = singletonify(invoke, true)

resolvers[ generateMask([EAGER, SINGLETON, PROVIDER])] = singletonify(invoke, true)
resolvers[ generateMask([EAGER, CONSTRUCTOR, SINGLETON]) ] = singletonify(instanciate, true)

// aliases
resolvers[ generateMask([INSTANCE]) ] = resolvers[ generateMask([VALUE]) ]

module.exports = resolvers

},{"./options":7,"./utils":11}],9:[function(_dereq_,module,exports){
'use strict'

module.exports = {
	ACQUIRE: 'ACQUIRE',
	RELEASE: 'RELEASE',
	DISPOSE: 'DISPOSE'
}

},{}],10:[function(_dereq_,module,exports){
'use strict'

var mod$17 = _dereq_('./signals');var ACQUIRE = mod$17.ACQUIRE;var RELEASE = mod$17.RELEASE;var DISPOSE = mod$17.DISPOSE;

module.exports = function singletonify(create, persistent) {

	persistent = persistent || false

	return function (value, resolveDeps, releaseDeps) {

		var handlers = {}
		var count = 0
		var instance

		function dispose() {
			if (typeof instance.dispose === 'function') {
				instance.dispose()
			}
			instance = undefined
			count = 0
		}

		handlers[ACQUIRE] = function (value) {
			if (typeof instance === 'undefined') {
				instance = create.call(this, value, resolveDeps())
			}
			count++
			return instance
		}

		handlers[RELEASE] = function (value) {
			count--
			if (count == 0 && !persistent) {
				releaseDeps()
				dispose()
			}
		}

		handlers[DISPOSE] = function (value) {
			if (instance) {
				releaseDeps()
				dispose()
			}
		}

		return function (signal) {
			return handlers[signal].call(this, value)
		}
	}
}

},{"./signals":9}],11:[function(_dereq_,module,exports){
'use strict'

var instanciate = _dereq_('./instanciate');
var singletonify = _dereq_('./singletonify');
var mod$10 = _dereq_('./options');var EAGER = mod$10.EAGER;var SINGLETON = mod$10.SINGLETON;var PROVIDER = mod$10.PROVIDER;var CONSTRUCTOR = mod$10.CONSTRUCTOR;

var EAGER_SINGLETON_PROVIDER = generateMask([EAGER, SINGLETON, PROVIDER])
var EAGER_SINGLETON_CONSTRUCTOR = generateMask([EAGER, SINGLETON, CONSTRUCTOR])

function identity(value) { return value } module.exports.identity = identity;

function leftCurryTwice(fn) {
	return function firstCurry() {var firstArgs=Array.prototype.slice.call(arguments,0);
		return function secondCurry() {var secondArgs=Array.prototype.slice.call(arguments,0);
			return fn.apply(null, firstArgs.concat(secondArgs))
		}
	}
} module.exports.leftCurryTwice = leftCurryTwice;

function compose() {var funcs=Array.prototype.slice.call(arguments,0);
	return function () {var args=Array.prototype.slice.call(arguments,0);

		var i

		for (i = funcs.length - 1; i >= 0; i--) {
			args = [funcs[i].apply(this, args)]
		}
		return args[0]
	}
} module.exports.compose = compose;

function resolveDeps(fn) {
	return function (value, resolve, release, signal) {
		return fn.call(this, value, resolve())
	}
} module.exports.resolveDeps = resolveDeps;

function invoke(fn, deps) {
	return fn.apply(null, deps)
} module.exports.invoke = invoke;

function partial(func, boundArgs) {
	return function () {var args=Array.prototype.slice.call(arguments,0);
		return func.apply(this, boundArgs.concat(args))
	}
} module.exports.partial = partial;

function generateMask(flags) {
	return flags.reduce(function(prev, curr)  {return prev | curr;}, 0)
} module.exports.generateMask = generateMask;

function isEagerSingleton(type) {
	return [EAGER_SINGLETON_PROVIDER, EAGER_SINGLETON_CONSTRUCTOR].indexOf(type) > -1
} module.exports.isEagerSingleton = isEagerSingleton;

function noop() {} module.exports.noop = noop;

module.exports.instanciate = instanciate;module.exports.singletonify = singletonify;

},{"./instanciate":6,"./options":7,"./singletonify":10}]},{},[5])
(5)
});