Convert to TypeScript

[pixelzoom]

I've started converting this sim to TypeScript a bit at a time. But it will be more challenging than most, because of certain JavaScript patterns that I now regret using (parameters of type constructor, duck typing, etc.) So I'm creating this issue to track progress and challenges.

function-builder is currently 32% converted, function-builder-basics 13%.

[pixelzoom]

Unassigning until work on this sim resumes.

[pixelzoom]

Some notes on the remaining conversion to TypeScript...

... But it will be more challenging than most, because of certain JavaScript patterns that I now regret using (parameters of type constructor, duck typing, etc.)

Parameters of type constructor can be identified by searching for "Constructor" (case sensitive). Here's a list, possibly incomplete, and the types may not be accurate:

• functionConstructor: AbstractFunction (ImageFunction in function-builder-basics)
• functionConstructors: ? (in function-builder-basics)
• functionNodeConstructor: FunctionNode
• SceneNodeConstructor: FBSceneNode
• cardConstructor: Card
• cardNodeConstructor: CardNode

For parameters that are constructors, have a look at TypeScript utility types ConstructorType<T> (??) and ConstructorParameters<typeof T>.

A couple of other ways to address parameters that are constructors:

Get the type of a constructor function using typeof:

class MyClass {
  constructor(public value: number) {}
}

type MyClassConstructor = typeof MyClass;

const myClassInstance = new MyClassConstructor(42); 

Define a type that represents a constructor function using a construct signature:

type MyConstructor = new (name: string, age: number) => Person;

class Person {
  constructor(public name: string, public age: number) {}
}

const createPerson: MyConstructor = Person; 
const john = new createPerson("John", 30);

... But it will be more challenging than most, because of certain JavaScript patterns that I now regret using (parameters of type constructor, duck typing, etc.)

Duck typing can be identified by looking for:

• @param annotations that specify multiple types (9 matched for regex '@param .*\|')
• @returns annotations that specify multiple types (3 matches for regex '@returns .*\|')
• associated usages of instanceof (28 occurrences).

MathFunction.js has examples of all of these:

  /**
   * Applies this function.
   *
   * @param {RationalNumber|MathFunction[]} input - rational number or array of MathFunction
   * @returns {RationalNumber|MathFunction[]} output, of same type as input
   * @public
   * @override
   */
  applyFunction( input ) {
    if ( input instanceof RationalNumber ) {
      return this.applyRationalNumber( input, this.operandProperty.value );
    }
    else if ( Array.isArray( input ) ) {
      return input.concat( this );
    }
    else {
      throw new Error( 'unsupported input type' );
    }
  }