inversify 6.0.2 → 6.0.3

package/es/syntax/binding_when_syntax.js

@@ -1,99 +1,99 @@
-import { BindingOnSyntax } from './binding_on_syntax';
-import { namedConstraint, taggedConstraint, traverseAncerstors, typeConstraint } from './constraint_helpers';
-var BindingWhenSyntax = (function () {
-    function BindingWhenSyntax(binding) {
-        this._binding = binding;
-    }
-    BindingWhenSyntax.prototype.when = function (constraint) {
-        this._binding.constraint = constraint;
-        return new BindingOnSyntax(this._binding);
-    };
-    BindingWhenSyntax.prototype.whenTargetNamed = function (name) {
-        this._binding.constraint = namedConstraint(name);
-        return new BindingOnSyntax(this._binding);
-    };
-    BindingWhenSyntax.prototype.whenTargetIsDefault = function () {
-        this._binding.constraint = function (request) {
-            if (request === null) {
-                return false;
-            }
-            var targetIsDefault = (request.target !== null) &&
-                (!request.target.isNamed()) &&
-                (!request.target.isTagged());
-            return targetIsDefault;
-        };
-        return new BindingOnSyntax(this._binding);
-    };
-    BindingWhenSyntax.prototype.whenTargetTagged = function (tag, value) {
-        this._binding.constraint = taggedConstraint(tag)(value);
-        return new BindingOnSyntax(this._binding);
-    };
-    BindingWhenSyntax.prototype.whenInjectedInto = function (parent) {
-        this._binding.constraint = function (request) {
-            return request !== null && typeConstraint(parent)(request.parentRequest);
-        };
-        return new BindingOnSyntax(this._binding);
-    };
-    BindingWhenSyntax.prototype.whenParentNamed = function (name) {
-        this._binding.constraint = function (request) {
-            return request !== null && namedConstraint(name)(request.parentRequest);
-        };
-        return new BindingOnSyntax(this._binding);
-    };
-    BindingWhenSyntax.prototype.whenParentTagged = function (tag, value) {
-        this._binding.constraint = function (request) {
-            return request !== null && taggedConstraint(tag)(value)(request.parentRequest);
-        };
-        return new BindingOnSyntax(this._binding);
-    };
-    BindingWhenSyntax.prototype.whenAnyAncestorIs = function (ancestor) {
-        this._binding.constraint = function (request) {
-            return request !== null && traverseAncerstors(request, typeConstraint(ancestor));
-        };
-        return new BindingOnSyntax(this._binding);
-    };
-    BindingWhenSyntax.prototype.whenNoAncestorIs = function (ancestor) {
-        this._binding.constraint = function (request) {
-            return request !== null && !traverseAncerstors(request, typeConstraint(ancestor));
-        };
-        return new BindingOnSyntax(this._binding);
-    };
-    BindingWhenSyntax.prototype.whenAnyAncestorNamed = function (name) {
-        this._binding.constraint = function (request) {
-            return request !== null && traverseAncerstors(request, namedConstraint(name));
-        };
-        return new BindingOnSyntax(this._binding);
-    };
-    BindingWhenSyntax.prototype.whenNoAncestorNamed = function (name) {
-        this._binding.constraint = function (request) {
-            return request !== null && !traverseAncerstors(request, namedConstraint(name));
-        };
-        return new BindingOnSyntax(this._binding);
-    };
-    BindingWhenSyntax.prototype.whenAnyAncestorTagged = function (tag, value) {
-        this._binding.constraint = function (request) {
-            return request !== null && traverseAncerstors(request, taggedConstraint(tag)(value));
-        };
-        return new BindingOnSyntax(this._binding);
-    };
-    BindingWhenSyntax.prototype.whenNoAncestorTagged = function (tag, value) {
-        this._binding.constraint = function (request) {
-            return request !== null && !traverseAncerstors(request, taggedConstraint(tag)(value));
-        };
-        return new BindingOnSyntax(this._binding);
-    };
-    BindingWhenSyntax.prototype.whenAnyAncestorMatches = function (constraint) {
-        this._binding.constraint = function (request) {
-            return request !== null && traverseAncerstors(request, constraint);
-        };
-        return new BindingOnSyntax(this._binding);
-    };
-    BindingWhenSyntax.prototype.whenNoAncestorMatches = function (constraint) {
-        this._binding.constraint = function (request) {
-            return request !== null && !traverseAncerstors(request, constraint);
-        };
-        return new BindingOnSyntax(this._binding);
-    };
-    return BindingWhenSyntax;
-}());
-export { BindingWhenSyntax };
+import { BindingOnSyntax } from './binding_on_syntax';
+import { namedConstraint, taggedConstraint, traverseAncerstors, typeConstraint } from './constraint_helpers';
+var BindingWhenSyntax = (function () {
+    function BindingWhenSyntax(binding) {
+        this._binding = binding;
+    }
+    BindingWhenSyntax.prototype.when = function (constraint) {
+        this._binding.constraint = constraint;
+        return new BindingOnSyntax(this._binding);
+    };
+    BindingWhenSyntax.prototype.whenTargetNamed = function (name) {
+        this._binding.constraint = namedConstraint(name);
+        return new BindingOnSyntax(this._binding);
+    };
+    BindingWhenSyntax.prototype.whenTargetIsDefault = function () {
+        this._binding.constraint = function (request) {
+            if (request === null) {
+                return false;
+            }
+            var targetIsDefault = (request.target !== null) &&
+                (!request.target.isNamed()) &&
+                (!request.target.isTagged());
+            return targetIsDefault;
+        };
+        return new BindingOnSyntax(this._binding);
+    };
+    BindingWhenSyntax.prototype.whenTargetTagged = function (tag, value) {
+        this._binding.constraint = taggedConstraint(tag)(value);
+        return new BindingOnSyntax(this._binding);
+    };
+    BindingWhenSyntax.prototype.whenInjectedInto = function (parent) {
+        this._binding.constraint = function (request) {
+            return request !== null && typeConstraint(parent)(request.parentRequest);
+        };
+        return new BindingOnSyntax(this._binding);
+    };
+    BindingWhenSyntax.prototype.whenParentNamed = function (name) {
+        this._binding.constraint = function (request) {
+            return request !== null && namedConstraint(name)(request.parentRequest);
+        };
+        return new BindingOnSyntax(this._binding);
+    };
+    BindingWhenSyntax.prototype.whenParentTagged = function (tag, value) {
+        this._binding.constraint = function (request) {
+            return request !== null && taggedConstraint(tag)(value)(request.parentRequest);
+        };
+        return new BindingOnSyntax(this._binding);
+    };
+    BindingWhenSyntax.prototype.whenAnyAncestorIs = function (ancestor) {
+        this._binding.constraint = function (request) {
+            return request !== null && traverseAncerstors(request, typeConstraint(ancestor));
+        };
+        return new BindingOnSyntax(this._binding);
+    };
+    BindingWhenSyntax.prototype.whenNoAncestorIs = function (ancestor) {
+        this._binding.constraint = function (request) {
+            return request !== null && !traverseAncerstors(request, typeConstraint(ancestor));
+        };
+        return new BindingOnSyntax(this._binding);
+    };
+    BindingWhenSyntax.prototype.whenAnyAncestorNamed = function (name) {
+        this._binding.constraint = function (request) {
+            return request !== null && traverseAncerstors(request, namedConstraint(name));
+        };
+        return new BindingOnSyntax(this._binding);
+    };
+    BindingWhenSyntax.prototype.whenNoAncestorNamed = function (name) {
+        this._binding.constraint = function (request) {
+            return request !== null && !traverseAncerstors(request, namedConstraint(name));
+        };
+        return new BindingOnSyntax(this._binding);
+    };
+    BindingWhenSyntax.prototype.whenAnyAncestorTagged = function (tag, value) {
+        this._binding.constraint = function (request) {
+            return request !== null && traverseAncerstors(request, taggedConstraint(tag)(value));
+        };
+        return new BindingOnSyntax(this._binding);
+    };
+    BindingWhenSyntax.prototype.whenNoAncestorTagged = function (tag, value) {
+        this._binding.constraint = function (request) {
+            return request !== null && !traverseAncerstors(request, taggedConstraint(tag)(value));
+        };
+        return new BindingOnSyntax(this._binding);
+    };
+    BindingWhenSyntax.prototype.whenAnyAncestorMatches = function (constraint) {
+        this._binding.constraint = function (request) {
+            return request !== null && traverseAncerstors(request, constraint);
+        };
+        return new BindingOnSyntax(this._binding);
+    };
+    BindingWhenSyntax.prototype.whenNoAncestorMatches = function (constraint) {
+        this._binding.constraint = function (request) {
+            return request !== null && !traverseAncerstors(request, constraint);
+        };
+        return new BindingOnSyntax(this._binding);
+    };
+    return BindingWhenSyntax;
+}());
+export { BindingWhenSyntax };

package/es/syntax/constraint_helpers.js

@@ -1,35 +1,35 @@
-import * as METADATA_KEY from '../constants/metadata_keys';
-import { Metadata } from '../planning/metadata';
-var traverseAncerstors = function (request, constraint) {
-    var parent = request.parentRequest;
-    if (parent !== null) {
-        return constraint(parent) ? true : traverseAncerstors(parent, constraint);
-    }
-    else {
-        return false;
-    }
-};
-var taggedConstraint = function (key) { return function (value) {
-    var constraint = function (request) {
-        return request !== null && request.target !== null && request.target.matchesTag(key)(value);
-    };
-    constraint.metaData = new Metadata(key, value);
-    return constraint;
-}; };
-var namedConstraint = taggedConstraint(METADATA_KEY.NAMED_TAG);
-var typeConstraint = function (type) { return function (request) {
-    var binding = null;
-    if (request !== null) {
-        binding = request.bindings[0];
-        if (typeof type === 'string') {
-            var serviceIdentifier = binding.serviceIdentifier;
-            return serviceIdentifier === type;
-        }
-        else {
-            var constructor = request.bindings[0].implementationType;
-            return type === constructor;
-        }
-    }
-    return false;
-}; };
-export { traverseAncerstors, taggedConstraint, namedConstraint, typeConstraint };
+import * as METADATA_KEY from '../constants/metadata_keys';
+import { Metadata } from '../planning/metadata';
+var traverseAncerstors = function (request, constraint) {
+    var parent = request.parentRequest;
+    if (parent !== null) {
+        return constraint(parent) ? true : traverseAncerstors(parent, constraint);
+    }
+    else {
+        return false;
+    }
+};
+var taggedConstraint = function (key) { return function (value) {
+    var constraint = function (request) {
+        return request !== null && request.target !== null && request.target.matchesTag(key)(value);
+    };
+    constraint.metaData = new Metadata(key, value);
+    return constraint;
+}; };
+var namedConstraint = taggedConstraint(METADATA_KEY.NAMED_TAG);
+var typeConstraint = function (type) { return function (request) {
+    var binding = null;
+    if (request !== null) {
+        binding = request.bindings[0];
+        if (typeof type === 'string') {
+            var serviceIdentifier = binding.serviceIdentifier;
+            return serviceIdentifier === type;
+        }
+        else {
+            var constructor = request.bindings[0].implementationType;
+            return type === constructor;
+        }
+    }
+    return false;
+}; };
+export { traverseAncerstors, taggedConstraint, namedConstraint, typeConstraint };

package/es/utils/async.js

@@ -1,11 +1,11 @@
-function isPromise(object) {
-    var isObjectOrFunction = (typeof object === 'object' && object !== null) || typeof object === 'function';
-    return isObjectOrFunction && typeof object.then === "function";
-}
-function isPromiseOrContainsPromise(object) {
-    if (isPromise(object)) {
-        return true;
-    }
-    return Array.isArray(object) && object.some(isPromise);
-}
-export { isPromise, isPromiseOrContainsPromise };
+function isPromise(object) {
+    var isObjectOrFunction = (typeof object === 'object' && object !== null) || typeof object === 'function';
+    return isObjectOrFunction && typeof object.then === "function";
+}
+function isPromiseOrContainsPromise(object) {
+    if (isPromise(object)) {
+        return true;
+    }
+    return Array.isArray(object) && object.some(isPromise);
+}
+export { isPromise, isPromiseOrContainsPromise };

package/es/utils/binding_utils.js

@@ -1,53 +1,53 @@
-import { getServiceIdentifierAsString } from '../utils/serialization';
-import * as ERROR_MSGS from '../constants/error_msgs';
-import { BindingTypeEnum } from '../constants/literal_types';
-import { FactoryType } from './factory_type';
-export var multiBindToService = function (container) {
-    return function (service) {
-        return function () {
-            var types = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                types[_i] = arguments[_i];
-            }
-            return types.forEach(function (t) { return container.bind(t).toService(service); });
-        };
-    };
-};
-export var ensureFullyBound = function (binding) {
-    var boundValue = null;
-    switch (binding.type) {
-        case BindingTypeEnum.ConstantValue:
-        case BindingTypeEnum.Function:
-            boundValue = binding.cache;
-            break;
-        case BindingTypeEnum.Constructor:
-        case BindingTypeEnum.Instance:
-            boundValue = binding.implementationType;
-            break;
-        case BindingTypeEnum.DynamicValue:
-            boundValue = binding.dynamicValue;
-            break;
-        case BindingTypeEnum.Provider:
-            boundValue = binding.provider;
-            break;
-        case BindingTypeEnum.Factory:
-            boundValue = binding.factory;
-            break;
-    }
-    if (boundValue === null) {
-        var serviceIdentifierAsString = getServiceIdentifierAsString(binding.serviceIdentifier);
-        throw new Error(ERROR_MSGS.INVALID_BINDING_TYPE + " " + serviceIdentifierAsString);
-    }
-};
-export var getFactoryDetails = function (binding) {
-    switch (binding.type) {
-        case BindingTypeEnum.Factory:
-            return { factory: binding.factory, factoryType: FactoryType.Factory };
-        case BindingTypeEnum.Provider:
-            return { factory: binding.provider, factoryType: FactoryType.Provider };
-        case BindingTypeEnum.DynamicValue:
-            return { factory: binding.dynamicValue, factoryType: FactoryType.DynamicValue };
-        default:
-            throw new Error("Unexpected factory type " + binding.type);
-    }
-};
+import { getServiceIdentifierAsString } from '../utils/serialization';
+import * as ERROR_MSGS from '../constants/error_msgs';
+import { BindingTypeEnum } from '../constants/literal_types';
+import { FactoryType } from './factory_type';
+export var multiBindToService = function (container) {
+    return function (service) {
+        return function () {
+            var types = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                types[_i] = arguments[_i];
+            }
+            return types.forEach(function (t) { return container.bind(t).toService(service); });
+        };
+    };
+};
+export var ensureFullyBound = function (binding) {
+    var boundValue = null;
+    switch (binding.type) {
+        case BindingTypeEnum.ConstantValue:
+        case BindingTypeEnum.Function:
+            boundValue = binding.cache;
+            break;
+        case BindingTypeEnum.Constructor:
+        case BindingTypeEnum.Instance:
+            boundValue = binding.implementationType;
+            break;
+        case BindingTypeEnum.DynamicValue:
+            boundValue = binding.dynamicValue;
+            break;
+        case BindingTypeEnum.Provider:
+            boundValue = binding.provider;
+            break;
+        case BindingTypeEnum.Factory:
+            boundValue = binding.factory;
+            break;
+    }
+    if (boundValue === null) {
+        var serviceIdentifierAsString = getServiceIdentifierAsString(binding.serviceIdentifier);
+        throw new Error("".concat(ERROR_MSGS.INVALID_BINDING_TYPE, " ").concat(serviceIdentifierAsString));
+    }
+};
+export var getFactoryDetails = function (binding) {
+    switch (binding.type) {
+        case BindingTypeEnum.Factory:
+            return { factory: binding.factory, factoryType: FactoryType.Factory };
+        case BindingTypeEnum.Provider:
+            return { factory: binding.provider, factoryType: FactoryType.Provider };
+        case BindingTypeEnum.DynamicValue:
+            return { factory: binding.dynamicValue, factoryType: FactoryType.DynamicValue };
+        default:
+            throw new Error("Unexpected factory type ".concat(binding.type));
+    }
+};

package/es/utils/clonable.js

@@ -1,7 +1,7 @@
-function isClonable(obj) {
-    return (typeof obj === 'object')
-        && (obj !== null)
-        && ('clone' in obj)
-        && typeof obj.clone === 'function';
-}
-export { isClonable };
+function isClonable(obj) {
+    return (typeof obj === 'object')
+        && (obj !== null)
+        && ('clone' in obj)
+        && typeof obj.clone === 'function';
+}
+export { isClonable };

package/es/utils/exceptions.js

@@ -1,16 +1,16 @@
-import * as ERROR_MSGS from '../constants/error_msgs';
-export function isStackOverflowExeption(error) {
-    return (error instanceof RangeError ||
-        error.message === ERROR_MSGS.STACK_OVERFLOW);
-}
-export var tryAndThrowErrorIfStackOverflow = function (fn, errorCallback) {
-    try {
-        return fn();
-    }
-    catch (error) {
-        if (isStackOverflowExeption(error)) {
-            error = errorCallback();
-        }
-        throw error;
-    }
-};
+import * as ERROR_MSGS from '../constants/error_msgs';
+export function isStackOverflowException(error) {
+    return (error instanceof RangeError ||
+        error.message === ERROR_MSGS.STACK_OVERFLOW);
+}
+export var tryAndThrowErrorIfStackOverflow = function (fn, errorCallback) {
+    try {
+        return fn();
+    }
+    catch (error) {
+        if (isStackOverflowException(error)) {
+            error = errorCallback();
+        }
+        throw error;
+    }
+};

package/es/utils/factory_type.js

@@ -1,6 +1,6 @@
-export var FactoryType;
-(function (FactoryType) {
-    FactoryType["DynamicValue"] = "toDynamicValue";
-    FactoryType["Factory"] = "toFactory";
-    FactoryType["Provider"] = "toProvider";
-})(FactoryType || (FactoryType = {}));
+export var FactoryType;
+(function (FactoryType) {
+    FactoryType["DynamicValue"] = "toDynamicValue";
+    FactoryType["Factory"] = "toFactory";
+    FactoryType["Provider"] = "toProvider";
+})(FactoryType || (FactoryType = {}));

package/es/utils/id.js

@@ -1,5 +1,5 @@
-var idCounter = 0;
-function id() {
-    return idCounter++;
-}
-export { id };
+var idCounter = 0;
+function id() {
+    return idCounter++;
+}
+export { id };

package/es/utils/js.js

@@ -1,13 +1,13 @@
-export function getFirstArrayDuplicate(array) {
-    var seenValues = new Set();
-    for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
-        var entry = array_1[_i];
-        if (seenValues.has(entry)) {
-            return entry;
-        }
-        else {
-            seenValues.add(entry);
-        }
-    }
-    return undefined;
-}
+export function getFirstArrayDuplicate(array) {
+    var seenValues = new Set();
+    for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {
+        var entry = array_1[_i];
+        if (seenValues.has(entry)) {
+            return entry;
+        }
+        else {
+            seenValues.add(entry);
+        }
+    }
+    return undefined;
+}