inversify 6.0.3 → 6.1.0

package/lib/planning/planner.js

@@ -26,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.plan = plan;
 exports.createMockRequest = createMockRequest;
 exports.getBindingDictionary = getBindingDictionary;
+var core_1 = require("@inversifyjs/core");
 var binding_count_1 = require("../bindings/binding_count");
 var ERROR_MSGS = __importStar(require("../constants/error_msgs"));
 var literal_types_1 = require("../constants/literal_types");
@@ -37,27 +38,26 @@ var metadata_1 = require("./metadata");
 var plan_1 = require("./plan");
 var reflection_utils_1 = require("./reflection_utils");
 var request_1 = require("./request");
-var target_1 = require("./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_1.Metadata(metadataKey, serviceIdentifier);
-    var target = new target_1.Target(targetType, name, serviceIdentifier, injectMetadata);
-    if (key !== undefined) {
-        var tagMetadata = new metadata_1.Metadata(key, value);
-        target.metadata.push(tagMetadata);
+    var metadataList = _getTargetMetadata(isMultiInject, serviceIdentifier, key, value);
+    var classElementMetadata = (0, core_1.getClassElementMetadataFromLegacyMetadata)(metadataList);
+    if (classElementMetadata.kind === core_1.ClassElementMetadataKind.unmanaged) {
+        throw new Error('Unexpected metadata when creating target');
     }
+    var target = new core_1.LegacyTargetImpl(name, classElementMetadata, targetType);
     return target;
 }
 function _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target) {
     var bindings = getBindings(context.container, target.serviceIdentifier);
     var activeBindings = [];
     if (bindings.length === binding_count_1.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);
     }
@@ -73,6 +73,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_1.Metadata(metadataKey, serviceIdentifier),
+    ];
+    if (key !== undefined) {
+        metadataList.push(new metadata_1.Metadata(key, value));
+    }
+    return metadataList;
+}
 function _validateActiveBindingCount(serviceIdentifier, bindings, target, container) {
     switch (bindings.length) {
         case binding_count_1.BindingCount.NoBindingsAvailable:
@@ -120,14 +132,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 === literal_types_1.BindingTypeEnum.Instance && binding.implementationType !== null) {
+        if (binding.type === literal_types_1.BindingTypeEnum.Instance &&
+            binding.implementationType !== null) {
             var dependencies = (0, reflection_utils_1.getDependencies)(metadataReader, binding.implementationType);
-            if (!context.container.options.skipBaseClassChecks) {
+            if (context.container.options.skipBaseClassChecks !== true) {
                 var baseClassDependencyCount = (0, reflection_utils_1.getBaseClassDependencyCount)(metadataReader, binding.implementationType);
                 if (dependencies.length < baseClassDependencyCount) {
                     var error = ERROR_MSGS.ARGUMENTS_LENGTH_MISMATCH((0, reflection_utils_1.getFunctionName)(binding.implementationType));
@@ -167,7 +180,12 @@ function plan(metadataReader, container, isMultiInject, targetType, serviceIdent
     }
 }
 function createMockRequest(container, serviceIdentifier, key, value) {
-    var target = new target_1.Target(literal_types_1.TargetTypeEnum.Variable, '', serviceIdentifier, new metadata_1.Metadata(key, value));
+    var metadataList = _getTargetMetadata(false, serviceIdentifier, key, value);
+    var classElementMetadata = (0, core_1.getClassElementMetadataFromLegacyMetadata)(metadataList);
+    if (classElementMetadata.kind === core_1.ClassElementMetadataKind.unmanaged) {
+        throw new Error('Unexpected metadata when creating target');
+    }
+    var target = new core_1.LegacyTargetImpl('', classElementMetadata, 'Variable');
     var context = new context_1.Context(container);
     var request = new request_1.Request(serviceIdentifier, context, null, [], target);
     return request;

package/lib/planning/queryable_string.d.ts

@@ -1,6 +1,6 @@
 import { interfaces } from '../interfaces/interfaces';
-declare class QueryableString implements interfaces.QueryableString {
-    private str;
+export declare class QueryableString implements interfaces.QueryableString {
+    private readonly str;
     constructor(str: string);
     startsWith(searchString: string): boolean;
     endsWith(searchString: string): boolean;
@@ -8,4 +8,3 @@ declare class QueryableString implements interfaces.QueryableString {
     equals(compareString: string): boolean;
     value(): string;
 }
-export { QueryableString };

package/lib/planning/queryable_string.js

@@ -10,12 +10,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/lib/planning/reflection_utils.js

@@ -22,120 +22,24 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFunctionName = void 0;
 exports.getDependencies = getDependencies;
 exports.getBaseClassDependencyCount = getBaseClassDependencyCount;
-var lazy_service_identifier_1 = require("../annotation/lazy_service_identifier");
-var ERROR_MSGS = __importStar(require("../constants/error_msgs"));
-var literal_types_1 = require("../constants/literal_types");
+var core_1 = require("@inversifyjs/core");
 var METADATA_KEY = __importStar(require("../constants/metadata_keys"));
 var serialization_1 = require("../utils/serialization");
 Object.defineProperty(exports, "getFunctionName", { enumerable: true, get: function () { return serialization_1.getFunctionName; } });
-var target_1 = require("./target");
 function getDependencies(metadataReader, func) {
-    var constructorName = (0, serialization_1.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 lazy_service_identifier_1.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_1.Target(literal_types_1.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_1.Target(literal_types_1.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 (0, core_1.getTargets)(metadataReader)(func);
 }
 function getBaseClassDependencyCount(metadataReader, func) {
     var baseConstructor = Object.getPrototypeOf(func.prototype).constructor;
     if (baseConstructor !== Object) {
-        var baseConstructorName = (0, serialization_1.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 = (0, core_1.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) {
@@ -149,15 +53,3 @@ 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]
-    };
-}

package/lib/planning/request.d.ts

@@ -8,7 +8,7 @@ declare class Request implements interfaces.Request {
     childRequests: interfaces.Request[];
     target: interfaces.Target;
     requestScope: interfaces.RequestScope | null;
-    constructor(serviceIdentifier: interfaces.ServiceIdentifier, parentContext: interfaces.Context, parentRequest: interfaces.Request | null, bindings: (interfaces.Binding<any> | interfaces.Binding<any>[]), target: interfaces.Target);
-    addChildRequest(serviceIdentifier: interfaces.ServiceIdentifier, bindings: (interfaces.Binding<unknown> | interfaces.Binding<unknown>[]), target: interfaces.Target): interfaces.Request;
+    constructor(serviceIdentifier: interfaces.ServiceIdentifier, parentContext: interfaces.Context, parentRequest: interfaces.Request | null, bindings: interfaces.Binding<any> | interfaces.Binding<any>[], target: interfaces.Target);
+    addChildRequest(serviceIdentifier: interfaces.ServiceIdentifier, bindings: interfaces.Binding<unknown> | interfaces.Binding<unknown>[], target: interfaces.Target): interfaces.Request;
 }
 export { Request };

package/lib/planning/request.js

@@ -10,10 +10,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/lib/planning/target.d.ts

@@ -8,7 +8,7 @@ declare class Target implements interfaces.Target {
     identifier: string | symbol;
     key: string | symbol;
     metadata: Metadata[];
-    constructor(type: interfaces.TargetType, identifier: string | symbol, serviceIdentifier: interfaces.ServiceIdentifier, namedOrTagged?: (string | Metadata));
+    constructor(type: interfaces.TargetType, identifier: string | symbol, serviceIdentifier: interfaces.ServiceIdentifier, namedOrTagged?: string | Metadata);
     hasTag(key: string): boolean;
     isArray(): boolean;
     matchesArray(name: interfaces.ServiceIdentifier<unknown>): boolean;

package/lib/planning/target.js

@@ -34,7 +34,9 @@ var Target = (function () {
         this.id = (0, id_1.id)();
         this.type = type;
         this.serviceIdentifier = serviceIdentifier;
-        var queryableName = typeof identifier === 'symbol' ? (0, serialization_1.getSymbolDescription)(identifier) : identifier;
+        var queryableName = typeof identifier === 'symbol'
+            ? (0, serialization_1.getSymbolDescription)(identifier)
+            : identifier;
         this.name = new queryable_string_1.QueryableString(queryableName || '');
         this.identifier = identifier;
         this.metadata = new Array();
@@ -68,7 +70,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);
@@ -81,7 +85,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/lib/resolution/instantiation.js

@@ -99,7 +99,12 @@ function _resolveRequests(childRequests, resolveRequest) {
             resolvedRequests.isAsync = (0, async_1.isPromiseOrContainsPromise)(injection);
         }
         return resolvedRequests;
-    }, { constructorInjections: [], propertyInjections: [], propertyRequests: [], isAsync: false });
+    }, {
+        constructorInjections: [],
+        isAsync: false,
+        propertyInjections: [],
+        propertyRequests: [],
+    });
 }
 function _createInstance(constr, childRequests, resolveRequest) {
     var result;
@@ -193,9 +198,7 @@ function _validateInstanceResolution(binding, constr) {
     }
 }
 function _throwIfHandlingDeactivation(binding, constr) {
-    var scopeErrorMessage = "Class cannot be instantiated in ".concat(binding.scope === literal_types_1.BindingScopeEnum.Request ?
-        'request' :
-        'transient', " scope.");
+    var scopeErrorMessage = "Class cannot be instantiated in ".concat(binding.scope === literal_types_1.BindingScopeEnum.Request ? 'request' : 'transient', " scope.");
     if (typeof binding.onDeactivation === 'function') {
         throw new Error((0, error_msgs_1.ON_DEACTIVATION_ERROR)(constr.name, scopeErrorMessage));
     }
@@ -207,7 +210,9 @@ function resolveInstance(binding, constr, childRequests, resolveRequest) {
     _validateInstanceResolution(binding, constr);
     var result = _createInstance(constr, childRequests, resolveRequest);
     if ((0, async_1.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/lib/resolution/resolver.js

@@ -80,8 +80,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 {
@@ -95,7 +95,11 @@ var _resolveRequest = function (requestScope) {
 };
 var _resolveFactoryFromBinding = function (binding, context) {
     var factoryDetails = (0, binding_utils_1.getFactoryDetails)(binding);
-    return (0, exceptions_1.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 (0, exceptions_1.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;
@@ -130,7 +134,9 @@ var _resolveBinding = function (requestScope, request, binding) {
     return _resolveInScope(requestScope, binding, function () {
         var result = _getResolvedFromBinding(requestScope, request, binding);
         if ((0, async_1.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);
@@ -155,7 +161,8 @@ function _onActivation(request, binding, resolved) {
             result = _activateContainer(activationsIterator, context_1, result);
         }
         containersIteratorResult = containersIterator.next();
-    } while (containersIteratorResult.done !== true && !(0, planner_1.getBindingDictionary)(container).hasKey(request.serviceIdentifier));
+    } while (containersIteratorResult.done !== true &&
+        !(0, planner_1.getBindingDictionary)(container).hasKey(request.serviceIdentifier));
     return result;
 }
 var _bindingActivation = function (context, binding, previousResult) {
@@ -170,7 +177,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 ((0, async_1.isPromise)(result)) {
             return _activateContainerAsync(activationsIterator, context, result);
@@ -189,7 +196,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();
@@ -201,7 +208,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];
@@ -225,6 +234,6 @@ 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);
 }

package/lib/scope/scope.js

@@ -40,7 +40,7 @@ exports.saveToScope = exports.tryGetFromScope = void 0;
 var literal_types_1 = require("../constants/literal_types");
 var async_1 = require("../utils/async");
 var tryGetFromScope = function (requestScope, binding) {
-    if ((binding.scope === literal_types_1.BindingScopeEnum.Singleton) && binding.activated) {
+    if (binding.scope === literal_types_1.BindingScopeEnum.Singleton && binding.activated) {
         return binding.cache;
     }
     if (binding.scope === literal_types_1.BindingScopeEnum.Request &&

package/lib/syntax/binding_in_syntax.d.ts

@@ -1,6 +1,6 @@
 import { interfaces } from '../interfaces/interfaces';
 declare class BindingInSyntax<T> implements interfaces.BindingInSyntax<T> {
-    private _binding;
+    private readonly _binding;
     constructor(binding: interfaces.Binding<T>);
     inRequestScope(): interfaces.BindingWhenOnSyntax<T>;
     inSingletonScope(): interfaces.BindingWhenOnSyntax<T>;

package/lib/syntax/binding_in_when_on_syntax.d.ts

@@ -1,9 +1,9 @@
 import { interfaces } from '../interfaces/interfaces';
 declare class BindingInWhenOnSyntax<T> implements interfaces.BindingInSyntax<T>, interfaces.BindingWhenSyntax<T>, interfaces.BindingOnSyntax<T> {
-    private _bindingInSyntax;
-    private _bindingWhenSyntax;
-    private _bindingOnSyntax;
-    private _binding;
+    private readonly _bindingInSyntax;
+    private readonly _bindingWhenSyntax;
+    private readonly _bindingOnSyntax;
+    private readonly _binding;
     constructor(binding: interfaces.Binding<T>);
     inRequestScope(): interfaces.BindingWhenOnSyntax<T>;
     inSingletonScope(): interfaces.BindingWhenOnSyntax<T>;
@@ -12,11 +12,11 @@ declare class BindingInWhenOnSyntax<T> implements interfaces.BindingInSyntax<T>,
     whenTargetNamed(name: string): interfaces.BindingOnSyntax<T>;
     whenTargetIsDefault(): interfaces.BindingOnSyntax<T>;
     whenTargetTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
-    whenInjectedInto(parent: (NewableFunction | string)): interfaces.BindingOnSyntax<T>;
+    whenInjectedInto(parent: NewableFunction | string): interfaces.BindingOnSyntax<T>;
     whenParentNamed(name: string): interfaces.BindingOnSyntax<T>;
     whenParentTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
-    whenAnyAncestorIs(ancestor: (NewableFunction | string)): interfaces.BindingOnSyntax<T>;
-    whenNoAncestorIs(ancestor: (NewableFunction | string)): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
     whenAnyAncestorNamed(name: string): interfaces.BindingOnSyntax<T>;
     whenAnyAncestorTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
     whenNoAncestorNamed(name: string): interfaces.BindingOnSyntax<T>;

package/lib/syntax/binding_on_syntax.d.ts

@@ -1,6 +1,6 @@
 import { interfaces } from '../interfaces/interfaces';
 declare class BindingOnSyntax<T> implements interfaces.BindingOnSyntax<T> {
-    private _binding;
+    private readonly _binding;
     constructor(binding: interfaces.Binding<T>);
     onActivation(handler: interfaces.BindingActivation<T>): interfaces.BindingWhenSyntax<T>;
     onDeactivation(handler: interfaces.BindingDeactivation<T>): interfaces.BindingWhenSyntax<T>;

package/lib/syntax/binding_to_syntax.d.ts

@@ -1,7 +1,7 @@
-import { interfaces } from "../interfaces/interfaces";
-import { BindingWhenOnSyntax } from "./binding_when_on_syntax";
+import { interfaces } from '../interfaces/interfaces';
+import { BindingWhenOnSyntax } from './binding_when_on_syntax';
 declare class BindingToSyntax<T> implements interfaces.BindingToSyntax<T> {
-    private _binding;
+    private readonly _binding;
     constructor(binding: interfaces.Binding<T>);
     to(constructor: interfaces.Newable<T>): interfaces.BindingInWhenOnSyntax<T>;
     toSelf(): interfaces.BindingInWhenOnSyntax<T>;
@@ -13,6 +13,6 @@ declare class BindingToSyntax<T> implements interfaces.BindingToSyntax<T> {
     toAutoFactory<T2>(serviceIdentifier: interfaces.ServiceIdentifier<T2>): interfaces.BindingWhenOnSyntax<T>;
     toAutoNamedFactory<T2>(serviceIdentifier: interfaces.ServiceIdentifier<T2>): BindingWhenOnSyntax<T>;
     toProvider<T2>(provider: interfaces.ProviderCreator<T2>): interfaces.BindingWhenOnSyntax<T>;
-    toService(service: string | symbol | interfaces.Newable<T> | interfaces.Abstract<T>): void;
+    toService(service: interfaces.ServiceIdentifier<T>): void;
 }
 export { BindingToSyntax };

package/lib/syntax/binding_to_syntax.js

@@ -38,10 +38,11 @@ var BindingToSyntax = (function () {
         return new binding_in_when_on_syntax_1.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) {
@@ -72,7 +73,7 @@ var BindingToSyntax = (function () {
         return new binding_when_on_syntax_1.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);
@@ -83,7 +84,9 @@ var BindingToSyntax = (function () {
     BindingToSyntax.prototype.toAutoFactory = function (serviceIdentifier) {
         this._binding.type = literal_types_1.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 = literal_types_1.BindingScopeEnum.Singleton;
@@ -92,7 +95,9 @@ var BindingToSyntax = (function () {
     BindingToSyntax.prototype.toAutoNamedFactory = function (serviceIdentifier) {
         this._binding.type = literal_types_1.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 binding_when_on_syntax_1.BindingWhenOnSyntax(this._binding);
     };
@@ -103,7 +108,9 @@ var BindingToSyntax = (function () {
         return new binding_when_on_syntax_1.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;
 }());

package/lib/syntax/binding_when_on_syntax.d.ts

@@ -1,18 +1,18 @@
 import { interfaces } from '../interfaces/interfaces';
 declare class BindingWhenOnSyntax<T> implements interfaces.BindingWhenSyntax<T>, interfaces.BindingOnSyntax<T> {
-    private _bindingWhenSyntax;
-    private _bindingOnSyntax;
-    private _binding;
+    private readonly _bindingWhenSyntax;
+    private readonly _bindingOnSyntax;
+    private readonly _binding;
     constructor(binding: interfaces.Binding<T>);
     when(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
     whenTargetNamed(name: string): interfaces.BindingOnSyntax<T>;
     whenTargetIsDefault(): interfaces.BindingOnSyntax<T>;
     whenTargetTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
-    whenInjectedInto(parent: (NewableFunction | string)): interfaces.BindingOnSyntax<T>;
+    whenInjectedInto(parent: NewableFunction | string): interfaces.BindingOnSyntax<T>;
     whenParentNamed(name: string): interfaces.BindingOnSyntax<T>;
     whenParentTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
-    whenAnyAncestorIs(ancestor: (NewableFunction | string)): interfaces.BindingOnSyntax<T>;
-    whenNoAncestorIs(ancestor: (NewableFunction | string)): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
     whenAnyAncestorNamed(name: string): interfaces.BindingOnSyntax<T>;
     whenAnyAncestorTagged(tag: string, value: unknown): interfaces.BindingOnSyntax<T>;
     whenNoAncestorNamed(name: string): interfaces.BindingOnSyntax<T>;

package/lib/syntax/binding_when_syntax.d.ts

@@ -1,16 +1,16 @@
 import { interfaces } from '../interfaces/interfaces';
 declare class BindingWhenSyntax<T> implements interfaces.BindingWhenSyntax<T> {
-    private _binding;
+    private readonly _binding;
     constructor(binding: interfaces.Binding<T>);
     when(constraint: (request: interfaces.Request) => boolean): interfaces.BindingOnSyntax<T>;
     whenTargetNamed(name: string | number | symbol): interfaces.BindingOnSyntax<T>;
     whenTargetIsDefault(): interfaces.BindingOnSyntax<T>;
     whenTargetTagged(tag: string | number | symbol, value: unknown): interfaces.BindingOnSyntax<T>;
-    whenInjectedInto(parent: (NewableFunction | string)): interfaces.BindingOnSyntax<T>;
+    whenInjectedInto(parent: NewableFunction | string): interfaces.BindingOnSyntax<T>;
     whenParentNamed(name: string | number | symbol): interfaces.BindingOnSyntax<T>;
     whenParentTagged(tag: string | number | symbol, value: unknown): interfaces.BindingOnSyntax<T>;
-    whenAnyAncestorIs(ancestor: (NewableFunction | string)): interfaces.BindingOnSyntax<T>;
-    whenNoAncestorIs(ancestor: (NewableFunction | string)): interfaces.BindingOnSyntax<T>;
+    whenAnyAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
+    whenNoAncestorIs(ancestor: NewableFunction | string): interfaces.BindingOnSyntax<T>;
     whenAnyAncestorNamed(name: string | number | symbol): interfaces.BindingOnSyntax<T>;
     whenNoAncestorNamed(name: string | number | symbol): interfaces.BindingOnSyntax<T>;
     whenAnyAncestorTagged(tag: string | number | symbol, value: unknown): interfaces.BindingOnSyntax<T>;