iniettore/lib/Container.js

'use strict'

var mod$0 = require('./signals');var ACQUIRE = mod$0.ACQUIRE;var RELEASE = mod$0.RELEASE;var DISPOSE = mod$0.DISPOSE;
var mod$1 = require('./constants');var CONTAINER_ALIAS = mod$1.CONTAINER_ALIAS;var CONTEXT_ALIAS = mod$1.CONTEXT_ALIAS;var CHILD_ALIAS = mod$1.CHILD_ALIAS;
var VALUE = require('./options').VALUE;
var mod$2 = require('./utils');var generateMask = mod$2.generateMask;var noop = mod$2.noop;var isEagerSingleton = mod$2.isEagerSingleton;
var resolvers = require('./resolvers');
var createContext = require('./createContext');



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

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

		this.$Container_mappings = mappings || {}
		this.$Container_resolvers = resolvers
		this.$Container_logger = logger
		this.$Container_resolving = {}
		this.$Container_pending = []
		this.$Container_children = {}
		this.$Container_signalRelease = signalRelease || noop
		
		this.$Container_bind(CONTAINER_ALIAS, this, VALUE, [])
		context = this.$Container_context = createContext(this.$Container_bind.bind(this))
		this.$Container_bind(CONTEXT_ALIAS, context, VALUE, [])
		conf(context)
		context.flush()
		this.$Container_unbind(CONTEXT_ALIAS)
	}

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

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

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

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

	Container.prototype.release=function(alias) {
		try {
			this.$Container_mappings[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.$Container_children).length + 1
		var child = new Container(conf, this.$Container_logger, Object.create(this.$Container_mappings), this.$Container_releaseChild.bind(this, id))

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

	Container.prototype.dispose=function() {
		this.$Container_disposeChildren()
		this.$Container_disposeInstances()
		this.$Container_signalRelease()
		this.$Container_signalRelease = noop
	};

	Container.prototype.$Container_disposeChildren=function() {
		var children = this.$Container_children
		var id

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

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

	Container.prototype.$Container_disposeInstances=function() {
		var mappings = this.$Container_mappings
		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.$Container_bind=function(alias, value, type, deps) {
		if ( !(type in this.$Container_resolvers) ) {
			throw new Error('Invalid flags combination. See documentation for valid flags combinations.')
		}
		this.$Container_mappings[alias] = this.$Container_resolvers[type].call(null, value, this.$Container_resolve.bind(this, deps), this.$Container_release.bind(this, deps))
		if (isEagerSingleton(type)) {
			this.get(alias)
		}
	};

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

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

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


module.exports = Container