fix(bindAll): fix constructor not being called with new

BREAKING CHANGE: Properties will use the bind decorator to apply getter/setters
on the prototype instead of the instance. This could cause
issues with consumers currently using the implementain that
assigns the bound properties to the instance through the constructor
rather than on the prototype. The value on the prototype will now be
a getter instead of the original function value.

src/bindAll.spec.ts

@@ -96,7 +96,7 @@ describe('bindAll', () => {
 
     const myClass = new MyClass();
 
-    expect(myClass.hasOwnProperty('fn')).to.be.true;
+    expect(accessed).to.be.false;
     expect(myClass.hasOwnProperty('prop')).to.be.false;
     expect(myClass.hasOwnProperty('prop2')).to.be.false;
   });

src/bindAll.ts

@@ -1,7 +1,7 @@
 import isFunction = require('lodash/isFunction');
 
-import { copyMetadata, wrapConstructor } from './utils';
 import { InstanceChainMap } from './factory';
+import { Bind } from './bind';
 
 /**
  * Binds methods of an object to the object itself, overwriting the existing method.
@@ -27,24 +27,22 @@ import { InstanceChainMap } from './factory';
  * myClass.unbound.call(null); // => MyClass {}
  */
 export function BindAll(methods: string[] = []): ClassDecorator {
-  return (target: Function): Function => {
-    return wrapConstructor(target, function(Ctor: Function, ...args: any[]) {
-      bindAllMethods(target, this, methods);
-
-      Ctor.apply(this, args);
-    });
+  return (target: any) => {
+    bindAllMethods(target, methods);
   };
 }
 
-function bindAllMethods(target: Function, instance: any, methods: string[] = []): void {
+function bindAllMethods(target: Function, methods: string[] = []): void {
+  const targetProto = target.prototype;
   let proto = target.prototype;
+  const boundKeys: string[] = [];
 
   while (proto && proto !== Object.prototype) {
     for (const key of Object.getOwnPropertyNames(proto)) {
       const include = methods.length ? methods.indexOf(key) !== -1 : true;
       const descriptor = Object.getOwnPropertyDescriptor(proto, key);
 
-      if (include && key !== 'constructor' && !instance.hasOwnProperty(key)) {
+      if (include && key !== 'constructor') {
         // If this property is a getter and it's NOT an instance decorated
         // method, ignore it. Instance decorators are getters until first accessed.
         if (descriptor.get) {
@@ -55,15 +53,9 @@ function bindAllMethods(target: Function, instance: any, methods: string[] = [])
           }
         }
 
-        const value = instance[key];
-
-        if (isFunction(value)) {
-          Object.defineProperty(instance, key, {
-            configurable: true,
-            enumerable: descriptor.enumerable,
-            value: copyMetadata(value.bind(instance), value),
-            writable: descriptor.writable
-          });
+        if (isFunction(proto[key]) && boundKeys.indexOf(key) === -1) {
+          Object.defineProperty(targetProto, key, Bind(proto, key, descriptor)!);
+          boundKeys.push(key);
         }
       }
     }