inversify 4.9.0 → 4.13.0

package/amd/annotation/inject.js

@@ -1,8 +1,21 @@
-define(["require", "exports", "../constants/metadata_keys", "../planning/metadata", "./decorator_utils"], function (require, exports, METADATA_KEY, metadata_1, decorator_utils_1) {
+define(["require", "exports", "../constants/error_msgs", "../constants/metadata_keys", "../planning/metadata", "./decorator_utils"], function (require, exports, error_msgs_1, METADATA_KEY, metadata_1, decorator_utils_1) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
+    var LazyServiceIdentifer = (function () {
+        function LazyServiceIdentifer(cb) {
+            this._cb = cb;
+        }
+        LazyServiceIdentifer.prototype.unwrap = function () {
+            return this._cb();
+        };
+        return LazyServiceIdentifer;
+    }());
+    exports.LazyServiceIdentifer = LazyServiceIdentifer;
     function inject(serviceIdentifier) {
         return function (target, targetKey, index) {
+            if (serviceIdentifier === undefined) {
+                throw new Error(error_msgs_1.UNDEFINED_INJECT_ANNOTATION(target.name));
+            }
             var metadata = new metadata_1.Metadata(METADATA_KEY.INJECT_TAG, serviceIdentifier);
             if (typeof index === "number") {
                 decorator_utils_1.tagParameter(target, targetKey, index, metadata);

package/amd/constants/error_msgs.js

@@ -10,6 +10,11 @@ define(["require", "exports"], function (require, exports) {
     exports.NOT_REGISTERED = "No matching bindings found for serviceIdentifier:";
     exports.MISSING_INJECTABLE_ANNOTATION = "Missing required @injectable annotation in:";
     exports.MISSING_INJECT_ANNOTATION = "Missing required @inject or @multiInject annotation in:";
+    exports.UNDEFINED_INJECT_ANNOTATION = function (name) {
+        return "@inject called with undefined this could mean that the class " + name + " has " +
+            "a circular dependency problem. You can use a LazyServiceIdentifer to  " +
+            "overcome this limitation.";
+    };
     exports.CIRCULAR_DEPENDENCY = "Circular dependency found:";
     exports.NOT_IMPLEMENTED = "Sorry, this feature is not fully implemented yet.";
     exports.INVALID_BINDING_TYPE = "Invalid binding type:";
@@ -20,14 +25,22 @@ define(["require", "exports"], function (require, exports) {
         "used as service identifier";
     exports.INVALID_DECORATOR_OPERATION = "The @inject @multiInject @tagged and @named decorators " +
         "must be applied to the parameters of a class constructor or a class property.";
-    exports.ARGUMENTS_LENGTH_MISMATCH_1 = "The number of constructor arguments in the derived class ";
-    exports.ARGUMENTS_LENGTH_MISMATCH_2 = " must be >= than the number of constructor arguments of its base class.";
+    exports.ARGUMENTS_LENGTH_MISMATCH = function () {
+        var values = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            values[_i] = arguments[_i];
+        }
+        return "The number of constructor arguments in the derived class " +
+            (values[0] + " must be >= than the number of constructor arguments of its base class.");
+    };
     exports.CONTAINER_OPTIONS_MUST_BE_AN_OBJECT = "Invalid Container constructor argument. Container options " +
         "must be an object.";
     exports.CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE = "Invalid Container option. Default scope must " +
         "be a string ('singleton' or 'transient').";
     exports.CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE = "Invalid Container option. Auto bind injectable must " +
         "be a boolean";
+    exports.CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK = "Invalid Container option. Skip base check must " +
+        "be a boolean";
     exports.MULTIPLE_POST_CONSTRUCT_METHODS = "Cannot apply @postConstruct decorator multiple times in the same class";
     exports.POST_CONSTRUCT_ERROR = function () {
         var values = [];

package/amd/container/container.js

@@ -1,35 +1,72 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = y[op[0] & 2 ? "return" : op[0] ? "throw" : "next"]) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [0, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 define(["require", "exports", "../bindings/binding", "../constants/error_msgs", "../constants/literal_types", "../constants/metadata_keys", "../planning/metadata_reader", "../planning/planner", "../resolution/resolver", "../syntax/binding_to_syntax", "../utils/guid", "../utils/serialization", "./container_snapshot", "./lookup"], function (require, exports, binding_1, ERROR_MSGS, literal_types_1, METADATA_KEY, metadata_reader_1, planner_1, resolver_1, binding_to_syntax_1, guid_1, serialization_1, container_snapshot_1, lookup_1) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     var Container = (function () {
         function Container(containerOptions) {
-            if (containerOptions !== undefined) {
-                if (typeof containerOptions !== "object") {
-                    throw new Error("" + ERROR_MSGS.CONTAINER_OPTIONS_MUST_BE_AN_OBJECT);
-                }
-                else {
-                    if (containerOptions.defaultScope !== undefined &&
-                        containerOptions.defaultScope !== literal_types_1.BindingScopeEnum.Singleton &&
-                        containerOptions.defaultScope !== literal_types_1.BindingScopeEnum.Transient &&
-                        containerOptions.defaultScope !== literal_types_1.BindingScopeEnum.Request) {
-                        throw new Error("" + ERROR_MSGS.CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE);
-                    }
-                    if (containerOptions.autoBindInjectable !== undefined &&
-                        typeof containerOptions.autoBindInjectable !== "boolean") {
-                        throw new Error("" + ERROR_MSGS.CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE);
-                    }
-                }
-                this.options = {
-                    autoBindInjectable: containerOptions.autoBindInjectable,
-                    defaultScope: containerOptions.defaultScope
-                };
+            var options = containerOptions || {};
+            if (typeof options !== "object") {
+                throw new Error("" + ERROR_MSGS.CONTAINER_OPTIONS_MUST_BE_AN_OBJECT);
             }
-            else {
-                this.options = {
-                    autoBindInjectable: false,
-                    defaultScope: literal_types_1.BindingScopeEnum.Transient
-                };
+            if (options.defaultScope === undefined) {
+                options.defaultScope = literal_types_1.BindingScopeEnum.Transient;
+            }
+            else if (options.defaultScope !== literal_types_1.BindingScopeEnum.Singleton &&
+                options.defaultScope !== literal_types_1.BindingScopeEnum.Transient &&
+                options.defaultScope !== literal_types_1.BindingScopeEnum.Request) {
+                throw new Error("" + ERROR_MSGS.CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE);
+            }
+            if (options.autoBindInjectable === undefined) {
+                options.autoBindInjectable = false;
             }
+            else if (typeof options.autoBindInjectable !== "boolean") {
+                throw new Error("" + ERROR_MSGS.CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE);
+            }
+            if (options.skipBaseClassChecks === undefined) {
+                options.skipBaseClassChecks = false;
+            }
+            else if (typeof options.skipBaseClassChecks !== "boolean") {
+                throw new Error("" + ERROR_MSGS.CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK);
+            }
+            this.options = {
+                autoBindInjectable: options.autoBindInjectable,
+                defaultScope: options.defaultScope,
+                skipBaseClassChecks: options.skipBaseClassChecks
+            };
             this.guid = guid_1.guid();
             this._bindingDictionary = new lookup_1.Lookup();
             this._snapshots = [];
@@ -54,46 +91,44 @@ define(["require", "exports", "../bindings/binding", "../constants/error_msgs",
             return container;
         };
         Container.prototype.load = function () {
-            var _this = this;
             var modules = [];
             for (var _i = 0; _i < arguments.length; _i++) {
                 modules[_i] = arguments[_i];
             }
-            var setModuleId = function (bindingToSyntax, moduleId) {
-                bindingToSyntax._binding.moduleId = moduleId;
-            };
-            var getBindFunction = function (moduleId) {
-                return function (serviceIdentifier) {
-                    var bindingToSyntax = _this.bind.call(_this, serviceIdentifier);
-                    setModuleId(bindingToSyntax, moduleId);
-                    return bindingToSyntax;
-                };
-            };
-            var getUnbindFunction = function (moduleId) {
-                return function (serviceIdentifier) {
-                    var _unbind = _this.unbind.bind(_this);
-                    _unbind(serviceIdentifier);
-                };
-            };
-            var getIsboundFunction = function (moduleId) {
-                return function (serviceIdentifier) {
-                    var _isBound = _this.isBound.bind(_this);
-                    return _isBound(serviceIdentifier);
-                };
-            };
-            var getRebindFunction = function (moduleId) {
-                return function (serviceIdentifier) {
-                    var bindingToSyntax = _this.rebind.call(_this, serviceIdentifier);
-                    setModuleId(bindingToSyntax, moduleId);
-                    return bindingToSyntax;
-                };
-            };
-            modules.forEach(function (module) {
-                var bindFunction = getBindFunction(module.guid);
-                var unbindFunction = getUnbindFunction(module.guid);
-                var isboundFunction = getIsboundFunction(module.guid);
-                var rebindFunction = getRebindFunction(module.guid);
-                module.registry(bindFunction, unbindFunction, isboundFunction, rebindFunction);
+            var getHelpers = this._getContainerModuleHelpersFactory();
+            for (var _a = 0, modules_1 = modules; _a < modules_1.length; _a++) {
+                var currentModule = modules_1[_a];
+                var containerModuleHelpers = getHelpers(currentModule.guid);
+                currentModule.registry(containerModuleHelpers.bindFunction, containerModuleHelpers.unbindFunction, containerModuleHelpers.isboundFunction, containerModuleHelpers.rebindFunction);
+            }
+        };
+        Container.prototype.loadAsync = function () {
+            var modules = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                modules[_i] = arguments[_i];
+            }
+            return __awaiter(this, void 0, void 0, function () {
+                var getHelpers, _a, modules_2, currentModule, containerModuleHelpers;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            getHelpers = this._getContainerModuleHelpersFactory();
+                            _a = 0, modules_2 = modules;
+                            _b.label = 1;
+                        case 1:
+                            if (!(_a < modules_2.length)) return [3, 4];
+                            currentModule = modules_2[_a];
+                            containerModuleHelpers = getHelpers(currentModule.guid);
+                            return [4, currentModule.registry(containerModuleHelpers.bindFunction, containerModuleHelpers.unbindFunction, containerModuleHelpers.isboundFunction, containerModuleHelpers.rebindFunction)];
+                        case 2:
+                            _b.sent();
+                            _b.label = 3;
+                        case 3:
+                            _a++;
+                            return [3, 1];
+                        case 4: return [2];
+                    }
+                });
             });
         };
         Container.prototype.unload = function () {
@@ -164,8 +199,8 @@ define(["require", "exports", "../bindings/binding", "../constants/error_msgs",
             this._bindingDictionary = snapshot.bindings;
             this._middleware = snapshot.middleware;
         };
-        Container.prototype.createChild = function () {
-            var child = new Container();
+        Container.prototype.createChild = function (containerOptions) {
+            var child = new Container(containerOptions);
             child.parent = this;
             return child;
         };
@@ -204,6 +239,46 @@ define(["require", "exports", "../bindings/binding", "../constants/error_msgs",
             tempContainer.parent = this;
             return tempContainer.get(constructorFunction);
         };
+        Container.prototype._getContainerModuleHelpersFactory = function () {
+            var _this = this;
+            var setModuleId = function (bindingToSyntax, moduleId) {
+                bindingToSyntax._binding.moduleId = moduleId;
+            };
+            var getBindFunction = function (moduleId) {
+                return function (serviceIdentifier) {
+                    var _bind = _this.bind.bind(_this);
+                    var bindingToSyntax = _bind(serviceIdentifier);
+                    setModuleId(bindingToSyntax, moduleId);
+                    return bindingToSyntax;
+                };
+            };
+            var getUnbindFunction = function (moduleId) {
+                return function (serviceIdentifier) {
+                    var _unbind = _this.unbind.bind(_this);
+                    _unbind(serviceIdentifier);
+                };
+            };
+            var getIsboundFunction = function (moduleId) {
+                return function (serviceIdentifier) {
+                    var _isBound = _this.isBound.bind(_this);
+                    return _isBound(serviceIdentifier);
+                };
+            };
+            var getRebindFunction = function (moduleId) {
+                return function (serviceIdentifier) {
+                    var _rebind = _this.rebind.bind(_this);
+                    var bindingToSyntax = _rebind(serviceIdentifier);
+                    setModuleId(bindingToSyntax, moduleId);
+                    return bindingToSyntax;
+                };
+            };
+            return function (mId) { return ({
+                bindFunction: getBindFunction(mId),
+                isboundFunction: getIsboundFunction(mId),
+                rebindFunction: getRebindFunction(mId),
+                unbindFunction: getUnbindFunction(mId)
+            }); };
+        };
         Container.prototype._get = function (avoidConstraints, isMultiInject, targetType, serviceIdentifier, key, value) {
             var result = null;
             var defaultArgs = {

package/amd/container/container_module.js

@@ -9,4 +9,12 @@ define(["require", "exports", "../utils/guid"], function (require, exports, guid
         return ContainerModule;
     }());
     exports.ContainerModule = ContainerModule;
+    var AsyncContainerModule = (function () {
+        function AsyncContainerModule(registry) {
+            this.guid = guid_1.guid();
+            this.registry = registry;
+        }
+        return AsyncContainerModule;
+    }());
+    exports.AsyncContainerModule = AsyncContainerModule;
 });

package/amd/inversify.js

@@ -6,11 +6,13 @@ define(["require", "exports", "./constants/metadata_keys", "./container/containe
     exports.BindingScopeEnum = literal_types_1.BindingScopeEnum;
     exports.BindingTypeEnum = literal_types_1.BindingTypeEnum;
     exports.TargetTypeEnum = literal_types_1.TargetTypeEnum;
+    exports.AsyncContainerModule = container_module_1.AsyncContainerModule;
     exports.ContainerModule = container_module_1.ContainerModule;
     exports.injectable = injectable_1.injectable;
     exports.tagged = tagged_1.tagged;
     exports.named = named_1.named;
     exports.inject = inject_1.inject;
+    exports.LazyServiceIdentifer = inject_1.LazyServiceIdentifer;
     exports.optional = optional_1.optional;
     exports.unmanaged = unmanaged_1.unmanaged;
     exports.multiInject = multi_inject_1.multiInject;

package/amd/planning/planner.js

@@ -93,6 +93,13 @@ define(["require", "exports", "../bindings/binding_count", "../constants/error_m
             }
             if (binding.type === literal_types_1.BindingTypeEnum.Instance && binding.implementationType !== null) {
                 var dependencies = reflection_utils_1.getDependencies(metadataReader, binding.implementationType);
+                if (!context.container.options.skipBaseClassChecks) {
+                    var baseClassDependencyCount = reflection_utils_1.getBaseClassDependencyCount(metadataReader, binding.implementationType);
+                    if (dependencies.length < baseClassDependencyCount) {
+                        var error = ERROR_MSGS.ARGUMENTS_LENGTH_MISMATCH(reflection_utils_1.getFunctionName(binding.implementationType));
+                        throw new Error(error);
+                    }
+                }
                 dependencies.forEach(function (dependency) {
                     _createSubRequests(metadataReader, false, dependency.serviceIdentifier, context, subChildRequest, dependency);
                 });

package/amd/planning/reflection_utils.js

@@ -1,6 +1,7 @@
-define(["require", "exports", "../constants/error_msgs", "../constants/literal_types", "../constants/metadata_keys", "../utils/serialization", "./target"], function (require, exports, ERROR_MSGS, literal_types_1, METADATA_KEY, serialization_1, target_1) {
+define(["require", "exports", "../annotation/inject", "../constants/error_msgs", "../constants/literal_types", "../constants/metadata_keys", "../utils/serialization", "./target"], function (require, exports, inject_1, ERROR_MSGS, literal_types_1, METADATA_KEY, serialization_1, target_1) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getFunctionName = serialization_1.getFunctionName;
     function getDependencies(metadataReader, func) {
         var constructorName = serialization_1.getFunctionName(func);
         var targets = getTargets(metadataReader, constructorName, func, false);
@@ -21,12 +22,6 @@ define(["require", "exports", "../constants/error_msgs", "../constants/literal_t
         var constructorTargets = getConstructorArgsAsTargets(isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata, iterations);
         var propertyTargets = getClassPropsAsTargets(metadataReader, func);
         var targets = constructorTargets.concat(propertyTargets);
-        var baseClassDependencyCount = getBaseClassDependencyCount(metadataReader, func);
-        if (targets.length < baseClassDependencyCount) {
-            var error = ERROR_MSGS.ARGUMENTS_LENGTH_MISMATCH_1 +
-                constructorName + ERROR_MSGS.ARGUMENTS_LENGTH_MISMATCH_2;
-            throw new Error(error);
-        }
         return targets;
     }
     function getConstructorArgsAsTarget(index, isBaseClass, constructorName, serviceIdentifiers, constructorArgsMetadata) {
@@ -36,6 +31,9 @@ define(["require", "exports", "../constants/error_msgs", "../constants/literal_t
         var serviceIdentifier = serviceIdentifiers[index];
         var injectIdentifier = (metadata.inject || metadata.multiInject);
         serviceIdentifier = (injectIdentifier) ? (injectIdentifier) : serviceIdentifier;
+        if (serviceIdentifier instanceof inject_1.LazyServiceIdentifer) {
+            serviceIdentifier = serviceIdentifier.unwrap();
+        }
         if (isManaged) {
             var isObject = serviceIdentifier === Object;
             var isFunction = serviceIdentifier === Function;
@@ -106,6 +104,7 @@ define(["require", "exports", "../constants/error_msgs", "../constants/literal_t
             return 0;
         }
     }
+    exports.getBaseClassDependencyCount = getBaseClassDependencyCount;
     function formatTargetMetadata(targetMetadata) {
         var targetMetadataMap = {};
         targetMetadata.forEach(function (m) {

package/appveyor.yml

@@ -1,34 +1,34 @@
-# AppVeyor file
-# http://www.appveyor.com/docs/appveyor-yml
-
-# Build version format
-version: "{build}"
-
-# Test against this version of Node.js
-environment:
-  NODE_ENV: test
-
-  matrix:
-    - nodejs_version: "9.3.0"
-
-build: off
-
-branches:
-  only:
-  - master
-
-install:
-  - ps: Install-Product node $env:nodejs_version
-  - npm install -g npm
-  - npm config set progress=false
-  - npm install
-
-# Fix line endings on Windows
-init:
-  - git config --global core.autocrlf true
-
-test_script:
-  # Output useful info for debugging.
-  - node --version && npm --version
-  - ps: "npm --version # PowerShell" # Pass comment to PS for easier debugging
-  - cmd: npm run test
+# AppVeyor file
+# http://www.appveyor.com/docs/appveyor-yml
+
+# Build version format
+version: "{build}"
+
+# Test against this version of Node.js
+environment:
+  NODE_ENV: test
+
+  matrix:
+    - nodejs_version: "9.3.0"
+
+build: off
+
+branches:
+  only:
+  - master
+
+install:
+  - ps: Install-Product node $env:nodejs_version
+  - npm install -g npm
+  - npm config set progress=false
+  - npm install
+
+# Fix line endings on Windows
+init:
+  - git config --global core.autocrlf true
+
+test_script:
+  # Output useful info for debugging.
+  - node --version && npm --version
+  - ps: "npm --version # PowerShell" # Pass comment to PS for easier debugging
+  - cmd: npm run test

package/dts/annotation/inject.d.ts

@@ -1,3 +1,9 @@
 import { interfaces } from "../interfaces/interfaces";
-declare function inject(serviceIdentifier: interfaces.ServiceIdentifier<any>): (target: any, targetKey: string, index?: number | undefined) => void;
+export declare type ServiceIdentifierOrFunc = interfaces.ServiceIdentifier<any> | LazyServiceIdentifer;
+export declare class LazyServiceIdentifer<T = any> {
+    private _cb;
+    constructor(cb: () => interfaces.ServiceIdentifier<T>);
+    unwrap(): string | symbol | interfaces.Newable<T> | interfaces.Abstract<T>;
+}
+declare function inject(serviceIdentifier: ServiceIdentifierOrFunc): (target: any, targetKey: string, index?: number | undefined) => void;
 export { inject };

package/dts/constants/error_msgs.d.ts

@@ -7,6 +7,7 @@ export declare const CANNOT_UNBIND = "Could not unbind serviceIdentifier:";
 export declare const NOT_REGISTERED = "No matching bindings found for serviceIdentifier:";
 export declare const MISSING_INJECTABLE_ANNOTATION = "Missing required @injectable annotation in:";
 export declare const MISSING_INJECT_ANNOTATION = "Missing required @inject or @multiInject annotation in:";
+export declare const UNDEFINED_INJECT_ANNOTATION: (name: string) => string;
 export declare const CIRCULAR_DEPENDENCY = "Circular dependency found:";
 export declare const NOT_IMPLEMENTED = "Sorry, this feature is not fully implemented yet.";
 export declare const INVALID_BINDING_TYPE = "Invalid binding type:";
@@ -15,11 +16,11 @@ export declare const INVALID_MIDDLEWARE_RETURN = "Invalid return type in middlew
 export declare const INVALID_FUNCTION_BINDING = "Value provided to function binding must be a function!";
 export declare const INVALID_TO_SELF_VALUE: string;
 export declare const INVALID_DECORATOR_OPERATION: string;
-export declare const ARGUMENTS_LENGTH_MISMATCH_1 = "The number of constructor arguments in the derived class ";
-export declare const ARGUMENTS_LENGTH_MISMATCH_2 = " must be >= than the number of constructor arguments of its base class.";
+export declare const ARGUMENTS_LENGTH_MISMATCH: (...values: any[]) => string;
 export declare const CONTAINER_OPTIONS_MUST_BE_AN_OBJECT: string;
 export declare const CONTAINER_OPTIONS_INVALID_DEFAULT_SCOPE: string;
 export declare const CONTAINER_OPTIONS_INVALID_AUTO_BIND_INJECTABLE: string;
+export declare const CONTAINER_OPTIONS_INVALID_SKIP_BASE_CHECK: string;
 export declare const MULTIPLE_POST_CONSTRUCT_METHODS = "Cannot apply @postConstruct decorator multiple times in the same class";
 export declare const POST_CONSTRUCT_ERROR: (...values: any[]) => string;
 export declare const CIRCULAR_DEPENDENCY_IN_FACTORY: (...values: any[]) => string;

package/dts/container/container.d.ts

@@ -10,6 +10,7 @@ declare class Container implements interfaces.Container {
     static merge(container1: interfaces.Container, container2: interfaces.Container): interfaces.Container;
     constructor(containerOptions?: interfaces.ContainerOptions);
     load(...modules: interfaces.ContainerModule[]): void;
+    loadAsync(...modules: interfaces.AsyncContainerModule[]): Promise<void>;
     unload(...modules: interfaces.ContainerModule[]): void;
     bind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;
     rebind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;
@@ -20,7 +21,7 @@ declare class Container implements interfaces.Container {
     isBoundTagged(serviceIdentifier: interfaces.ServiceIdentifier<any>, key: string | number | symbol, value: any): boolean;
     snapshot(): void;
     restore(): void;
-    createChild(): Container;
+    createChild(containerOptions?: interfaces.ContainerOptions): Container;
     applyMiddleware(...middlewares: interfaces.Middleware[]): void;
     applyCustomMetadataReader(metadataReader: interfaces.MetadataReader): void;
     get<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T;
@@ -30,6 +31,7 @@ declare class Container implements interfaces.Container {
     getAllTagged<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, key: string | number | symbol, value: any): T[];
     getAllNamed<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): T[];
     resolve<T>(constructorFunction: interfaces.Newable<T>): T;
+    private _getContainerModuleHelpersFactory();
     private _get<T>(avoidConstraints, isMultiInject, targetType, serviceIdentifier, key?, value?);
     private _planAndResolve<T>();
 }

package/dts/container/container_module.d.ts

@@ -1,7 +1,11 @@
 import { interfaces } from "../interfaces/interfaces";
-declare class ContainerModule implements interfaces.ContainerModule {
+export declare class ContainerModule implements interfaces.ContainerModule {
     guid: string;
     registry: interfaces.ContainerModuleCallBack;
     constructor(registry: interfaces.ContainerModuleCallBack);
 }
-export { ContainerModule };
+export declare class AsyncContainerModule implements interfaces.AsyncContainerModule {
+    guid: string;
+    registry: interfaces.AsyncContainerModuleCallBack;
+    constructor(registry: interfaces.AsyncContainerModuleCallBack);
+}

package/dts/interfaces/interfaces.d.ts

@@ -122,6 +122,7 @@ declare namespace interfaces {
     interface ContainerOptions {
         autoBindInjectable?: boolean;
         defaultScope?: BindingScope;
+        skipBaseClassChecks?: boolean;
     }
     interface Container {
         guid: string;
@@ -140,6 +141,7 @@ declare namespace interfaces {
         getAll<T>(serviceIdentifier: ServiceIdentifier<T>): T[];
         resolve<T>(constructorFunction: interfaces.Newable<T>): T;
         load(...modules: ContainerModule[]): void;
+        loadAsync(...modules: AsyncContainerModule[]): Promise<void>;
         unload(...modules: ContainerModule[]): void;
         applyCustomMetadataReader(metadataReader: MetadataReader): void;
         applyMiddleware(...middleware: Middleware[]): void;
@@ -155,7 +157,12 @@ declare namespace interfaces {
         guid: string;
         registry: ContainerModuleCallBack;
     }
+    interface AsyncContainerModule {
+        guid: string;
+        registry: AsyncContainerModuleCallBack;
+    }
     type ContainerModuleCallBack = (bind: interfaces.Bind, unbind: interfaces.Unbind, isBound: interfaces.IsBound, rebind: interfaces.Rebind) => void;
+    type AsyncContainerModuleCallBack = (bind: interfaces.Bind, unbind: interfaces.Unbind, isBound: interfaces.IsBound, rebind: interfaces.Rebind) => Promise<void>;
     interface ContainerSnapshot {
         bindings: Lookup<Binding<any>>;
         middleware: Next | null;

package/dts/inversify.d.ts

@@ -2,11 +2,11 @@ import * as keys from "./constants/metadata_keys";
 export declare const METADATA_KEY: typeof keys;
 export { Container } from "./container/container";
 export { BindingScopeEnum, BindingTypeEnum, TargetTypeEnum } from "./constants/literal_types";
-export { ContainerModule } from "./container/container_module";
+export { AsyncContainerModule, ContainerModule } from "./container/container_module";
 export { injectable } from "./annotation/injectable";
 export { tagged } from "./annotation/tagged";
 export { named } from "./annotation/named";
-export { inject } from "./annotation/inject";
+export { inject, LazyServiceIdentifer } from "./annotation/inject";
 export { optional } from "./annotation/optional";
 export { unmanaged } from "./annotation/unmanaged";
 export { multiInject } from "./annotation/multi_inject";

package/dts/planning/reflection_utils.d.ts

@@ -1,3 +1,5 @@
 import { interfaces } from "../interfaces/interfaces";
+import { getFunctionName } from "../utils/serialization";
 declare function getDependencies(metadataReader: interfaces.MetadataReader, func: Function): interfaces.Target[];
-export { getDependencies };
+declare function getBaseClassDependencyCount(metadataReader: interfaces.MetadataReader, func: Function): number;
+export { getDependencies, getBaseClassDependencyCount, getFunctionName };

package/es/annotation/inject.js

@@ -1,8 +1,22 @@
+import { UNDEFINED_INJECT_ANNOTATION } from "../constants/error_msgs";
 import * as METADATA_KEY from "../constants/metadata_keys";
 import { Metadata } from "../planning/metadata";
 import { tagParameter, tagProperty } from "./decorator_utils";
+var LazyServiceIdentifer = (function () {
+    function LazyServiceIdentifer(cb) {
+        this._cb = cb;
+    }
+    LazyServiceIdentifer.prototype.unwrap = function () {
+        return this._cb();
+    };
+    return LazyServiceIdentifer;
+}());
+export { LazyServiceIdentifer };
 function inject(serviceIdentifier) {
     return function (target, targetKey, index) {
+        if (serviceIdentifier === undefined) {
+            throw new Error(UNDEFINED_INJECT_ANNOTATION(target.name));
+        }
         var metadata = new Metadata(METADATA_KEY.INJECT_TAG, serviceIdentifier);
         if (typeof index === "number") {
             tagParameter(target, targetKey, index, metadata);