inversify-binding-decorators - npm Package Compare versions

Comparing version 3.2.0 to 4.0.0

amd/decorator/fluent_provide.js

 define(["require", "exports", "../syntax/provide_in_when_on_syntax", "../syntax/provide_when_syntax", "../syntax/provide_on_syntax", "../syntax/provide_in_syntax", "../syntax/provide_done_syntax"], function (require, exports, provide_in_when_on_syntax_1, provide_when_syntax_1, provide_on_syntax_1, provide_in_syntax_1, provide_done_syntax_1) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    function fluentProvide(container) {
-        // function is named for testing
-        return function _fluentProvide(serviceIdentifier) {
-            var bindingWhenOnSyntax = container.bind(serviceIdentifier).to(null);
-            var binding = bindingWhenOnSyntax._binding;
-            var provideDoneSyntax = new provide_done_syntax_1.default(binding);
-            var provideInWhenOnSyntax = new provide_in_when_on_syntax_1.default(new provide_in_syntax_1.default(bindingWhenOnSyntax, provideDoneSyntax), new provide_when_syntax_1.default(bindingWhenOnSyntax, provideDoneSyntax), new provide_on_syntax_1.default(bindingWhenOnSyntax, provideDoneSyntax));
-            return provideInWhenOnSyntax;
-        };
+    function fluentProvide(serviceIdentifier) {
+        var bindingWhenOnSyntax = function (bind, target) { return bind(serviceIdentifier).to(target); };
+        var bindingConstraintFunction = function (bind, target) { return bindingWhenOnSyntax(bind, target)._binding; };
+        var provideDoneSyntax = new provide_done_syntax_1.default(bindingConstraintFunction);
+        var provideInWhenOnSyntax = new provide_in_when_on_syntax_1.default(new provide_in_syntax_1.default(function (bind, target) { return bindingWhenOnSyntax(bind, target); }, provideDoneSyntax), new provide_when_syntax_1.default(bindingWhenOnSyntax, provideDoneSyntax), new provide_on_syntax_1.default(bindingWhenOnSyntax, provideDoneSyntax));
+        return provideInWhenOnSyntax;
     }
     exports.default = fluentProvide;
 });

amd/decorator/provide.js

@@ -1,30 +0,32 @@
-define(["require", "exports", "inversify"], function (require, exports, inversify_1) {
+define(["require", "exports", "inversify", "../constants"], function (require, exports, inversify_1, constants_1) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    function provide(container) {
-        return function _provide(serviceIdentifier, force) {
-            var bindingWhenOnSyntax = container.bind(serviceIdentifier).to(null);
-            return function (target) {
-                var isAlreadyDecorated = Reflect.hasOwnMetadata(inversify_1.METADATA_KEY.PARAM_TYPES, target);
-                var redecorateWithInject = force === true;
-                if (redecorateWithInject === true && isAlreadyDecorated === false) {
+    function provide(serviceIdentifier, force) {
+        return function (target) {
+            var isAlreadyDecorated = Reflect.hasOwnMetadata(inversify_1.METADATA_KEY.PARAM_TYPES, target);
+            var redecorateWithInject = force === true;
+            if (redecorateWithInject === true && isAlreadyDecorated === false) {
+                inversify_1.decorate(inversify_1.injectable(), target);
+            }
+            else if (redecorateWithInject === true && isAlreadyDecorated === true) {
+                // Do nothing
+            }
+            else {
+                try {
                     inversify_1.decorate(inversify_1.injectable(), target);
                 }
-                else if (redecorateWithInject === true && isAlreadyDecorated === true) {
-                    // Do nothing
+                catch (e) {
+                    throw new Error("Cannot apply @provide decorator multiple times but is has been used " +
+                        ("multiple times in " + target.name + " ") +
+                        "Please use @provide(ID, true) if you are trying to declare multiple bindings!");
                 }
-                else {
-                    try {
-                        inversify_1.decorate(inversify_1.injectable(), target);
-                    }
-                    catch (e) {
-                        throw new Error("Cannot apply @provide decorator multiple times but is has been used " +
-                            ("multiple times in " + target.name + " ") +
-                            "Please use @provide(ID, true) if you are trying to declare multiple bindings!");
-                    }
-                }
-                var binding = bindingWhenOnSyntax._binding;
-                binding.implementationType = target;
-                return target;
+            }
+            var currentMetadata = {
+                constraint: function (bind, bindTarget) { return bind(serviceIdentifier).to(bindTarget); },
+                implementationType: target
             };
+            var previousMetadata = Reflect.getMetadata(constants_1.METADATA_KEY.provide, Reflect) || [];
+            var newMetadata = [currentMetadata].concat(previousMetadata);
+            Reflect.defineMetadata(constants_1.METADATA_KEY.provide, newMetadata, Reflect);
+            return target;
         };
@@ -31,0 +33,0 @@ }

amd/index.js

@@ -1,7 +0,8 @@
-define(["require", "exports", "./factory/provide_decorator_factory", "./factory/fluent_provide_decorator_factory", "./utils/auto_wire"], function (require, exports, provide_decorator_factory_1, fluent_provide_decorator_factory_1, auto_wire_1) {
+define(["require", "exports", "./utils/auto_wire", "./decorator/provide", "./decorator/fluent_provide", "./factory/module_factory"], function (require, exports, auto_wire_1, provide_1, fluent_provide_1, module_factory_1) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.makeProvideDecorator = provide_decorator_factory_1.default;
-    exports.makeFluentProvideDecorator = fluent_provide_decorator_factory_1.default;
     exports.autoProvide = auto_wire_1.default;
+    exports.provide = provide_1.default;
+    exports.fluentProvide = fluent_provide_1.default;
+    exports.buildProviderModule = module_factory_1.default;
 });

amd/syntax/provide_done_syntax.js

@@ -1,2 +0,2 @@
-define(["require", "exports", "inversify", "inversify"], function (require, exports, inversify_1, inversify_2) {
+define(["require", "exports", "inversify", "inversify", "../constants"], function (require, exports, inversify_1, inversify_2, constants_1) {
     "use strict";
@@ -26,6 +26,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
                             ("multiple times in " + target.name + " ") +
-                            "Please use @done(true) if you are trying to declare multiple bindings!");
+                            "Please use done(true) if you are trying to declare multiple bindings!");
                     }
                 }
-                that._binding.implementationType = target;
+                var currentMetadata = {
+                    constraint: that._binding,
+                    implementationType: target
+                };
+                var previousMetadata = Reflect.getMetadata(constants_1.METADATA_KEY.provide, Reflect) || [];
+                var newMetadata = [currentMetadata].concat(previousMetadata);
+                Reflect.defineMetadata(constants_1.METADATA_KEY.provide, newMetadata, Reflect);
                 return target;
@@ -32,0 +38,0 @@ };

amd/syntax/provide_in_syntax.js

@@ -10,17 +10,21 @@ define(["require", "exports", "./provide_when_on_syntax", "./provide_when_syntax", "./provide_on_syntax", "./provide_done_syntax"], function (require, exports, provide_when_on_syntax_1, provide_when_syntax_1, provide_on_syntax_1, provide_done_syntax_1) {
         ProvideInSyntax.prototype.inSingletonScope = function () {
-            var bindingWhenOnSyntax = this._bindingInSyntax.inSingletonScope();
-            var provideWhenSyntax = new provide_when_syntax_1.default(bindingWhenOnSyntax, this._provideDoneSyntax);
-            var provideOnSyntax = new provide_on_syntax_1.default(bindingWhenOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingWhenOnSyntax = function (bind, target) {
+                return _this._bindingInSyntax(bind, target).inSingletonScope();
+            };
+            var inDoneSyntax = new provide_done_syntax_1.default(bindingWhenOnSyntax);
+            var provideWhenSyntax = new provide_when_syntax_1.default(bindingWhenOnSyntax, inDoneSyntax);
+            var provideOnSyntax = new provide_on_syntax_1.default(bindingWhenOnSyntax, inDoneSyntax);
             return new provide_when_on_syntax_1.default(provideWhenSyntax, provideOnSyntax);
         };
         ProvideInSyntax.prototype.inTransientScope = function () {
-            var bindingWhenOnSyntax = this._bindingInSyntax.inTransientScope();
-            var provideWhenSyntax = new provide_when_syntax_1.default(bindingWhenOnSyntax, this._provideDoneSyntax);
-            var provideOnSyntax = new provide_on_syntax_1.default(bindingWhenOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingWhenOnSyntax = function (bind, target) { return _this._bindingInSyntax(bind, target).inTransientScope(); };
+            var inDoneSyntax = new provide_done_syntax_1.default(bindingWhenOnSyntax);
+            var provideWhenSyntax = new provide_when_syntax_1.default(bindingWhenOnSyntax, inDoneSyntax);
+            var provideOnSyntax = new provide_on_syntax_1.default(bindingWhenOnSyntax, inDoneSyntax);
             return new provide_when_on_syntax_1.default(provideWhenSyntax, provideOnSyntax);
         };
         ProvideInSyntax.prototype.done = function (force) {
-            var binding = this._bindingInSyntax._binding;
-            var provideDoneSyntax = new provide_done_syntax_1.default(binding);
-            return provideDoneSyntax.done(force);
+            return this._provideDoneSyntax.done(force);
         };
@@ -27,0 +31,0 @@ return ProvideInSyntax;

amd/syntax/provide_on_syntax.js

@@ -1,2 +0,2 @@
-define(["require", "exports", "./provide_when_syntax"], function (require, exports, provide_when_syntax_1) {
+define(["require", "exports", "./provide_when_syntax", "./provide_done_syntax"], function (require, exports, provide_when_syntax_1, provide_done_syntax_1) {
     "use strict";
@@ -10,4 +10,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
         ProvideOnSyntax.prototype.onActivation = function (fn) {
-            var bindingWhenSyntax = this._bindingOnSyntax.onActivation(fn);
-            return new provide_when_syntax_1.default(bindingWhenSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingWhenSyntax = function (bind, target) { return _this._bindingOnSyntax(bind, target).onActivation(fn); };
+            var onDoneSyntax = new provide_done_syntax_1.default(bindingWhenSyntax);
+            return new provide_when_syntax_1.default(bindingWhenSyntax, onDoneSyntax);
         };
@@ -14,0 +16,0 @@ ProvideOnSyntax.prototype.done = function (force) {

amd/syntax/provide_when_syntax.js

@@ -1,2 +0,2 @@
-define(["require", "exports", "./provide_on_syntax"], function (require, exports, provide_on_syntax_1) {
+define(["require", "exports", "./provide_on_syntax", "./provide_done_syntax"], function (require, exports, provide_on_syntax_1, provide_done_syntax_1) {
     "use strict";
@@ -10,56 +10,112 @@ Object.defineProperty(exports, "__esModule", { value: true });
         ProvideWhenSyntax.prototype.when = function (constraint) {
-            var bindingOnSyntax = this._bindingWhenSyntax.when(constraint);
-            return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingOnSyntax = function (bind, target) {
+                return _this._bindingWhenSyntax(bind, target).when(constraint);
+            };
+            var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+            return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
         };
         ProvideWhenSyntax.prototype.whenTargetNamed = function (name) {
-            var bindingOnSyntax = this._bindingWhenSyntax.whenTargetNamed(name);
-            return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingOnSyntax = function (bind, target) {
+                return _this._bindingWhenSyntax(bind, target).whenTargetNamed(name);
+            };
+            var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+            return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
         };
         ProvideWhenSyntax.prototype.whenTargetTagged = function (tag, value) {
-            var bindingOnSyntax = this._bindingWhenSyntax.whenTargetTagged(tag, value);
-            return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingOnSyntax = function (bind, target) {
+                return _this._bindingWhenSyntax(bind, target).whenTargetTagged(tag, value);
+            };
+            var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+            return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
         };
         ProvideWhenSyntax.prototype.whenInjectedInto = function (parent) {
-            var bindingOnSyntax = this._bindingWhenSyntax.whenInjectedInto(parent);
-            return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingOnSyntax = function (bind, target) {
+                return _this._bindingWhenSyntax(bind, target).whenInjectedInto(parent);
+            };
+            var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+            return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
         };
         ProvideWhenSyntax.prototype.whenParentNamed = function (name) {
-            var bindingOnSyntax = this._bindingWhenSyntax.whenParentNamed(name);
-            return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingOnSyntax = function (bind, target) {
+                return _this._bindingWhenSyntax(bind, target).whenParentNamed(name);
+            };
+            var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+            return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
         };
         ProvideWhenSyntax.prototype.whenParentTagged = function (tag, value) {
-            var bindingOnSyntax = this._bindingWhenSyntax.whenParentTagged(tag, value);
-            return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingOnSyntax = function (bind, target) {
+                return _this._bindingWhenSyntax(bind, target).whenParentTagged(tag, value);
+            };
+            var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+            return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
         };
         ProvideWhenSyntax.prototype.whenAnyAncestorIs = function (ancestor) {
-            var bindingOnSyntax = this._bindingWhenSyntax.whenAnyAncestorIs(ancestor);
-            return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingOnSyntax = function (bind, target) {
+                return _this._bindingWhenSyntax(bind, target).whenAnyAncestorIs(ancestor);
+            };
+            var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+            return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
         };
         ProvideWhenSyntax.prototype.whenNoAncestorIs = function (ancestor) {
-            var bindingOnSyntax = this._bindingWhenSyntax.whenNoAncestorIs(ancestor);
-            return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingOnSyntax = function (bind, target) {
+                return _this._bindingWhenSyntax(bind, target).whenNoAncestorIs(ancestor);
+            };
+            var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+            return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
         };
         ProvideWhenSyntax.prototype.whenAnyAncestorNamed = function (name) {
-            var bindingOnSyntax = this._bindingWhenSyntax.whenAnyAncestorNamed(name);
-            return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingOnSyntax = function (bind, target) {
+                return _this._bindingWhenSyntax(bind, target).whenAnyAncestorNamed(name);
+            };
+            var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+            return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
         };
         ProvideWhenSyntax.prototype.whenAnyAncestorTagged = function (tag, value) {
-            var bindingOnSyntax = this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value);
-            return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingOnSyntax = function (bind, target) {
+                return _this._bindingWhenSyntax(bind, target).whenAnyAncestorTagged(tag, value);
+            };
+            var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+            return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
         };
         ProvideWhenSyntax.prototype.whenNoAncestorNamed = function (name) {
-            var bindingOnSyntax = this._bindingWhenSyntax.whenNoAncestorNamed(name);
-            return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingOnSyntax = function (bind, target) {
+                return _this._bindingWhenSyntax(bind, target).whenNoAncestorNamed(name);
+            };
+            var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+            return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
         };
         ProvideWhenSyntax.prototype.whenNoAncestorTagged = function (tag, value) {
-            var bindingOnSyntax = this._bindingWhenSyntax.whenNoAncestorTagged(tag, value);
-            return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingOnSyntax = function (bind, target) {
+                return _this._bindingWhenSyntax(bind, target).whenNoAncestorTagged(tag, value);
+            };
+            var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+            return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
         };
         ProvideWhenSyntax.prototype.whenAnyAncestorMatches = function (constraint) {
-            var bindingOnSyntax = this._bindingWhenSyntax.whenAnyAncestorMatches(constraint);
-            return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingOnSyntax = function (bind, target) {
+                return _this._bindingWhenSyntax(bind, target).whenAnyAncestorMatches(constraint);
+            };
+            var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+            return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
         };
         ProvideWhenSyntax.prototype.whenNoAncestorMatches = function (constraint) {
-            var bindingOnSyntax = this._bindingWhenSyntax.whenNoAncestorMatches(constraint);
-            return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+            var _this = this;
+            var bindingOnSyntax = function (bind, target) {
+                return _this._bindingWhenSyntax(bind, target).whenNoAncestorMatches(constraint);
+            };
+            var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+            return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
         };
@@ -66,0 +122,0 @@ ProvideWhenSyntax.prototype.done = function (force) {

amd/utils/auto_wire.js

@@ -1,2 +0,2 @@
-define(["require", "exports", "inversify", "../factory/provide_decorator_factory"], function (require, exports, inversify_1, provide_decorator_factory_1) {
+define(["require", "exports", "inversify", "../decorator/provide"], function (require, exports, inversify_1, provide_1) {
     "use strict";
@@ -9,7 +9,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
         }
-        var provide = provide_decorator_factory_1.default(container);
         modules.forEach(function (module) {
             Object.keys(module).forEach(function (key) {
                 var entity = module[key];
-                var decorator = provide(entity);
+                var decorator = provide_1.default(entity);
                 inversify_1.decorate(decorator, entity);
@@ -16,0 +15,0 @@ });

dts/decorator/fluent_provide.d.ts

 import interfaces from "../interfaces/interfaces";
 import { interfaces as inversifyInterfaces } from "inversify";
-declare function fluentProvide(container: inversifyInterfaces.Container): (serviceIdentifier: string | symbol | inversifyInterfaces.Newable<any> | inversifyInterfaces.Abstract<any>) => interfaces.ProvideInWhenOnSyntax<any>;
+declare function fluentProvide(serviceIdentifier: inversifyInterfaces.ServiceIdentifier<any>): interfaces.ProvideInWhenOnSyntax<any>;
 export default fluentProvide;

dts/decorator/provide.d.ts

@@ -1,3 +0,3 @@
-import { interfaces } from "inversify";
-declare function provide(container: interfaces.Container): (serviceIdentifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>, force?: boolean | undefined) => (target: any) => any;
+import { interfaces as inversifyInterfaces } from "inversify";
+declare function provide(serviceIdentifier: inversifyInterfaces.ServiceIdentifier<any>, force?: boolean): (target: any) => any;
 export default provide;

dts/index.d.ts

@@ -1,6 +0,8 @@
-import makeProvideDecorator from "./factory/provide_decorator_factory";
-import makeFluentProvideDecorator from "./factory/fluent_provide_decorator_factory";
 import autoProvide from "./utils/auto_wire";
-export { makeProvideDecorator };
-export { makeFluentProvideDecorator };
+import provide from "./decorator/provide";
+import fluentProvide from "./decorator/fluent_provide";
+import buildProviderModule from "./factory/module_factory";
+export { fluentProvide };
+export { provide };
 export { autoProvide };
+export { buildProviderModule };

dts/interfaces/interfaces.d.ts

 import { interfaces as inversifyInterfaces } from "inversify";
 declare namespace interfaces {
+    type BindConstraint = (bind: inversifyInterfaces.Bind, target: any) => any;
+    interface ProvideSyntax {
+        constraint: BindConstraint;
+        implementationType: any;
+    }
     interface ProvideDoneSyntax {
@@ -4,0 +9,0 @@ done(force?: boolean): (target: any) => any;

dts/syntax/provide_done_syntax.d.ts

 import interfaces from "../interfaces/interfaces";
-import { interfaces as inversifyInterfaces } from "inversify";
-declare class ProvideDoneSyntax<T> implements interfaces.ProvideDoneSyntax {
+declare class ProvideDoneSyntax implements interfaces.ProvideDoneSyntax {
     private _binding;
-    constructor(binding: inversifyInterfaces.Binding<T>);
+    constructor(binding: interfaces.BindConstraint);
     done(force?: boolean): (target: any) => any;
 }
 export default ProvideDoneSyntax;

dts/syntax/provide_in_syntax.d.ts

@@ -6,3 +6,3 @@ import interfaces from "../interfaces/interfaces";
     private _provideDoneSyntax;
-    constructor(bindingInSyntax: inversifyInterfaces.BindingInSyntax<T>, provideDoneSyntax: interfaces.ProvideDoneSyntax);
+    constructor(bindingInSyntax: (bind: inversifyInterfaces.Bind, target: any) => inversifyInterfaces.BindingInSyntax<T>, provideDoneSyntax: interfaces.ProvideDoneSyntax);
     inSingletonScope(): interfaces.ProvideWhenOnSyntax<T>;
@@ -9,0 +9,0 @@ inTransientScope(): interfaces.ProvideWhenOnSyntax<T>;

dts/syntax/provide_on_syntax.d.ts

@@ -6,3 +6,3 @@ import interfaces from "../interfaces/interfaces";
     private _provideDoneSyntax;
-    constructor(bindingOnSyntax: inversifyInterfaces.BindingOnSyntax<T>, provideDoneSyntax: interfaces.ProvideDoneSyntax);
+    constructor(bindingOnSyntax: (bind: inversifyInterfaces.Bind, target: any) => inversifyInterfaces.BindingOnSyntax<T>, provideDoneSyntax: interfaces.ProvideDoneSyntax);
     onActivation(fn: (context: inversifyInterfaces.Context, injectable: T) => T): interfaces.ProvideWhenSyntax<T>;
@@ -9,0 +9,0 @@ done(force?: boolean): (target: any) => any;

dts/syntax/provide_when_syntax.d.ts

@@ -6,3 +6,3 @@ import interfaces from "../interfaces/interfaces";
     private _provideDoneSyntax;
-    constructor(bindingWhenSyntax: inversifyInterfaces.BindingWhenSyntax<T>, provideDoneSyntax: interfaces.ProvideDoneSyntax);
+    constructor(bindingWhenSyntax: (bind: inversifyInterfaces.Bind, target: any) => inversifyInterfaces.BindingWhenSyntax<T>, provideDoneSyntax: interfaces.ProvideDoneSyntax);
     when(constraint: (request: inversifyInterfaces.Request) => boolean): interfaces.ProvideOnSyntax<T>;
@@ -9,0 +9,0 @@ whenTargetNamed(name: string): interfaces.ProvideOnSyntax<T>;

es/decorator/fluent_provide.js

@@ -6,12 +6,9 @@ import ProvideInWhenOnSyntax from "../syntax/provide_in_when_on_syntax";
 import ProvideDoneSyntax from "../syntax/provide_done_syntax";
-function fluentProvide(container) {
-    // function is named for testing
-    return function _fluentProvide(serviceIdentifier) {
-        var bindingWhenOnSyntax = container.bind(serviceIdentifier).to(null);
-        var binding = bindingWhenOnSyntax._binding;
-        var provideDoneSyntax = new ProvideDoneSyntax(binding);
-        var provideInWhenOnSyntax = new ProvideInWhenOnSyntax(new ProvideInSyntax(bindingWhenOnSyntax, provideDoneSyntax), new ProvideWhenSyntax(bindingWhenOnSyntax, provideDoneSyntax), new ProvideOnSyntax(bindingWhenOnSyntax, provideDoneSyntax));
-        return provideInWhenOnSyntax;
-    };
+function fluentProvide(serviceIdentifier) {
+    var bindingWhenOnSyntax = function (bind, target) { return bind(serviceIdentifier).to(target); };
+    var bindingConstraintFunction = function (bind, target) { return bindingWhenOnSyntax(bind, target)._binding; };
+    var provideDoneSyntax = new ProvideDoneSyntax(bindingConstraintFunction);
+    var provideInWhenOnSyntax = new ProvideInWhenOnSyntax(new ProvideInSyntax(function (bind, target) { return bindingWhenOnSyntax(bind, target); }, provideDoneSyntax), new ProvideWhenSyntax(bindingWhenOnSyntax, provideDoneSyntax), new ProvideOnSyntax(bindingWhenOnSyntax, provideDoneSyntax));
+    return provideInWhenOnSyntax;
 }
 export default fluentProvide;

es/decorator/provide.js

@@ -1,30 +0,33 @@
-import { decorate, injectable, METADATA_KEY } from "inversify";
-function provide(container) {
-    return function _provide(serviceIdentifier, force) {
-        var bindingWhenOnSyntax = container.bind(serviceIdentifier).to(null);
-        return function (target) {
-            var isAlreadyDecorated = Reflect.hasOwnMetadata(METADATA_KEY.PARAM_TYPES, target);
-            var redecorateWithInject = force === true;
-            if (redecorateWithInject === true && isAlreadyDecorated === false) {
+import { decorate, injectable, METADATA_KEY as inversify_METADATA_KEY } from "inversify";
+import { METADATA_KEY } from "../constants";
+function provide(serviceIdentifier, force) {
+    return function (target) {
+        var isAlreadyDecorated = Reflect.hasOwnMetadata(inversify_METADATA_KEY.PARAM_TYPES, target);
+        var redecorateWithInject = force === true;
+        if (redecorateWithInject === true && isAlreadyDecorated === false) {
+            decorate(injectable(), target);
+        }
+        else if (redecorateWithInject === true && isAlreadyDecorated === true) {
+            // Do nothing
+        }
+        else {
+            try {
                 decorate(injectable(), target);
             }
-            else if (redecorateWithInject === true && isAlreadyDecorated === true) {
-                // Do nothing
+            catch (e) {
+                throw new Error("Cannot apply @provide decorator multiple times but is has been used " +
+                    ("multiple times in " + target.name + " ") +
+                    "Please use @provide(ID, true) if you are trying to declare multiple bindings!");
             }
-            else {
-                try {
-                    decorate(injectable(), target);
-                }
-                catch (e) {
-                    throw new Error("Cannot apply @provide decorator multiple times but is has been used " +
-                        ("multiple times in " + target.name + " ") +
-                        "Please use @provide(ID, true) if you are trying to declare multiple bindings!");
-                }
-            }
-            var binding = bindingWhenOnSyntax._binding;
-            binding.implementationType = target;
-            return target;
+        }
+        var currentMetadata = {
+            constraint: function (bind, bindTarget) { return bind(serviceIdentifier).to(bindTarget); },
+            implementationType: target
         };
+        var previousMetadata = Reflect.getMetadata(METADATA_KEY.provide, Reflect) || [];
+        var newMetadata = [currentMetadata].concat(previousMetadata);
+        Reflect.defineMetadata(METADATA_KEY.provide, newMetadata, Reflect);
+        return target;
     };
 }
 export default provide;

es/index.js

@@ -1,6 +0,8 @@
-import makeProvideDecorator from "./factory/provide_decorator_factory";
-import makeFluentProvideDecorator from "./factory/fluent_provide_decorator_factory";
 import autoProvide from "./utils/auto_wire";
-export { makeProvideDecorator };
-export { makeFluentProvideDecorator };
+import provide from "./decorator/provide";
+import fluentProvide from "./decorator/fluent_provide";
+import buildProviderModule from "./factory/module_factory";
+export { fluentProvide };
+export { provide };
 export { autoProvide };
+export { buildProviderModule };

es/syntax/provide_done_syntax.js

 import { decorate, injectable } from "inversify";
-import { METADATA_KEY } from "inversify";
+import { METADATA_KEY as inversify_METADATA_KEY } from "inversify";
+import { METADATA_KEY } from "../constants";
 var ProvideDoneSyntax = /** @class */ (function () {
@@ -10,3 +11,3 @@ function ProvideDoneSyntax(binding) {
         return function (target) {
-            var isAlreadyDecorated = Reflect.hasOwnMetadata(METADATA_KEY.PARAM_TYPES, target);
+            var isAlreadyDecorated = Reflect.hasOwnMetadata(inversify_METADATA_KEY.PARAM_TYPES, target);
             var redecorateWithInject = force === true;
@@ -26,6 +27,12 @@ if (redecorateWithInject === true && isAlreadyDecorated === false) {
                         ("multiple times in " + target.name + " ") +
-                        "Please use @done(true) if you are trying to declare multiple bindings!");
+                        "Please use done(true) if you are trying to declare multiple bindings!");
                 }
             }
-            that._binding.implementationType = target;
+            var currentMetadata = {
+                constraint: that._binding,
+                implementationType: target
+            };
+            var previousMetadata = Reflect.getMetadata(METADATA_KEY.provide, Reflect) || [];
+            var newMetadata = [currentMetadata].concat(previousMetadata);
+            Reflect.defineMetadata(METADATA_KEY.provide, newMetadata, Reflect);
             return target;
@@ -32,0 +39,0 @@ };

es/syntax/provide_in_syntax.js

@@ -11,17 +11,21 @@ import ProvideWhenOnSyntax from "./provide_when_on_syntax";
     ProvideInSyntax.prototype.inSingletonScope = function () {
-        var bindingWhenOnSyntax = this._bindingInSyntax.inSingletonScope();
-        var provideWhenSyntax = new ProvideWhenSyntax(bindingWhenOnSyntax, this._provideDoneSyntax);
-        var provideOnSyntax = new ProvideOnSyntax(bindingWhenOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingWhenOnSyntax = function (bind, target) {
+            return _this._bindingInSyntax(bind, target).inSingletonScope();
+        };
+        var inDoneSyntax = new ProvideDoneSyntax(bindingWhenOnSyntax);
+        var provideWhenSyntax = new ProvideWhenSyntax(bindingWhenOnSyntax, inDoneSyntax);
+        var provideOnSyntax = new ProvideOnSyntax(bindingWhenOnSyntax, inDoneSyntax);
         return new ProvideWhenOnSyntax(provideWhenSyntax, provideOnSyntax);
     };
     ProvideInSyntax.prototype.inTransientScope = function () {
-        var bindingWhenOnSyntax = this._bindingInSyntax.inTransientScope();
-        var provideWhenSyntax = new ProvideWhenSyntax(bindingWhenOnSyntax, this._provideDoneSyntax);
-        var provideOnSyntax = new ProvideOnSyntax(bindingWhenOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingWhenOnSyntax = function (bind, target) { return _this._bindingInSyntax(bind, target).inTransientScope(); };
+        var inDoneSyntax = new ProvideDoneSyntax(bindingWhenOnSyntax);
+        var provideWhenSyntax = new ProvideWhenSyntax(bindingWhenOnSyntax, inDoneSyntax);
+        var provideOnSyntax = new ProvideOnSyntax(bindingWhenOnSyntax, inDoneSyntax);
         return new ProvideWhenOnSyntax(provideWhenSyntax, provideOnSyntax);
     };
     ProvideInSyntax.prototype.done = function (force) {
-        var binding = this._bindingInSyntax._binding;
-        var provideDoneSyntax = new ProvideDoneSyntax(binding);
-        return provideDoneSyntax.done(force);
+        return this._provideDoneSyntax.done(force);
     };
@@ -28,0 +32,0 @@ return ProvideInSyntax;

es/syntax/provide_on_syntax.js

 import ProvideWhenSyntax from "./provide_when_syntax";
+import ProvideDoneSyntax from "./provide_done_syntax";
 var ProvideOnSyntax = /** @class */ (function () {
@@ -8,4 +9,6 @@ function ProvideOnSyntax(bindingOnSyntax, provideDoneSyntax) {
     ProvideOnSyntax.prototype.onActivation = function (fn) {
-        var bindingWhenSyntax = this._bindingOnSyntax.onActivation(fn);
-        return new ProvideWhenSyntax(bindingWhenSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingWhenSyntax = function (bind, target) { return _this._bindingOnSyntax(bind, target).onActivation(fn); };
+        var onDoneSyntax = new ProvideDoneSyntax(bindingWhenSyntax);
+        return new ProvideWhenSyntax(bindingWhenSyntax, onDoneSyntax);
     };
@@ -12,0 +15,0 @@ ProvideOnSyntax.prototype.done = function (force) {

es/syntax/provide_when_syntax.js

 import ProvideOnSyntax from "./provide_on_syntax";
+import ProvideDoneSyntax from "./provide_done_syntax";
 var ProvideWhenSyntax = /** @class */ (function () {
@@ -8,56 +9,112 @@ function ProvideWhenSyntax(bindingWhenSyntax, provideDoneSyntax) {
     ProvideWhenSyntax.prototype.when = function (constraint) {
-        var bindingOnSyntax = this._bindingWhenSyntax.when(constraint);
-        return new ProvideOnSyntax(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).when(constraint);
+        };
+        var whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenTargetNamed = function (name) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenTargetNamed(name);
-        return new ProvideOnSyntax(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenTargetNamed(name);
+        };
+        var whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenTargetTagged = function (tag, value) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenTargetTagged(tag, value);
-        return new ProvideOnSyntax(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenTargetTagged(tag, value);
+        };
+        var whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenInjectedInto = function (parent) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenInjectedInto(parent);
-        return new ProvideOnSyntax(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenInjectedInto(parent);
+        };
+        var whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenParentNamed = function (name) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenParentNamed(name);
-        return new ProvideOnSyntax(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenParentNamed(name);
+        };
+        var whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenParentTagged = function (tag, value) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenParentTagged(tag, value);
-        return new ProvideOnSyntax(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenParentTagged(tag, value);
+        };
+        var whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenAnyAncestorIs = function (ancestor) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenAnyAncestorIs(ancestor);
-        return new ProvideOnSyntax(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenAnyAncestorIs(ancestor);
+        };
+        var whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenNoAncestorIs = function (ancestor) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenNoAncestorIs(ancestor);
-        return new ProvideOnSyntax(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenNoAncestorIs(ancestor);
+        };
+        var whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenAnyAncestorNamed = function (name) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenAnyAncestorNamed(name);
-        return new ProvideOnSyntax(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenAnyAncestorNamed(name);
+        };
+        var whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenAnyAncestorTagged = function (tag, value) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value);
-        return new ProvideOnSyntax(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenAnyAncestorTagged(tag, value);
+        };
+        var whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenNoAncestorNamed = function (name) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenNoAncestorNamed(name);
-        return new ProvideOnSyntax(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenNoAncestorNamed(name);
+        };
+        var whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenNoAncestorTagged = function (tag, value) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenNoAncestorTagged(tag, value);
-        return new ProvideOnSyntax(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenNoAncestorTagged(tag, value);
+        };
+        var whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenAnyAncestorMatches = function (constraint) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenAnyAncestorMatches(constraint);
-        return new ProvideOnSyntax(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenAnyAncestorMatches(constraint);
+        };
+        var whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenNoAncestorMatches = function (constraint) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenNoAncestorMatches(constraint);
-        return new ProvideOnSyntax(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenNoAncestorMatches(constraint);
+        };
+        var whenDoneSyntax = new ProvideDoneSyntax(bindingOnSyntax);
+        return new ProvideOnSyntax(bindingOnSyntax, whenDoneSyntax);
     };
@@ -64,0 +121,0 @@ ProvideWhenSyntax.prototype.done = function (force) {

es/utils/auto_wire.js

 import { decorate } from "inversify";
-import makeProvideDecorator from "../factory/provide_decorator_factory";
+import provide from "../decorator/provide";
 function autoProvide(container) {
@@ -8,3 +8,2 @@ var modules = [];
     }
-    var provide = makeProvideDecorator(container);
     modules.forEach(function (module) {
@@ -11,0 +10,0 @@ Object.keys(module).forEach(function (key) {

lib/decorator/fluent_provide.js

@@ -8,12 +8,9 @@ "use strict";
 var provide_done_syntax_1 = require("../syntax/provide_done_syntax");
-function fluentProvide(container) {
-    // function is named for testing
-    return function _fluentProvide(serviceIdentifier) {
-        var bindingWhenOnSyntax = container.bind(serviceIdentifier).to(null);
-        var binding = bindingWhenOnSyntax._binding;
-        var provideDoneSyntax = new provide_done_syntax_1.default(binding);
-        var provideInWhenOnSyntax = new provide_in_when_on_syntax_1.default(new provide_in_syntax_1.default(bindingWhenOnSyntax, provideDoneSyntax), new provide_when_syntax_1.default(bindingWhenOnSyntax, provideDoneSyntax), new provide_on_syntax_1.default(bindingWhenOnSyntax, provideDoneSyntax));
-        return provideInWhenOnSyntax;
-    };
+function fluentProvide(serviceIdentifier) {
+    var bindingWhenOnSyntax = function (bind, target) { return bind(serviceIdentifier).to(target); };
+    var bindingConstraintFunction = function (bind, target) { return bindingWhenOnSyntax(bind, target)._binding; };
+    var provideDoneSyntax = new provide_done_syntax_1.default(bindingConstraintFunction);
+    var provideInWhenOnSyntax = new provide_in_when_on_syntax_1.default(new provide_in_syntax_1.default(function (bind, target) { return bindingWhenOnSyntax(bind, target); }, provideDoneSyntax), new provide_when_syntax_1.default(bindingWhenOnSyntax, provideDoneSyntax), new provide_on_syntax_1.default(bindingWhenOnSyntax, provideDoneSyntax));
+    return provideInWhenOnSyntax;
 }
 exports.default = fluentProvide;

lib/decorator/provide.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var inversify_1 = require("inversify");
-function provide(container) {
-    return function _provide(serviceIdentifier, force) {
-        var bindingWhenOnSyntax = container.bind(serviceIdentifier).to(null);
-        return function (target) {
-            var isAlreadyDecorated = Reflect.hasOwnMetadata(inversify_1.METADATA_KEY.PARAM_TYPES, target);
-            var redecorateWithInject = force === true;
-            if (redecorateWithInject === true && isAlreadyDecorated === false) {
+var constants_1 = require("../constants");
+function provide(serviceIdentifier, force) {
+    return function (target) {
+        var isAlreadyDecorated = Reflect.hasOwnMetadata(inversify_1.METADATA_KEY.PARAM_TYPES, target);
+        var redecorateWithInject = force === true;
+        if (redecorateWithInject === true && isAlreadyDecorated === false) {
+            inversify_1.decorate(inversify_1.injectable(), target);
+        }
+        else if (redecorateWithInject === true && isAlreadyDecorated === true) {
+            // Do nothing
+        }
+        else {
+            try {
                 inversify_1.decorate(inversify_1.injectable(), target);
             }
-            else if (redecorateWithInject === true && isAlreadyDecorated === true) {
-                // Do nothing
+            catch (e) {
+                throw new Error("Cannot apply @provide decorator multiple times but is has been used " +
+                    ("multiple times in " + target.name + " ") +
+                    "Please use @provide(ID, true) if you are trying to declare multiple bindings!");
             }
-            else {
-                try {
-                    inversify_1.decorate(inversify_1.injectable(), target);
-                }
-                catch (e) {
-                    throw new Error("Cannot apply @provide decorator multiple times but is has been used " +
-                        ("multiple times in " + target.name + " ") +
-                        "Please use @provide(ID, true) if you are trying to declare multiple bindings!");
-                }
-            }
-            var binding = bindingWhenOnSyntax._binding;
-            binding.implementationType = target;
-            return target;
+        }
+        var currentMetadata = {
+            constraint: function (bind, bindTarget) { return bind(serviceIdentifier).to(bindTarget); },
+            implementationType: target
         };
+        var previousMetadata = Reflect.getMetadata(constants_1.METADATA_KEY.provide, Reflect) || [];
+        var newMetadata = [currentMetadata].concat(previousMetadata);
+        Reflect.defineMetadata(constants_1.METADATA_KEY.provide, newMetadata, Reflect);
+        return target;
     };
 }
 exports.default = provide;

lib/index.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var provide_decorator_factory_1 = require("./factory/provide_decorator_factory");
-exports.makeProvideDecorator = provide_decorator_factory_1.default;
-var fluent_provide_decorator_factory_1 = require("./factory/fluent_provide_decorator_factory");
-exports.makeFluentProvideDecorator = fluent_provide_decorator_factory_1.default;
 var auto_wire_1 = require("./utils/auto_wire");
 exports.autoProvide = auto_wire_1.default;
+var provide_1 = require("./decorator/provide");
+exports.provide = provide_1.default;
+var fluent_provide_1 = require("./decorator/fluent_provide");
+exports.fluentProvide = fluent_provide_1.default;
+var module_factory_1 = require("./factory/module_factory");
+exports.buildProviderModule = module_factory_1.default;

lib/syntax/provide_done_syntax.js

@@ -5,2 +5,3 @@ "use strict";
 var inversify_2 = require("inversify");
+var constants_1 = require("../constants");
 var ProvideDoneSyntax = /** @class */ (function () {
@@ -28,6 +29,12 @@ function ProvideDoneSyntax(binding) {
                         ("multiple times in " + target.name + " ") +
-                        "Please use @done(true) if you are trying to declare multiple bindings!");
+                        "Please use done(true) if you are trying to declare multiple bindings!");
                 }
             }
-            that._binding.implementationType = target;
+            var currentMetadata = {
+                constraint: that._binding,
+                implementationType: target
+            };
+            var previousMetadata = Reflect.getMetadata(constants_1.METADATA_KEY.provide, Reflect) || [];
+            var newMetadata = [currentMetadata].concat(previousMetadata);
+            Reflect.defineMetadata(constants_1.METADATA_KEY.provide, newMetadata, Reflect);
             return target;
@@ -34,0 +41,0 @@ };

lib/syntax/provide_in_syntax.js

@@ -13,17 +13,21 @@ "use strict";
     ProvideInSyntax.prototype.inSingletonScope = function () {
-        var bindingWhenOnSyntax = this._bindingInSyntax.inSingletonScope();
-        var provideWhenSyntax = new provide_when_syntax_1.default(bindingWhenOnSyntax, this._provideDoneSyntax);
-        var provideOnSyntax = new provide_on_syntax_1.default(bindingWhenOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingWhenOnSyntax = function (bind, target) {
+            return _this._bindingInSyntax(bind, target).inSingletonScope();
+        };
+        var inDoneSyntax = new provide_done_syntax_1.default(bindingWhenOnSyntax);
+        var provideWhenSyntax = new provide_when_syntax_1.default(bindingWhenOnSyntax, inDoneSyntax);
+        var provideOnSyntax = new provide_on_syntax_1.default(bindingWhenOnSyntax, inDoneSyntax);
         return new provide_when_on_syntax_1.default(provideWhenSyntax, provideOnSyntax);
     };
     ProvideInSyntax.prototype.inTransientScope = function () {
-        var bindingWhenOnSyntax = this._bindingInSyntax.inTransientScope();
-        var provideWhenSyntax = new provide_when_syntax_1.default(bindingWhenOnSyntax, this._provideDoneSyntax);
-        var provideOnSyntax = new provide_on_syntax_1.default(bindingWhenOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingWhenOnSyntax = function (bind, target) { return _this._bindingInSyntax(bind, target).inTransientScope(); };
+        var inDoneSyntax = new provide_done_syntax_1.default(bindingWhenOnSyntax);
+        var provideWhenSyntax = new provide_when_syntax_1.default(bindingWhenOnSyntax, inDoneSyntax);
+        var provideOnSyntax = new provide_on_syntax_1.default(bindingWhenOnSyntax, inDoneSyntax);
         return new provide_when_on_syntax_1.default(provideWhenSyntax, provideOnSyntax);
     };
     ProvideInSyntax.prototype.done = function (force) {
-        var binding = this._bindingInSyntax._binding;
-        var provideDoneSyntax = new provide_done_syntax_1.default(binding);
-        return provideDoneSyntax.done(force);
+        return this._provideDoneSyntax.done(force);
     };
@@ -30,0 +34,0 @@ return ProvideInSyntax;

lib/syntax/provide_on_syntax.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var provide_when_syntax_1 = require("./provide_when_syntax");
+var provide_done_syntax_1 = require("./provide_done_syntax");
 var ProvideOnSyntax = /** @class */ (function () {
@@ -10,4 +11,6 @@ function ProvideOnSyntax(bindingOnSyntax, provideDoneSyntax) {
     ProvideOnSyntax.prototype.onActivation = function (fn) {
-        var bindingWhenSyntax = this._bindingOnSyntax.onActivation(fn);
-        return new provide_when_syntax_1.default(bindingWhenSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingWhenSyntax = function (bind, target) { return _this._bindingOnSyntax(bind, target).onActivation(fn); };
+        var onDoneSyntax = new provide_done_syntax_1.default(bindingWhenSyntax);
+        return new provide_when_syntax_1.default(bindingWhenSyntax, onDoneSyntax);
     };
@@ -14,0 +17,0 @@ ProvideOnSyntax.prototype.done = function (force) {

lib/syntax/provide_when_syntax.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var provide_on_syntax_1 = require("./provide_on_syntax");
+var provide_done_syntax_1 = require("./provide_done_syntax");
 var ProvideWhenSyntax = /** @class */ (function () {
@@ -10,56 +11,112 @@ function ProvideWhenSyntax(bindingWhenSyntax, provideDoneSyntax) {
     ProvideWhenSyntax.prototype.when = function (constraint) {
-        var bindingOnSyntax = this._bindingWhenSyntax.when(constraint);
-        return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).when(constraint);
+        };
+        var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenTargetNamed = function (name) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenTargetNamed(name);
-        return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenTargetNamed(name);
+        };
+        var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenTargetTagged = function (tag, value) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenTargetTagged(tag, value);
-        return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenTargetTagged(tag, value);
+        };
+        var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenInjectedInto = function (parent) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenInjectedInto(parent);
-        return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenInjectedInto(parent);
+        };
+        var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenParentNamed = function (name) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenParentNamed(name);
-        return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenParentNamed(name);
+        };
+        var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenParentTagged = function (tag, value) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenParentTagged(tag, value);
-        return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenParentTagged(tag, value);
+        };
+        var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenAnyAncestorIs = function (ancestor) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenAnyAncestorIs(ancestor);
-        return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenAnyAncestorIs(ancestor);
+        };
+        var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenNoAncestorIs = function (ancestor) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenNoAncestorIs(ancestor);
-        return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenNoAncestorIs(ancestor);
+        };
+        var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenAnyAncestorNamed = function (name) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenAnyAncestorNamed(name);
-        return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenAnyAncestorNamed(name);
+        };
+        var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenAnyAncestorTagged = function (tag, value) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenAnyAncestorTagged(tag, value);
-        return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenAnyAncestorTagged(tag, value);
+        };
+        var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenNoAncestorNamed = function (name) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenNoAncestorNamed(name);
-        return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenNoAncestorNamed(name);
+        };
+        var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenNoAncestorTagged = function (tag, value) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenNoAncestorTagged(tag, value);
-        return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenNoAncestorTagged(tag, value);
+        };
+        var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenAnyAncestorMatches = function (constraint) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenAnyAncestorMatches(constraint);
-        return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenAnyAncestorMatches(constraint);
+        };
+        var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
     };
     ProvideWhenSyntax.prototype.whenNoAncestorMatches = function (constraint) {
-        var bindingOnSyntax = this._bindingWhenSyntax.whenNoAncestorMatches(constraint);
-        return new provide_on_syntax_1.default(bindingOnSyntax, this._provideDoneSyntax);
+        var _this = this;
+        var bindingOnSyntax = function (bind, target) {
+            return _this._bindingWhenSyntax(bind, target).whenNoAncestorMatches(constraint);
+        };
+        var whenDoneSyntax = new provide_done_syntax_1.default(bindingOnSyntax);
+        return new provide_on_syntax_1.default(bindingOnSyntax, whenDoneSyntax);
     };
@@ -66,0 +123,0 @@ ProvideWhenSyntax.prototype.done = function (force) {

lib/utils/auto_wire.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var inversify_1 = require("inversify");
-var provide_decorator_factory_1 = require("../factory/provide_decorator_factory");
+var provide_1 = require("../decorator/provide");
 function autoProvide(container) {
@@ -10,7 +10,6 @@ var modules = [];
     }
-    var provide = provide_decorator_factory_1.default(container);
     modules.forEach(function (module) {
         Object.keys(module).forEach(function (key) {
             var entity = module[key];
-            var decorator = provide(entity);
+            var decorator = provide_1.default(entity);
             inversify_1.decorate(decorator, entity);
@@ -17,0 +16,0 @@ });

package.json

 {
   "name": "inversify-binding-decorators",
-  "version": "3.2.0",
+  "version": "4.0.0",
   "description": "An utility that allows developers to declare InversifyJS bindings using ES2016 decorators",
@@ -28,20 +28,20 @@ "main": "lib/index.js",
   "devDependencies": {
-    "@types/chai": "4.0.8",
-    "@types/mocha": "2.2.44",
-    "@types/sinon": "4.0.0",
+    "@types/chai": "4.1.2",
+    "@types/mocha": "5.1.0",
+    "@types/sinon": "4.3.1",
     "chai": "4.1.2",
     "gulp": "3.9.1",
-    "gulp-istanbul": "1.1.2",
-    "gulp-tslint": "8.1.2",
-    "gulp-mocha": "3.0.1",
-    "gulp-typescript": "3.2.3",
-    "inversify": "4.6.0",
-    "mocha": "4.0.1",
-    "publish-please": "2.3.1",
-    "reflect-metadata": "0.1.10",
-    "run-sequence": "2.2.0",
-    "sinon": "4.1.2",
-    "tslint": "5.8.0",
+    "gulp-istanbul": "1.1.3",
+    "gulp-mocha": "5.0.0",
+    "gulp-tslint": "8.1.3",
+    "gulp-typescript": "4.0.2",
+    "inversify": "4.13.0",
+    "mocha": "5.1.1",
+    "publish-please": "2.4.0",
+    "reflect-metadata": "0.1.12",
+    "run-sequence": "2.2.1",
+    "sinon": "5.0.0",
+    "tslint": "5.9.1",
     "typescript": "2.6.2"
   }
 }

README.md

@@ -59,8 +59,5 @@ # inversify-binding-decorators
 import { injectable, Container } from "inversify";
-import { makeProvideDecorator } from "inversify-binding-decorators";
+import { provide, buildProviderModule } from "inversify-binding-decorators";
 import "reflect-metadata";
 
-var container = new Container();
-let provide = makeProvideDecorator(container);
-
 @provide(Katana)
@@ -80,2 +77,6 @@ class Katana implements Weapon {
 
+var container = new Container();
+// Reflects all decorators provided by this package and packages them into 
+// a module to be loaded by the container
+container.load(buildProviderModule());
 
@@ -211,12 +212,6 @@ ```
 
-The decorator returned by `makeProvideDecorator` is not fluent and is very limited 
-when compared to `makeFluentProvideDecorator`:
-
 ```ts
 import { injectable, Container } from "inversify";
-import { makeFluentProvideDecorator } from "inversify-binding-decorators";
+import { fluentProvide, buildProviderModule } from "inversify-binding-decorators";
 
-var container = new Container();
-let provide = makeFluentProvideDecorator(container);
-
 let TYPE = {
@@ -227,3 +222,3 @@ Weapon : "Weapon",
 
-@provide(TYPE.Weapon).whenTargetTagged("throwable", true).done();
+@fluentProvide(TYPE.Weapon).whenTargetTagged("throwable", true).done();
 class Katana implements Weapon {
@@ -235,3 +230,3 @@ public hit() {
 
-@provide(TYPE.Weapon).whenTargetTagged("throwable", false).done();
+@fluentProvide(TYPE.Weapon).whenTargetTagged("throwable", false).done();
 class Shuriken implements Weapon {
@@ -243,3 +238,3 @@ public hit() {
 
-@provide(TYPE.Ninja)
+@fluentProvide(TYPE.Ninja).done();
 class Ninja implements Ninja {
@@ -262,2 +257,5 @@
 }
+
+var container = new Container();
+container.load(buildProviderModule());
 ```
@@ -330,3 +328,3 @@
 
-> Cannot apply @provideFluent decorator multiple times but is has been used multiple times in Ninja Please use @done(true) if you are trying to declare multiple bindings!
+> Cannot apply @provideFluent decorator multiple times but is has been used multiple times in Ninja Please use done(true) if you are trying to declare multiple bindings!
 
@@ -338,4 +336,2 @@ We throw an exception to ensure that you are are not trying to apply `@fluentProvide` multiple times by mistake.
 ```ts
-let container = new Container();
-let provideFluent = fluentProvide(container);
 
@@ -354,2 +350,4 @@ const provideSingleton = (identifier: any) => {
 }
+let container = new Container();
+container.load(buildProviderModule());
 ```
@@ -356,0 +354,0 @@

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

91875

increased by12.51%

Lines of code

1491

increased by18.52%

Worsened metrics

Number of package files

56

decreased by-1.75%

Number of lines in readme file

445

decreased by-0.45%

No dependency changes