Migrate math module to TypeScript

[drewhoener]

Public API Changes
None

Description

Overview

This PR migrates the classes in the math module to Typescript. As I mentioned in #904, this PR is largely trivial and just requires adding the types described in the JSDoc.

Contents

• Adds an interface I<Type> to each so math modules can reference each other without introducing circular imports.
• Use the same interfaces to provide constructor options
• Adds some utility types for null and undefined

Depends on #905

GitHub doesn't have "dependent PRs" so all previous commits are included here. Might not be worth reviewing until dependencies are merged

[EzraBrooks]

GitHub tip: if you made this PR be based on your prior PR, it would deduplicate the diff - and when that PR is merged it would automatically retarget this one to the new base branch.

[drewhoener]

GitHub tip: if you made this PR be based on your prior PR, it would deduplicate the diff - and when that PR is merged it would automatically retarget this one to the new base branch.

Yeah, the 3 PRs I made are in a direct chain with each other, the branches continue from the previous one. I just mean github still shows all the commits until the previous one is merged. You can absolutely start reviewing at the first relevant commit though

[drewhoener]

@EzraBrooks this one should also be ready

[EzraBrooks]

In modern typescript do we actually need the interfaces here or can we just import the class type as a type? I thought we could import type MyClass now 🤔

[drewhoener]

In modern typescript do we actually need the interfaces here or can we just import the class type as a type? I thought we could import type MyClass now 🤔

We can, the constructors define object types for their options though, so it made sense to make a type for it to also inherit. Either that or I'd have to define a type anyway for the constructor since I'm trying not to change any API semantics.
It also helps with DX for methods like Quaternion.multiply, if it accepts the interface type you don't have to be so verbose by making a new class instance.

const q: Quaternion = new Quaternion({
  x: 1,
  y: 1,
  z: 1,
  w: 1
});

// Without the interface type
q.multiply(new Quaternion({
  x: 1,
  y: 1,
  z: 1,
  w: 1
}));

// With type interface
q.multiply({
  x: 1,
  y: 1,
  z: 1,
  w: 1
});

You can still pass in a Quaternion instance, but it provides more flexibility

[EzraBrooks]

Makes sense to me. I guess I'm just out of the object-oriented mindset 😆