Merge pull request #34 from remojansen/master

Libs upgrade and AMD support
inversify · Dec 6, 2016 · c6e98b4 · c6e98b4
2 parents ae1b26d + 5b42480
commit c6e98b4
Show file tree

Hide file tree

Showing 21 changed files with 113 additions and 66 deletions.
diff --git a/.gitignore b/.gitignore
@@ -38,6 +38,7 @@ typings
 dist
 lib
 es
+amd
 
 type_definitions/inversify/*.js
 

diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -7,6 +7,7 @@
 		"test/**/*.js": true,
         "**/es": true,
         "**/lib": true,
+        "**/amd": true,
         "**/dts": true,
         "**/coverage": true,
         "**/dist": true,

diff --git a/gulpfile.js b/gulpfile.js
@@ -46,6 +46,22 @@ gulp.task("build-lib", function() {
         .js.pipe(gulp.dest("lib/"));
 });
 
+var tsAmdProject = tsc.createProject("tsconfig.json", {
+    module: "amd"
+});
+
+gulp.task("build-amd", function() {
+    return gulp.src([
+            "src/**/*.ts"
+        ])
+        .pipe(tsAmdProject())
+        .on("error", function(err) {
+            process.exit(1);
+        })
+        .js.pipe(gulp.dest("amd/"));
+});
+
+
 var tsEsProject = tsc.createProject("tsconfig.json", {
     module: "es2015"
 });
@@ -132,7 +148,7 @@ gulp.task("test", function(cb) {
 
 gulp.task("build", function(cb) {
     runSequence(
-        "lint", ["build-src", "build-es", "build-lib", "build-dts"], // tests + build es and lib
+        "lint", ["build-src", "build-es", "build-lib", "build-amd", "build-dts"], // tests + build es and lib
         "build-test",
         cb);
 });

diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "inversify-binding-decorators",
-  "version": "2.0.0",
+  "version": "3.0.0-beta.1",
   "description": "An utility that allows developers to declare InversifyJS bindings using ES2016 decorators",
   "main": "lib/index.js",
   "jsnext:main": "es/index.js",
@@ -32,15 +32,15 @@
     "gulp": "^3.9.1",
     "gulp-istanbul": "^1.0.0",
     "gulp-mocha": "^3.0.0",
-    "gulp-tslint": "^6.1.2",
+    "gulp-tslint": "^7.0.0",
     "gulp-typescript": "^3.0.0",
-    "inversify": "^3.0.0-beta.1",
+    "inversify": "^3.0.0-rc.1",
     "mocha": "^3.0.0",
     "publish-please": "^2.1.4",
     "reflect-metadata": "^0.1.3",
     "run-sequence": "^1.2.0",
     "sinon": "^1.17.4",
-    "tslint": "^3.12.0",
+    "tslint": "^4.0.1",
     "typescript": "^2.1.1"
   }
 }
diff --git a/src/decorator/fluent_provide.ts b/src/decorator/fluent_provide.ts
@@ -11,7 +11,7 @@ function fluentProvide(container: inversifyInterfaces.Container) {
   // function is named for testing
   return function _fluentProvide(serviceIdentifier: inversifyInterfaces.ServiceIdentifier<any>) {
 
-    let bindingWhenOnSyntax = container.bind<any>(serviceIdentifier).to(null);
+    let bindingWhenOnSyntax = container.bind<any>(serviceIdentifier).to(<any>null);
     let binding = (<any>bindingWhenOnSyntax)._binding;
     let provideDoneSyntax = new ProvideDoneSyntax(binding);
 

diff --git a/src/decorator/provide.ts b/src/decorator/provide.ts
@@ -5,7 +5,7 @@ function provide(container: interfaces.Container) {
 
   // function is named for testing
   return function _provide(serviceIdentifier: interfaces.ServiceIdentifier<any>) {
-    let bindingWhenOnSyntax = container.bind<any>(serviceIdentifier).to(null);
+    let bindingWhenOnSyntax = container.bind<any>(serviceIdentifier).to(<any>null);
     return function (target: any) {
       decorate(injectable(), target);
       let binding: interfaces.Binding<any> = (<any>bindingWhenOnSyntax)._binding;

diff --git a/src/factory/fluent_provide_decorator_factory.ts b/src/factory/fluent_provide_decorator_factory.ts
@@ -2,9 +2,10 @@ import fluentProvide from "../decorator/fluent_provide";
 import interfaces from "../interfaces/interfaces";
 import { interfaces as inversifyInterfaces } from "inversify";
 
-function makeFluentProvideDecorator(container: inversifyInterfaces.Container) {
-    let result: (serviceIdentifier: inversifyInterfaces.ServiceIdentifier<any>) => interfaces.ProvideInWhenOnSyntax<any> = null;
-    result = fluentProvide(container);
+function makeFluentProvideDecorator(
+    container: inversifyInterfaces.Container
+): (serviceIdentifier: inversifyInterfaces.ServiceIdentifier<any>) => interfaces.ProvideInWhenOnSyntax<any> {
+    let result = fluentProvide(container);
     return result;
 }
 

diff --git a/src/interfaces/interfaces.ts b/src/interfaces/interfaces.ts
@@ -2,22 +2,22 @@ import { interfaces as inversifyInterfaces } from "inversify";
 
 namespace interfaces {
 
-    export interface ProvideInSyntax<T> extends ProvideDoneSyntax<T> {
-        inSingletonScope(): ProvideWhenOnSyntax<T>;
-        inTransientScope(): ProvideWhenOnSyntax<T>;
+    export interface ProvideDoneSyntax {
+        done(): (target: any) => any;
     }
 
-    export interface ProvideDoneSyntax<T> {
-        done(): (target: any) => any;
+    export interface ProvideInSyntax<T> extends ProvideDoneSyntax {
+        inSingletonScope(): ProvideWhenOnSyntax<T>;
+        inTransientScope(): ProvideWhenOnSyntax<T>;
     }
 
     export interface ProvideInWhenOnSyntax<T> extends ProvideInSyntax<T>, ProvideWhenSyntax<T>, ProvideOnSyntax<T> {}
 
-    export interface ProvideOnSyntax<T> extends ProvideDoneSyntax<T> {
+    export interface ProvideOnSyntax<T> extends ProvideDoneSyntax {
         onActivation(fn: (context: inversifyInterfaces.Context, injectable: T) => T): ProvideWhenSyntax<T>;
     }
 
-    export interface ProvideWhenSyntax<T> extends ProvideDoneSyntax<T> {
+    export interface ProvideWhenSyntax<T> extends ProvideDoneSyntax {
         when(constraint: (request: inversifyInterfaces.Request) => boolean): ProvideOnSyntax<T>;
         whenTargetNamed(name: string): ProvideOnSyntax<T>;
         whenTargetTagged(tag: string, value: any): ProvideOnSyntax<T>;

diff --git a/src/syntax/provide_done_syntax.ts b/src/syntax/provide_done_syntax.ts
@@ -2,7 +2,7 @@ import interfaces from "../interfaces/interfaces";
 import { decorate, injectable } from "inversify";
 import { interfaces as inversifyInterfaces } from "inversify";
 
-class ProvideDoneSyntax<T> implements interfaces.ProvideDoneSyntax<T> {
+class ProvideDoneSyntax<T> implements interfaces.ProvideDoneSyntax {
 
     private _binding: inversifyInterfaces.Binding<T>;
 

diff --git a/src/syntax/provide_in_syntax.ts b/src/syntax/provide_in_syntax.ts
@@ -8,11 +8,11 @@ import { interfaces as inversifyInterfaces } from "inversify";
 class ProvideInSyntax<T> implements interfaces.ProvideInSyntax<T> {
 
     private _bindingInSyntax: inversifyInterfaces.BindingInSyntax<T>;
-    private _provideDoneSyntax: interfaces.ProvideDoneSyntax<T>;
+    private _provideDoneSyntax: interfaces.ProvideDoneSyntax;
 
     public constructor(
         bindingInSyntax: inversifyInterfaces.BindingInSyntax<T>,
-        provideDoneSyntax: interfaces.ProvideDoneSyntax<T>
+        provideDoneSyntax: interfaces.ProvideDoneSyntax
     ) {
         this._bindingInSyntax = bindingInSyntax;
         this._provideDoneSyntax = provideDoneSyntax;

diff --git a/src/syntax/provide_on_syntax.ts b/src/syntax/provide_on_syntax.ts
@@ -5,11 +5,11 @@ import { interfaces as inversifyInterfaces } from "inversify";
 class ProvideOnSyntax<T> implements interfaces.ProvideOnSyntax<T> {
 
     private _bindingOnSyntax: inversifyInterfaces.BindingOnSyntax<T>;
-    private _provideDoneSyntax: interfaces.ProvideDoneSyntax<T>;
+    private _provideDoneSyntax: interfaces.ProvideDoneSyntax;
 
     public constructor(
         bindingOnSyntax: inversifyInterfaces.BindingOnSyntax<T>,
-        provideDoneSyntax: interfaces.ProvideDoneSyntax<T>
+        provideDoneSyntax: interfaces.ProvideDoneSyntax
     ) {
         this._bindingOnSyntax = bindingOnSyntax;
         this._provideDoneSyntax = provideDoneSyntax;

diff --git a/src/syntax/provide_when_syntax.ts b/src/syntax/provide_when_syntax.ts
@@ -5,11 +5,11 @@ import { interfaces as inversifyInterfaces } from "inversify";
 class ProvideWhenSyntax<T> implements interfaces.ProvideWhenSyntax<T> {
 
     private _bindingWhenSyntax: inversifyInterfaces.BindingWhenSyntax<T>;
-    private _provideDoneSyntax: interfaces.ProvideDoneSyntax<T>;
+    private _provideDoneSyntax: interfaces.ProvideDoneSyntax;
 
     public constructor(
         bindingWhenSyntax: inversifyInterfaces.BindingWhenSyntax<T>,
-        provideDoneSyntax: interfaces.ProvideDoneSyntax<T>
+        provideDoneSyntax: interfaces.ProvideDoneSyntax
     ) {
         this._bindingWhenSyntax = bindingWhenSyntax;
         this._provideDoneSyntax = provideDoneSyntax;

diff --git a/test/index.test.ts b/test/index.test.ts
@@ -11,6 +11,8 @@ describe("inversify-binding-decorators", () => {
         let provide = makeProvideDecorator(container);
 
         interface Warrior {
+            katana: Weapon;
+            shuriken: ThrowableWeapon;
             fight(): string;
             sneak(): string;
         }
@@ -46,23 +48,27 @@ describe("inversify-binding-decorators", () => {
         @provide(TYPE.Warrior)
         class Ninja implements Warrior {
 
-            private _katana: Weapon;
-            private _shuriken: ThrowableWeapon;
+            public katana: Weapon;
+            public shuriken: ThrowableWeapon;
 
             public constructor(
                 @inject(TYPE.Weapon) katana: Weapon,
                 @inject(TYPE.ThrowableWeapon) shuriken: ThrowableWeapon
             ) {
-                this._katana = katana;
-                this._shuriken = shuriken;
+                this.katana = katana;
+                this.shuriken = shuriken;
             }
 
-            public fight() { return this._katana.hit(); };
-            public sneak() { return this._shuriken.throw(); };
+            public fight() { return this.katana.hit(); };
+            public sneak() { return this.shuriken.throw(); };
 
         }
 
         let ninja = container.get<Warrior>(TYPE.Warrior);
+
+        expect(ninja instanceof Ninja).eql(true);
+        expect(ninja.katana instanceof Katana).eql(true);
+        expect(ninja.shuriken instanceof Shuriken).eql(true);
         expect(ninja.fight()).eql("cut!");
         expect(ninja.sneak()).eql("hit!");
 
@@ -90,23 +96,27 @@ describe("inversify-binding-decorators", () => {
         @provide(Ninja)
         class Ninja {
 
-            private _katana: Katana;
-            private _shuriken: Shuriken;
+            public katana: Katana;
+            public shuriken: Shuriken;
 
             public constructor(
                 katana: Katana,
                 shuriken: Shuriken
             ) {
-                this._katana = katana;
-                this._shuriken = shuriken;
+                this.katana = katana;
+                this.shuriken = shuriken;
             }
 
-            public fight() { return this._katana.hit(); };
-            public sneak() { return this._shuriken.throw(); };
+            public fight() { return this.katana.hit(); };
+            public sneak() { return this.shuriken.throw(); };
 
         }
 
         let ninja = container.get<Ninja>(Ninja);
+
+        expect(ninja instanceof Ninja).eql(true);
+        expect(ninja.katana instanceof Katana).eql(true);
+        expect(ninja.shuriken instanceof Shuriken).eql(true);
         expect(ninja.fight()).eql("cut!");
         expect(ninja.sneak()).eql("hit!");
 
@@ -118,6 +128,8 @@ describe("inversify-binding-decorators", () => {
         let provide = makeProvideDecorator(container);
 
         interface Warrior {
+            katana: Katana;
+            shuriken: Shuriken;
             fight(): string;
             sneak(): string;
         }
@@ -153,23 +165,27 @@ describe("inversify-binding-decorators", () => {
         @provide(TYPE.Warrior)
         class Ninja implements Warrior {
 
-            private _katana: Weapon;
-            private _shuriken: ThrowableWeapon;
+            public katana: Weapon;
+            public shuriken: ThrowableWeapon;
 
             public constructor(
                 @inject(TYPE.Weapon) katana: Weapon,
                 @inject(TYPE.ThrowableWeapon) shuriken: ThrowableWeapon
             ) {
-                this._katana = katana;
-                this._shuriken = shuriken;
+                this.katana = katana;
+                this.shuriken = shuriken;
             }
 
-            public fight() { return this._katana.hit(); };
-            public sneak() { return this._shuriken.throw(); };
+            public fight() { return this.katana.hit(); };
+            public sneak() { return this.shuriken.throw(); };
 
         }
 
         let ninja = container.get<Warrior>(TYPE.Warrior);
+
+        expect(ninja instanceof Ninja).eql(true);
+        expect(ninja.katana instanceof Katana).eql(true);
+        expect(ninja.shuriken instanceof Shuriken).eql(true);
         expect(ninja.fight()).eql("cut!");
         expect(ninja.sneak()).eql("hit!");
 
@@ -189,6 +205,8 @@ describe("inversify-binding-decorators", () => {
         };
 
         interface Warrior {
+            katana: Weapon;
+            shuriken: ThrowableWeapon;
             fight(): string;
             sneak(): string;
         }
@@ -232,23 +250,27 @@ describe("inversify-binding-decorators", () => {
         @provideTransient(TYPE.Warrior)
         class Ninja implements Warrior {
 
-            private _katana: Weapon;
-            private _shuriken: ThrowableWeapon;
+            public katana: Weapon;
+            public shuriken: ThrowableWeapon;
 
             public constructor(
                 @inject(TYPE.Weapon) katana: Weapon,
                 @inject(TYPE.ThrowableWeapon) shuriken: ThrowableWeapon
             ) {
-                this._katana = katana;
-                this._shuriken = shuriken;
+                this.katana = katana;
+                this.shuriken = shuriken;
             }
 
-            public fight() { return this._katana.hit(); };
-            public sneak() { return this._shuriken.throw(); };
+            public fight() { return this.katana.hit(); };
+            public sneak() { return this.shuriken.throw(); };
 
         }
 
         let ninja = container.get<Warrior>(TYPE.Warrior);
+        expect(ninja instanceof Ninja).eql(true);
+        expect(ninja.katana instanceof Katana).eql(true);
+        expect(ninja.shuriken instanceof Shuriken).eql(true);
+
         expect(ninja.fight().indexOf("cut!")).eql(0);
         expect(ninja.sneak().indexOf("hit!")).eql(0);
 
@@ -268,6 +290,8 @@ describe("inversify-binding-decorators", () => {
         };
 
         interface Warrior {
+            primary: Weapon;
+            secondary: Weapon;
             fight(): string;
             sneak(): string;
         }
@@ -298,23 +322,27 @@ describe("inversify-binding-decorators", () => {
         @provide(TYPE.Warrior).done()
         class Ninja implements Warrior {
 
-            private _primary: Weapon;
-            private _secondary: Weapon;
+            public primary: Weapon;
+            public secondary: Weapon;
 
             public constructor(
                 @inject(TYPE.Weapon) @tagged("throwable", false) primary: Weapon,
                 @inject(TYPE.Weapon) @tagged("throwable", true) secondary: Weapon
             ) {
-                this._primary = primary;
-                this._secondary = secondary;
+                this.primary = primary;
+                this.secondary = secondary;
             }
 
-            public fight() { return this._primary.hit(); };
-            public sneak() { return this._secondary.hit(); };
+            public fight() { return this.primary.hit(); };
+            public sneak() { return this.secondary.hit(); };
 
         }
 
         let ninja = container.get<Warrior>(TYPE.Warrior);
+
+        expect(ninja instanceof Ninja).eql(true);
+        expect(ninja.primary instanceof Katana).eql(true);
+        expect(ninja.secondary instanceof Shuriken).eql(true);
         expect(ninja.fight()).eql("Hit by Katana!");
         expect(ninja.sneak()).eql("Hit by Shuriken!");