inversify 6.0.3 → 6.1.1

package/es/container/module_activation_store.js

@@ -4,20 +4,18 @@ var ModuleActivationStore = (function () {
         this._map = new Map();
     }
     ModuleActivationStore.prototype.remove = function (moduleId) {
-        if (this._map.has(moduleId)) {
-            var handlers = this._map.get(moduleId);
-            this._map.delete(moduleId);
-            return handlers;
+        var handlers = this._map.get(moduleId);
+        if (handlers === undefined) {
+            return this._getEmptyHandlersStore();
         }
-        return this._getEmptyHandlersStore();
+        this._map.delete(moduleId);
+        return handlers;
     };
     ModuleActivationStore.prototype.addDeactivation = function (moduleId, serviceIdentifier, onDeactivation) {
-        this._getModuleActivationHandlers(moduleId)
-            .onDeactivations.add(serviceIdentifier, onDeactivation);
+        this._getModuleActivationHandlers(moduleId).onDeactivations.add(serviceIdentifier, onDeactivation);
     };
     ModuleActivationStore.prototype.addActivation = function (moduleId, serviceIdentifier, onActivation) {
-        this._getModuleActivationHandlers(moduleId)
-            .onActivations.add(serviceIdentifier, onActivation);
+        this._getModuleActivationHandlers(moduleId).onActivations.add(serviceIdentifier, onActivation);
     };
     ModuleActivationStore.prototype.clone = function () {
         var clone = new ModuleActivationStore();
@@ -40,7 +38,7 @@ var ModuleActivationStore = (function () {
     ModuleActivationStore.prototype._getEmptyHandlersStore = function () {
         var handlersStore = {
             onActivations: new Lookup(),
-            onDeactivations: new Lookup()
+            onDeactivations: new Lookup(),
         };
         return handlersStore;
     };

package/es/interfaces/interfaces.js

@@ -1,5 +1 @@
-var interfaces;
-(function (interfaces) {
-    ;
-})(interfaces || (interfaces = {}));
-export { interfaces };
+export {};

package/es/inversify.js

@@ -1,15 +1,14 @@
 import * as keys from './constants/metadata_keys';
+export { LazyServiceIdentifier } from '@inversifyjs/common';
 export var METADATA_KEY = keys;
 export { Container } from './container/container';
-export { BindingScopeEnum, BindingTypeEnum, TargetTypeEnum } from './constants/literal_types';
-export { AsyncContainerModule, ContainerModule } from './container/container_module';
+export { BindingScopeEnum, BindingTypeEnum, TargetTypeEnum, } from './constants/literal_types';
+export { AsyncContainerModule, ContainerModule, } from './container/container_module';
 export { createTaggedDecorator } from './annotation/decorator_utils';
 export { injectable } from './annotation/injectable';
 export { tagged } from './annotation/tagged';
 export { named } from './annotation/named';
 export { inject } from './annotation/inject';
-export { LazyServiceIdentifier } from './annotation/lazy_service_identifier';
-export { LazyServiceIdentifier as LazyServiceIdentifer } from './annotation/lazy_service_identifier';
 export { optional } from './annotation/optional';
 export { unmanaged } from './annotation/unmanaged';
 export { multiInject } from './annotation/multi_inject';
@@ -18,8 +17,7 @@ export { postConstruct } from './annotation/post_construct';
 export { preDestroy } from './annotation/pre_destroy';
 export { MetadataReader } from './planning/metadata_reader';
 export { id } from './utils/id';
-export { interfaces } from './interfaces/interfaces';
 export { decorate } from './annotation/decorator_utils';
-export { traverseAncerstors, taggedConstraint, namedConstraint, typeConstraint } from './syntax/constraint_helpers';
+export { traverseAncerstors, taggedConstraint, namedConstraint, typeConstraint, } from './syntax/constraint_helpers';
 export { getServiceIdentifierAsString } from './utils/serialization';
 export { multiBindToService } from './utils/binding_utils';

package/es/planning/metadata_reader.js

@@ -3,15 +3,17 @@ var MetadataReader = (function () {
     function MetadataReader() {
     }
     MetadataReader.prototype.getConstructorMetadata = function (constructorFunc) {
-        var compilerGeneratedMetadata = Reflect.getMetadata(METADATA_KEY.PARAM_TYPES, constructorFunc);
+        var _a;
+        var compilerGeneratedMetadata = (_a = Reflect.getMetadata(METADATA_KEY.DESIGN_PARAM_TYPES, constructorFunc)) !== null && _a !== void 0 ? _a : [];
         var userGeneratedMetadata = Reflect.getMetadata(METADATA_KEY.TAGGED, constructorFunc);
         return {
             compilerGeneratedMetadata: compilerGeneratedMetadata,
-            userGeneratedMetadata: userGeneratedMetadata || {}
+            userGeneratedMetadata: userGeneratedMetadata !== null && userGeneratedMetadata !== void 0 ? userGeneratedMetadata : {},
         };
     };
     MetadataReader.prototype.getPropertiesMetadata = function (constructorFunc) {
-        var userGeneratedMetadata = Reflect.getMetadata(METADATA_KEY.TAGGED_PROP, constructorFunc) || [];
+        var _a;
+        var userGeneratedMetadata = (_a = Reflect.getMetadata(METADATA_KEY.TAGGED_PROP, constructorFunc)) !== null && _a !== void 0 ? _a : {};
         return userGeneratedMetadata;
     };
     return MetadataReader;

package/es/planning/planner.js

@@ -1,35 +1,35 @@
+import { ClassElementMetadataKind, getClassElementMetadataFromLegacyMetadata, LegacyTargetImpl as TargetImpl, } from '@inversifyjs/core';
 import { BindingCount } from '../bindings/binding_count';
 import * as ERROR_MSGS from '../constants/error_msgs';
-import { BindingTypeEnum, TargetTypeEnum } from '../constants/literal_types';
+import { BindingTypeEnum } from '../constants/literal_types';
 import * as METADATA_KEY from '../constants/metadata_keys';
 import { isStackOverflowException } from '../utils/exceptions';
-import { circularDependencyToException, getServiceIdentifierAsString, listMetadataForTarget, listRegisteredBindingsForServiceIdentifier } from '../utils/serialization';
+import { circularDependencyToException, getServiceIdentifierAsString, listMetadataForTarget, listRegisteredBindingsForServiceIdentifier, } from '../utils/serialization';
 import { Context } from './context';
 import { Metadata } from './metadata';
 import { Plan } from './plan';
-import { getBaseClassDependencyCount, getDependencies, getFunctionName } from './reflection_utils';
+import { getBaseClassDependencyCount, getDependencies, getFunctionName, } from './reflection_utils';
 import { Request } from './request';
-import { Target } from './target';
 function getBindingDictionary(cntnr) {
     return cntnr._bindingDictionary;
 }
 function _createTarget(isMultiInject, targetType, serviceIdentifier, name, key, value) {
-    var metadataKey = isMultiInject ? METADATA_KEY.MULTI_INJECT_TAG : METADATA_KEY.INJECT_TAG;
-    var injectMetadata = new Metadata(metadataKey, serviceIdentifier);
-    var target = new Target(targetType, name, serviceIdentifier, injectMetadata);
-    if (key !== undefined) {
-        var tagMetadata = new Metadata(key, value);
-        target.metadata.push(tagMetadata);
+    var metadataList = _getTargetMetadata(isMultiInject, serviceIdentifier, key, value);
+    var classElementMetadata = getClassElementMetadataFromLegacyMetadata(metadataList);
+    if (classElementMetadata.kind === ClassElementMetadataKind.unmanaged) {
+        throw new Error('Unexpected metadata when creating target');
     }
+    var target = new TargetImpl(name, classElementMetadata, targetType);
     return target;
 }
 function _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target) {
     var bindings = getBindings(context.container, target.serviceIdentifier);
     var activeBindings = [];
     if (bindings.length === BindingCount.NoBindingsAvailable &&
-        context.container.options.autoBindInjectable &&
+        context.container.options.autoBindInjectable === true &&
         typeof target.serviceIdentifier === 'function' &&
-        metadataReader.getConstructorMetadata(target.serviceIdentifier).compilerGeneratedMetadata) {
+        metadataReader.getConstructorMetadata(target.serviceIdentifier)
+            .compilerGeneratedMetadata) {
         context.container.bind(target.serviceIdentifier).toSelf();
         bindings = getBindings(context.container, target.serviceIdentifier);
     }
@@ -45,6 +45,18 @@ function _getActiveBindings(metadataReader, avoidConstraints, context, parentReq
     _validateActiveBindingCount(target.serviceIdentifier, activeBindings, target, context.container);
     return activeBindings;
 }
+function _getTargetMetadata(isMultiInject, serviceIdentifier, key, value) {
+    var metadataKey = isMultiInject
+        ? METADATA_KEY.MULTI_INJECT_TAG
+        : METADATA_KEY.INJECT_TAG;
+    var metadataList = [
+        new Metadata(metadataKey, serviceIdentifier),
+    ];
+    if (key !== undefined) {
+        metadataList.push(new Metadata(key, value));
+    }
+    return metadataList;
+}
 function _validateActiveBindingCount(serviceIdentifier, bindings, target, container) {
     switch (bindings.length) {
         case BindingCount.NoBindingsAvailable:
@@ -92,14 +104,15 @@ function _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier,
             subChildRequest = childRequest.addChildRequest(binding.serviceIdentifier, binding, target);
         }
         else {
-            if (binding.cache) {
+            if (binding.cache !== null) {
                 return;
             }
             subChildRequest = childRequest;
         }
-        if (binding.type === BindingTypeEnum.Instance && binding.implementationType !== null) {
+        if (binding.type === BindingTypeEnum.Instance &&
+            binding.implementationType !== null) {
             var dependencies = getDependencies(metadataReader, binding.implementationType);
-            if (!context.container.options.skipBaseClassChecks) {
+            if (context.container.options.skipBaseClassChecks !== true) {
                 var baseClassDependencyCount = getBaseClassDependencyCount(metadataReader, binding.implementationType);
                 if (dependencies.length < baseClassDependencyCount) {
                     var error = ERROR_MSGS.ARGUMENTS_LENGTH_MISMATCH(getFunctionName(binding.implementationType));
@@ -139,7 +152,12 @@ function plan(metadataReader, container, isMultiInject, targetType, serviceIdent
     }
 }
 function createMockRequest(container, serviceIdentifier, key, value) {
-    var target = new Target(TargetTypeEnum.Variable, '', serviceIdentifier, new Metadata(key, value));
+    var metadataList = _getTargetMetadata(false, serviceIdentifier, key, value);
+    var classElementMetadata = getClassElementMetadataFromLegacyMetadata(metadataList);
+    if (classElementMetadata.kind === ClassElementMetadataKind.unmanaged) {
+        throw new Error('Unexpected metadata when creating target');
+    }
+    var target = new TargetImpl('', classElementMetadata, 'Variable');
     var context = new Context(container);
     var request = new Request(serviceIdentifier, context, null, [], target);
     return request;

package/es/planning/queryable_string.js

@@ -7,12 +7,15 @@ var QueryableString = (function () {
     };
     QueryableString.prototype.endsWith = function (searchString) {
         var reverseString = '';
-        var reverseSearchString = searchString.split('').reverse().join('');
+        var reverseSearchString = searchString
+            .split('')
+            .reverse()
+            .join('');
         reverseString = this.str.split('').reverse().join('');
         return this.startsWith.call({ str: reverseString }, reverseSearchString);
     };
     QueryableString.prototype.contains = function (searchString) {
-        return (this.str.indexOf(searchString) !== -1);
+        return this.str.indexOf(searchString) !== -1;
     };
     QueryableString.prototype.equals = function (compareString) {
         return this.str === compareString;

package/es/planning/reflection_utils.js

@@ -1,112 +1,16 @@
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-import { LazyServiceIdentifier } from '../annotation/lazy_service_identifier';
-import * as ERROR_MSGS from '../constants/error_msgs';
-import { TargetTypeEnum } from '../constants/literal_types';
+import { getTargets } from '@inversifyjs/core';
 import * as METADATA_KEY from '../constants/metadata_keys';
 import { getFunctionName } from '../utils/serialization';
-import { Target } from './target';
 function getDependencies(metadataReader, func) {
-    var constructorName = getFunctionName(func);
-    return getTargets(metadataReader, constructorName, func, false);
-}
-function getTargets(metadataReader, constructorName, func, isBaseClass) {
-    var metadata = metadataReader.getConstructorMetadata(func);
-    var serviceIdentifiers = metadata.compilerGeneratedMetadata;
-    if (serviceIdentifiers === undefined) {
-        var msg = "".concat(ERROR_MSGS.MISSING_INJECTABLE_ANNOTATION, " ").concat(constructorName, ".");
-        throw new Error(msg);
-    }
-    var constructorArgsMetadata = metadata.userGeneratedMetadata;
-    var keys = Object.keys(constructorArgsMetadata);
-    var hasUserDeclaredUnknownInjections = (func.length === 0 && keys.length > 0);
-    var hasOptionalParameters = keys.length > func.length;
-    var iterations = (hasUserDeclaredUnknownInjections || hasOptionalParameters) ? keys.length : func.length;
-    var constructorTargets = getConstructorArgsAsTargets(isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata, iterations);
-    var propertyTargets = getClassPropsAsTargets(metadataReader, func, constructorName);
-    var targets = __spreadArray(__spreadArray([], constructorTargets, true), propertyTargets, true);
-    return targets;
-}
-function getConstructorArgsAsTarget(index, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata) {
-    var targetMetadata = constructorArgsMetadata[index.toString()] || [];
-    var metadata = formatTargetMetadata(targetMetadata);
-    var isManaged = metadata.unmanaged !== true;
-    var serviceIdentifier = serviceIdentifiers[index];
-    var injectIdentifier = metadata.inject || metadata.multiInject;
-    serviceIdentifier = (injectIdentifier ? injectIdentifier : serviceIdentifier);
-    if (serviceIdentifier instanceof LazyServiceIdentifier) {
-        serviceIdentifier = serviceIdentifier.unwrap();
-    }
-    if (isManaged) {
-        var isObject = serviceIdentifier === Object;
-        var isFunction = serviceIdentifier === Function;
-        var isUndefined = serviceIdentifier === undefined;
-        var isUnknownType = isObject || isFunction || isUndefined;
-        if (!isBaseClass && isUnknownType) {
-            var msg = "".concat(ERROR_MSGS.MISSING_INJECT_ANNOTATION, " argument ").concat(index, " in class ").concat(constructorName, ".");
-            throw new Error(msg);
-        }
-        var target = new Target(TargetTypeEnum.ConstructorArgument, metadata.targetName, serviceIdentifier);
-        target.metadata = targetMetadata;
-        return target;
-    }
-    return null;
-}
-function getConstructorArgsAsTargets(isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata, iterations) {
-    var targets = [];
-    for (var i = 0; i < iterations; i++) {
-        var index = i;
-        var target = getConstructorArgsAsTarget(index, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata);
-        if (target !== null) {
-            targets.push(target);
-        }
-    }
-    return targets;
-}
-function _getServiceIdentifierForProperty(inject, multiInject, propertyName, className) {
-    var serviceIdentifier = (inject || multiInject);
-    if (serviceIdentifier === undefined) {
-        var msg = "".concat(ERROR_MSGS.MISSING_INJECTABLE_ANNOTATION, " for property ").concat(String(propertyName), " in class ").concat(className, ".");
-        throw new Error(msg);
-    }
-    return serviceIdentifier;
-}
-function getClassPropsAsTargets(metadataReader, constructorFunc, constructorName) {
-    var classPropsMetadata = metadataReader.getPropertiesMetadata(constructorFunc);
-    var targets = [];
-    var symbolKeys = Object.getOwnPropertySymbols(classPropsMetadata);
-    var stringKeys = Object.keys(classPropsMetadata);
-    var keys = stringKeys.concat(symbolKeys);
-    for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
-        var key = keys_1[_i];
-        var targetMetadata = classPropsMetadata[key];
-        var metadata = formatTargetMetadata(targetMetadata);
-        var identifier = metadata.targetName || key;
-        var serviceIdentifier = _getServiceIdentifierForProperty(metadata.inject, metadata.multiInject, key, constructorName);
-        var target = new Target(TargetTypeEnum.ClassProperty, identifier, serviceIdentifier);
-        target.metadata = targetMetadata;
-        targets.push(target);
-    }
-    var baseConstructor = Object.getPrototypeOf(constructorFunc.prototype).constructor;
-    if (baseConstructor !== Object) {
-        var baseTargets = getClassPropsAsTargets(metadataReader, baseConstructor, constructorName);
-        targets = __spreadArray(__spreadArray([], targets, true), baseTargets, true);
-    }
-    return targets;
+    return getTargets(metadataReader)(func);
 }
 function getBaseClassDependencyCount(metadataReader, func) {
     var baseConstructor = Object.getPrototypeOf(func.prototype).constructor;
     if (baseConstructor !== Object) {
-        var baseConstructorName = getFunctionName(baseConstructor);
-        var targets = getTargets(metadataReader, baseConstructorName, baseConstructor, true);
-        var metadata = targets.map(function (t) { return t.metadata.filter(function (m) { return m.key === METADATA_KEY.UNMANAGED_TAG; }); });
+        var targets = getTargets(metadataReader)(baseConstructor);
+        var metadata = targets.map(function (t) {
+            return t.metadata.filter(function (m) { return m.key === METADATA_KEY.UNMANAGED_TAG; });
+        });
         var unmanagedCount = [].concat.apply([], metadata).length;
         var dependencyCount = targets.length - unmanagedCount;
         if (dependencyCount > 0) {
@@ -120,16 +24,4 @@ function getBaseClassDependencyCount(metadataReader, func) {
         return 0;
     }
 }
-function formatTargetMetadata(targetMetadata) {
-    var targetMetadataMap = {};
-    targetMetadata.forEach(function (m) {
-        targetMetadataMap[m.key.toString()] = m.value;
-    });
-    return {
-        inject: targetMetadataMap[METADATA_KEY.INJECT_TAG],
-        multiInject: targetMetadataMap[METADATA_KEY.MULTI_INJECT_TAG],
-        targetName: targetMetadataMap[METADATA_KEY.NAME_TAG],
-        unmanaged: targetMetadataMap[METADATA_KEY.UNMANAGED_TAG]
-    };
-}
 export { getDependencies, getBaseClassDependencyCount, getFunctionName };

package/es/planning/request.js

@@ -7,10 +7,8 @@ var Request = (function () {
         this.parentRequest = parentRequest;
         this.target = target;
         this.childRequests = [];
-        this.bindings = (Array.isArray(bindings) ? bindings : [bindings]);
-        this.requestScope = parentRequest === null
-            ? new Map()
-            : null;
+        this.bindings = Array.isArray(bindings) ? bindings : [bindings];
+        this.requestScope = parentRequest === null ? new Map() : null;
     }
     Request.prototype.addChildRequest = function (serviceIdentifier, bindings, target) {
         var child = new Request(serviceIdentifier, this.parentContext, this, bindings, target);

package/es/planning/target.js

@@ -8,7 +8,9 @@ var Target = (function () {
         this.id = id();
         this.type = type;
         this.serviceIdentifier = serviceIdentifier;
-        var queryableName = typeof identifier === 'symbol' ? getSymbolDescription(identifier) : identifier;
+        var queryableName = typeof identifier === 'symbol'
+            ? getSymbolDescription(identifier)
+            : identifier;
         this.name = new QueryableString(queryableName || '');
         this.identifier = identifier;
         this.metadata = new Array();
@@ -42,7 +44,9 @@ var Target = (function () {
         return this.hasTag(METADATA_KEY.NAMED_TAG);
     };
     Target.prototype.isTagged = function () {
-        return this.metadata.some(function (metadata) { return METADATA_KEY.NON_CUSTOM_TAG_KEYS.every(function (key) { return metadata.key !== key; }); });
+        return this.metadata.some(function (metadata) {
+            return METADATA_KEY.NON_CUSTOM_TAG_KEYS.every(function (key) { return metadata.key !== key; });
+        });
     };
     Target.prototype.isOptional = function () {
         return this.matchesTag(METADATA_KEY.OPTIONAL_TAG)(true);
@@ -55,7 +59,9 @@ var Target = (function () {
     };
     Target.prototype.getCustomTags = function () {
         if (this.isTagged()) {
-            return this.metadata.filter(function (metadata) { return METADATA_KEY.NON_CUSTOM_TAG_KEYS.every(function (key) { return metadata.key !== key; }); });
+            return this.metadata.filter(function (metadata) {
+                return METADATA_KEY.NON_CUSTOM_TAG_KEYS.every(function (key) { return metadata.key !== key; });
+            });
         }
         else {
             return null;

package/es/resolution/instantiation.js

@@ -54,7 +54,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import { ON_DEACTIVATION_ERROR, POST_CONSTRUCT_ERROR, PRE_DESTROY_ERROR } from '../constants/error_msgs';
+import { ON_DEACTIVATION_ERROR, POST_CONSTRUCT_ERROR, PRE_DESTROY_ERROR, } from '../constants/error_msgs';
 import { BindingScopeEnum, TargetTypeEnum } from '../constants/literal_types';
 import * as METADATA_KEY from '../constants/metadata_keys';
 import { isPromise, isPromiseOrContainsPromise } from '../utils/async';
@@ -73,7 +73,12 @@ function _resolveRequests(childRequests, resolveRequest) {
             resolvedRequests.isAsync = isPromiseOrContainsPromise(injection);
         }
         return resolvedRequests;
-    }, { constructorInjections: [], propertyInjections: [], propertyRequests: [], isAsync: false });
+    }, {
+        constructorInjections: [],
+        isAsync: false,
+        propertyInjections: [],
+        propertyRequests: [],
+    });
 }
 function _createInstance(constr, childRequests, resolveRequest) {
     var result;
@@ -167,9 +172,7 @@ function _validateInstanceResolution(binding, constr) {
     }
 }
 function _throwIfHandlingDeactivation(binding, constr) {
-    var scopeErrorMessage = "Class cannot be instantiated in ".concat(binding.scope === BindingScopeEnum.Request ?
-        'request' :
-        'transient', " scope.");
+    var scopeErrorMessage = "Class cannot be instantiated in ".concat(binding.scope === BindingScopeEnum.Request ? 'request' : 'transient', " scope.");
     if (typeof binding.onDeactivation === 'function') {
         throw new Error(ON_DEACTIVATION_ERROR(constr.name, scopeErrorMessage));
     }
@@ -181,7 +184,9 @@ function resolveInstance(binding, constr, childRequests, resolveRequest) {
     _validateInstanceResolution(binding, constr);
     var result = _createInstance(constr, childRequests, resolveRequest);
     if (isPromise(result)) {
-        return result.then(function (resolvedResult) { return _getInstanceAfterPostConstruct(constr, resolvedResult); });
+        return result.then(function (resolvedResult) {
+            return _getInstanceAfterPostConstruct(constr, resolvedResult);
+        });
     }
     else {
         return _getInstanceAfterPostConstruct(constr, result);

package/es/resolution/resolver.js

@@ -39,7 +39,7 @@ import { BindingTypeEnum } from '../constants/literal_types';
 import { getBindingDictionary } from '../planning/planner';
 import { saveToScope, tryGetFromScope } from '../scope/scope';
 import { isPromise } from '../utils/async';
-import { getFactoryDetails, ensureFullyBound } from '../utils/binding_utils';
+import { ensureFullyBound, getFactoryDetails } from '../utils/binding_utils';
 import { tryAndThrowErrorIfStackOverflow } from '../utils/exceptions';
 import { resolveInstance } from './instantiation';
 var _resolveRequest = function (requestScope) {
@@ -54,8 +54,8 @@ var _resolveRequest = function (requestScope) {
             !request.parentRequest.target.matchesArray(request.target.serviceIdentifier);
         if (targetIsAnArray && targetParentIsNotAnArray) {
             return childRequests.map(function (childRequest) {
-                var _f = _resolveRequest(requestScope);
-                return _f(childRequest);
+                var resolveRequest = _resolveRequest(requestScope);
+                return resolveRequest(childRequest);
             });
         }
         else {
@@ -69,7 +69,11 @@ var _resolveRequest = function (requestScope) {
 };
 var _resolveFactoryFromBinding = function (binding, context) {
     var factoryDetails = getFactoryDetails(binding);
-    return tryAndThrowErrorIfStackOverflow(function () { return factoryDetails.factory.bind(binding)(context); }, function () { return new Error(ERROR_MSGS.CIRCULAR_DEPENDENCY_IN_FACTORY(factoryDetails.factoryType, context.currentRequest.serviceIdentifier.toString())); });
+    return tryAndThrowErrorIfStackOverflow(function () {
+        return factoryDetails.factory.bind(binding)(context);
+    }, function () {
+        return new Error(ERROR_MSGS.CIRCULAR_DEPENDENCY_IN_FACTORY(factoryDetails.factoryType, context.currentRequest.serviceIdentifier.toString()));
+    });
 };
 var _getResolvedFromBinding = function (requestScope, request, binding) {
     var result;
@@ -104,7 +108,9 @@ var _resolveBinding = function (requestScope, request, binding) {
     return _resolveInScope(requestScope, binding, function () {
         var result = _getResolvedFromBinding(requestScope, request, binding);
         if (isPromise(result)) {
-            result = result.then(function (resolved) { return _onActivation(request, binding, resolved); });
+            result = result.then(function (resolved) {
+                return _onActivation(request, binding, resolved);
+            });
         }
         else {
             result = _onActivation(request, binding, result);
@@ -129,7 +135,8 @@ function _onActivation(request, binding, resolved) {
             result = _activateContainer(activationsIterator, context_1, result);
         }
         containersIteratorResult = containersIterator.next();
-    } while (containersIteratorResult.done !== true && !getBindingDictionary(container).hasKey(request.serviceIdentifier));
+    } while (containersIteratorResult.done !== true &&
+        !getBindingDictionary(container).hasKey(request.serviceIdentifier));
     return result;
 }
 var _bindingActivation = function (context, binding, previousResult) {
@@ -144,7 +151,7 @@ var _bindingActivation = function (context, binding, previousResult) {
 };
 var _activateContainer = function (activationsIterator, context, result) {
     var activation = activationsIterator.next();
-    while (!activation.done) {
+    while (activation.done !== true) {
         result = activation.value(context, result);
         if (isPromise(result)) {
             return _activateContainerAsync(activationsIterator, context, result);
@@ -163,7 +170,7 @@ var _activateContainerAsync = function (activationsIterator, context, resultProm
                 activation = activationsIterator.next();
                 _a.label = 2;
             case 2:
-                if (!!activation.done) return [3, 4];
+                if (!(activation.done !== true)) return [3, 4];
                 return [4, activation.value(context, result)];
             case 3:
                 result = _a.sent();
@@ -175,7 +182,9 @@ var _activateContainerAsync = function (activationsIterator, context, resultProm
 }); };
 var _getContainerActivationsForService = function (container, serviceIdentifier) {
     var activations = container._activations;
-    return activations.hasKey(serviceIdentifier) ? activations.get(serviceIdentifier).values() : [].values();
+    return activations.hasKey(serviceIdentifier)
+        ? activations.get(serviceIdentifier).values()
+        : [].values();
 };
 var _getContainersIterator = function (container) {
     var containersStack = [container];
@@ -199,7 +208,7 @@ var _getContainersIterator = function (container) {
     return containersIterator;
 };
 function resolve(context) {
-    var _f = _resolveRequest(context.plan.rootRequest.requestScope);
-    return _f(context.plan.rootRequest);
+    var resolveRequestFunction = _resolveRequest(context.plan.rootRequest.requestScope);
+    return resolveRequestFunction(context.plan.rootRequest);
 }
 export { resolve };

package/es/scope/scope.js

@@ -37,7 +37,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 import { BindingScopeEnum } from '../constants/literal_types';
 import { isPromise } from '../utils/async';
 export var tryGetFromScope = function (requestScope, binding) {
-    if ((binding.scope === BindingScopeEnum.Singleton) && binding.activated) {
+    if (binding.scope === BindingScopeEnum.Singleton && binding.activated) {
         return binding.cache;
     }
     if (binding.scope === BindingScopeEnum.Request &&

package/es/syntax/binding_to_syntax.js

@@ -1,7 +1,7 @@
-import * as ERROR_MSGS from "../constants/error_msgs";
-import { BindingScopeEnum, BindingTypeEnum } from "../constants/literal_types";
-import { BindingInWhenOnSyntax } from "./binding_in_when_on_syntax";
-import { BindingWhenOnSyntax } from "./binding_when_on_syntax";
+import * as ERROR_MSGS from '../constants/error_msgs';
+import { BindingScopeEnum, BindingTypeEnum } from '../constants/literal_types';
+import { BindingInWhenOnSyntax } from './binding_in_when_on_syntax';
+import { BindingWhenOnSyntax } from './binding_when_on_syntax';
 var BindingToSyntax = (function () {
     function BindingToSyntax(binding) {
         this._binding = binding;
@@ -12,10 +12,11 @@ var BindingToSyntax = (function () {
         return new BindingInWhenOnSyntax(this._binding);
     };
     BindingToSyntax.prototype.toSelf = function () {
-        if (typeof this._binding.serviceIdentifier !== "function") {
-            throw new Error("".concat(ERROR_MSGS.INVALID_TO_SELF_VALUE));
+        if (typeof this._binding.serviceIdentifier !== 'function') {
+            throw new Error(ERROR_MSGS.INVALID_TO_SELF_VALUE);
         }
-        var self = this._binding.serviceIdentifier;
+        var self = this._binding
+            .serviceIdentifier;
         return this.to(self);
     };
     BindingToSyntax.prototype.toConstantValue = function (value) {
@@ -46,7 +47,7 @@ var BindingToSyntax = (function () {
         return new BindingWhenOnSyntax(this._binding);
     };
     BindingToSyntax.prototype.toFunction = function (func) {
-        if (typeof func !== "function") {
+        if (typeof func !== 'function') {
             throw new Error(ERROR_MSGS.INVALID_FUNCTION_BINDING);
         }
         var bindingWhenOnSyntax = this.toConstantValue(func);
@@ -57,7 +58,9 @@ var BindingToSyntax = (function () {
     BindingToSyntax.prototype.toAutoFactory = function (serviceIdentifier) {
         this._binding.type = BindingTypeEnum.Factory;
         this._binding.factory = function (context) {
-            var autofactory = function () { return context.container.get(serviceIdentifier); };
+            var autofactory = function () {
+                return context.container.get(serviceIdentifier);
+            };
             return autofactory;
         };
         this._binding.scope = BindingScopeEnum.Singleton;
@@ -66,7 +69,9 @@ var BindingToSyntax = (function () {
     BindingToSyntax.prototype.toAutoNamedFactory = function (serviceIdentifier) {
         this._binding.type = BindingTypeEnum.Factory;
         this._binding.factory = function (context) {
-            return function (named) { return context.container.getNamed(serviceIdentifier, named); };
+            return function (named) {
+                return context.container.getNamed(serviceIdentifier, named);
+            };
         };
         return new BindingWhenOnSyntax(this._binding);
     };
@@ -77,7 +82,9 @@ var BindingToSyntax = (function () {
         return new BindingWhenOnSyntax(this._binding);
     };
     BindingToSyntax.prototype.toService = function (service) {
-        this.toDynamicValue(function (context) { return context.container.get(service); });
+        this.toDynamicValue(function (context) {
+            return context.container.get(service);
+        });
     };
     return BindingToSyntax;
 }());