Review Mixins for language changes about typescript-handbook HOT 3 OPEN

namespace DisposableMixin {
  var classesUsingThis : Function[] = [];

  export interface DisposableInterface {
    isDisposed: boolean;
    dispose() : void;
  }

  class DisposableImplementation implements DisposableInterface {
    isDisposed:boolean;
    dispose():void {
      this.isDisposed = true;
    }
  }

  export var mixInto = makeMixinApplicator(DisposableImplementation, classesUsingThis);
  export var usedBy = makeMixinInstanceChecker<DisposableInterface>(classesUsingThis);
}


namespace ActivatableMixin {
  var classesUsingThis : Function[] = [];

  export interface ActivatableInterface {
    isActive: boolean
    activate() : void
    deactivate() : void
  }

  class ActivatableImplementation implements ActivatableInterface {
    isActive: boolean;
    activate() {
      this.isActive = true;
    }
    deactivate() {
      this.isActive = false;
    }
  }

  export var mixInto = makeMixinApplicator(ActivatableImplementation, classesUsingThis);
  export var isActivatable = makeMixinInstanceChecker<ActivatableInterface>(classesUsingThis);
}

import DisposableInterface = DisposableMixin.DisposableInterface;
import ActivatableInterface = ActivatableMixin.ActivatableInterface;

class SmartObject implements DisposableInterface, ActivatableInterface {
  constructor() {
    setInterval(() => console.log("activated: " + this.isActive + " | disposed: " + this.isDisposed), 500);
  }

  interact() {
    this.activate();
  }

  // Disposable
  isDisposed: boolean = false;
  dispose: () => void;

  // Activatable
  isActive: boolean = false;
  activate: () => void;
  deactivate: () => void;
}
DisposableMixin.mixInto(SmartObject);
ActivatableMixin.mixInto(SmartObject);

var smartObj = new SmartObject();
setTimeout(() => smartObj.interact(), 1000);


////////////////////////////////////////
// In your runtime library somewhere
////////////////////////////////////////

function makeMixinApplicator(mixinImplementation:any, classesUsingMixin:any[], exclude_constructor=true) : (c:any) => void {
  return (c:any) => {
    classesUsingMixin.push(c);
    Object.getOwnPropertyNames(mixinImplementation.prototype).forEach(name => {
      if(!exclude_constructor || name !== "constructor") {
        (<any>c.prototype)[name] = (<any>mixinImplementation.prototype)[name];
      }
    })
  };
}

function makeMixinInstanceChecker<T>(classesUsingMixin:Function[]) : ( (x:any) => x is T ) {
  return (x:any) : x is T => {
    for(let i=0; i<classesUsingMixin.length; i++) {
      if(x instanceof classesUsingMixin[i])
        return true;
    }
    return false;
  }
}