constructor_interfaces_ts

/**
 * TypeScript Constructor Interfaces Proposal
 *
 * Author: Reed Spool
 */

/**
 * Root interface for Constructor Interfaces. This is a workaround for
 * TypeScript's lack of "static" methods for classes.
 *
 * Based on StackOverflow user chris's solution. See
 * https://stackoverflow.com/a/43484801/1037165
 *
 * @interface IConstructor
 * @template InstanceInterface
 */
interface IConstructor<InstanceInterface>
{
  /**
   * Explicitly typed constructor is required, so make an extremely permissive
   * declaration that can be refined in subclasses.
   *
   * @constructor
   */
  new (...args : any[]) : InstanceInterface;
}

/**
 * That's ALL for the definition. What follows is a comprehensive usage
 * example.
 */

// Create a Constructor Interface by extending IConstructor and
// specifiying your Instance Interface. Keep your class open for
// extension with "T extends ...".
interface CMyClass<T extends IMyClass> extends IConstructor<T>
{
  // Specify constructor parameters safely, staying open for extension
  // by specifying any variatic arguments. You don't need to specify
  // a constructor though.
  new (instanceValue : string, ...args : any[]) : T;

  // Properties on Constructor Interfaces can be accessed by the
  // Class object.
  aClassProperty : string;

  // This is useful for static factory methods.
  aClassMethod () : T
}

// Create a normal Instance Interface. IConstructor doesn't require
// or restrict anything here. You could use anything, including
// `Object` or `any`
interface IMyClass
{
}

// This is the hackish part: Your class must be anonymous so that
// you can specify the type of the variable that holds it. So make a
// `const` variable of your Constructor Interface's type set to a new
// anonymous class which implements your Instance Interface.
export const MyClass : CMyClass<IMyClass> = class implements IMyClass
{
  // The constructor must satisfy CMyClass's `new` signature.
  constructor (instanceValue : string, ...args : any[])
  {
  }

  // We can use the built-in JS `static` keyword to satisfy the interface
  // of CMyClass
  static aClassProperty : string = "myProp";
  static aClassMethod () : IMyClass { return new MyClass(); }
}