@math.gl/core 3.5.7 → 3.6.0-alpha.3

package/src/classes/{pose.js → pose.ts}

@@ -1,28 +1,25 @@
 // Copyright (c) 2017 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
+// MIT License
 import Matrix4 from './matrix4';
 import Vector3 from './vector3';
 import Euler from './euler';
+import {NumericArray} from '@math.gl/types';
+
+type PoseOptions = {
+  position?: Readonly<NumericArray>;
+  orientation?: Readonly<NumericArray>;
+  x?: number;
+  y?: number;
+  z?: number;
+  roll?: number;
+  pitch?: number;
+  yaw?: number;
+};
 
 export default class Pose {
-  // @ts-ignore TS2740: Type '{}' is missing the following properties from type
+  readonly position: Vector3;
+  readonly orientation: Euler;
+
   constructor({
     x = 0,
     y = 0,
@@ -30,74 +27,85 @@ export default class Pose {
     roll = 0,
     pitch = 0,
     yaw = 0,
-    position = undefined,
-    orientation = undefined
-  } = {}) {
+    position,
+    orientation
+  }: PoseOptions = {}) {
     if (Array.isArray(position) && position.length === 3) {
       this.position = new Vector3(position);
     } else {
       this.position = new Vector3(x, y, z);
     }
     if (Array.isArray(orientation) && orientation.length === 4) {
+      // @ts-expect-error
       this.orientation = new Euler(orientation, orientation[3]);
     } else {
       this.orientation = new Euler(roll, pitch, yaw, Euler.RollPitchYaw);
     }
   }
 
-  get x() {
+  get x(): number {
     return this.position.x;
   }
-  set x(value) {
+
+  set x(value: number) {
     this.position.x = value;
   }
-  get y() {
+
+  get y(): number {
     return this.position.y;
   }
-  set y(value) {
+
+  set y(value: number) {
     this.position.y = value;
   }
-  get z() {
+
+  get z(): number {
     return this.position.z;
   }
-  set z(value) {
+
+  set z(value: number) {
     this.position.z = value;
   }
-  get roll() {
+
+  get roll(): number {
     return this.orientation.roll;
   }
-  set roll(value) {
+
+  set roll(value: number) {
     this.orientation.roll = value;
   }
-  get pitch() {
+
+  get pitch(): number {
     return this.orientation.pitch;
   }
-  set pitch(value) {
+  set pitch(value: number) {
     this.orientation.pitch = value;
   }
-  get yaw() {
+
+  get yaw(): number {
     return this.orientation.yaw;
   }
-  set yaw(value) {
+
+  set yaw(value: number) {
     this.orientation.yaw = value;
   }
 
-  getPosition() {
+  getPosition(): Vector3 {
     return this.position;
   }
 
-  getOrientation() {
+  getOrientation(): Euler {
     return this.orientation;
   }
 
-  equals(pose) {
+  equals(pose: Pose): boolean {
     if (!pose) {
       return false;
     }
     return this.position.equals(pose.position) && this.orientation.equals(pose.orientation);
   }
 
-  exactEquals(pose) {
+  exactEquals(pose: Pose): boolean {
     if (!pose) {
       return false;
     }
@@ -106,48 +114,43 @@ export default class Pose {
     );
   }
 
-  getTransformationMatrix() {
-    // setup precomputations for the sin/cos of the angles
+  getTransformationMatrix(): Matrix4 {
+    // setup pre computations for the sin/cos of the angles
     const sr = Math.sin(this.roll);
     const sp = Math.sin(this.pitch);
     const sw = Math.sin(this.yaw);
-
     const cr = Math.cos(this.roll);
     const cp = Math.cos(this.pitch);
     const cw = Math.cos(this.yaw);
 
-    const matrix = new Matrix4().setRowMajor(
+    // Create matrix
+    return new Matrix4().setRowMajor(
       cw * cp, // 0,0
       -sw * cr + cw * sp * sr, // 0,1
       sw * sr + cw * sp * cr, // 0,2
       this.x, // 0,3
-
       sw * cp, // 1,0
       cw * cr + sw * sp * sr, // 1,1
       -cw * sr + sw * sp * cr, // 1,2
       this.y, // 1,3
-
       -sp, // 2,0
       cp * sr, // 2,1
       cp * cr, // 2,2
       this.z, // 2,3
-
       0,
       0,
       0,
       1
     );
-
-    return matrix;
   }
 
-  getTransformationMatrixFromPose(pose) {
+  getTransformationMatrixFromPose(pose: Pose): Matrix4 {
     return new Matrix4()
       .multiplyRight(this.getTransformationMatrix())
       .multiplyRight(pose.getTransformationMatrix().invert());
   }
 
-  getTransformationMatrixToPose(pose) {
+  getTransformationMatrixToPose(pose: Pose): Matrix4 {
     return new Matrix4()
       .multiplyRight(pose.getTransformationMatrix())
       .multiplyRight(this.getTransformationMatrix().invert());

package/src/classes/{quaternion.js → quaternion.ts}

@@ -1,47 +1,27 @@
 // Copyright (c) 2017 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
+// MIT License
 import MathArray from './base/math-array';
 import {checkNumber, checkVector} from '../lib/validators';
-import assert from '../lib/assert';
-
-// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.
+import Vector4 from './vector4';
 import * as quat from 'gl-matrix/quat';
-// @ts-ignore: error TS2307: Cannot find module 'gl-matrix/...'.
 import * as vec4 from 'gl-matrix/vec4';
+import {NumericArray} from '@math.gl/types';
 
-const IDENTITY_QUATERNION = [0, 0, 0, 1];
+const IDENTITY_QUATERNION = [0, 0, 0, 1] as const;
 
 export default class Quaternion extends MathArray {
-  constructor(x = 0, y = 0, z = 0, w = 1) {
+  constructor(x: number | Readonly<NumericArray> = 0, y = 0, z = 0, w = 1) {
     // PERF NOTE: initialize elements as double precision numbers
     super(-0, -0, -0, -0);
     // eslint-disable-next-line prefer-rest-params
     if (Array.isArray(x) && arguments.length === 1) {
       this.copy(x);
     } else {
-      this.set(x, y, z, w);
+      this.set(x as number, y, z, w);
     }
   }
 
-  copy(array) {
+  copy(array: Readonly<NumericArray>): this {
     this[0] = array[0];
     this[1] = array[1];
     this[2] = array[2];
@@ -49,7 +29,7 @@ export default class Quaternion extends MathArray {
     return this.check();
   }
 
-  set(x, y, z, w) {
+  set(x: number, y: number, z: number, w: number): this {
     this[0] = x;
     this[1] = y;
     this[2] = z;
@@ -57,25 +37,37 @@ export default class Quaternion extends MathArray {
     return this.check();
   }
 
-  // Creates a quaternion from the given 3x3 rotation matrix.
-  // NOTE: The resultant quaternion is not normalized, so you should
-  // be sure to renormalize the quaternion yourself where necessary.
-  fromMatrix3(m) {
-    quat.fromMat3(this, m);
+  fromObject(object: {x: number; y: number; z: number; w: number}): this {
+    this[0] = object.x;
+    this[1] = object.y;
+    this[2] = object.z;
+    this[3] = object.w;
     return this.check();
   }
 
-  // Set a quat to the identity quaternion
-  identity() {
-    quat.identity(this);
+  /**
+   * Creates a quaternion from the given 3x3 rotation matrix.
+   * NOTE: The resultant quaternion is not normalized, so you should
+   * be sure to renormalize the quaternion yourself where necessary.
+   * @param m
+   * @returns
+   */
+  fromMatrix3(m: Readonly<NumericArray>): this {
+    quat.fromMat3(this, m);
     return this.check();
   }
 
-  fromAxisRotation(axis, rad) {
+  fromAxisRotation(axis: Readonly<NumericArray>, rad: number): this {
     quat.setAxisAngle(this, axis, rad);
     return this.check();
   }
 
+  /** Set a quat to the identity quaternion */
+  identity(): this {
+    quat.identity(this);
+    return this.check();
+  }
+
   // Set the components of a quat to the given values
   // set(i, j, k, l) {
   //   quat.set(this, i, j, k, l);
@@ -83,66 +75,56 @@ export default class Quaternion extends MathArray {
   // }
 
   // Sets a quat from the given angle and rotation axis, then returns it.
-  setAxisAngle(axis, rad) {
+  setAxisAngle(axis: Readonly<NumericArray>, rad: number): this {
     return this.fromAxisRotation(axis, rad);
   }
 
   // Getters/setters
-  /* eslint-disable no-multi-spaces, brace-style, no-return-assign */
-  get ELEMENTS() {
+  get ELEMENTS(): number {
     return 4;
   }
 
-  get x() {
+  get x(): number {
     return this[0];
   }
-
-  set x(value) {
+  set x(value: number) {
     this[0] = checkNumber(value);
   }
 
-  get y() {
+  get y(): number {
     return this[1];
   }
-
-  set y(value) {
+  set y(value: number) {
     this[1] = checkNumber(value);
   }
 
-  get z() {
+  get z(): number {
     return this[2];
   }
-
-  set z(value) {
+  set z(value: number) {
     this[2] = checkNumber(value);
   }
 
-  get w() {
+  get w(): number {
     return this[3];
   }
-
-  set w(value) {
+  set w(value: number) {
     this[3] = checkNumber(value);
   }
 
-  /* eslint-enable no-multi-spaces, brace-style, no-return-assign */
-
   // Calculates the length of a quat
-  len() {
+  len(): number {
     return quat.length(this);
   }
 
   // Calculates the squared length of a quat
-  lengthSquared() {
+  lengthSquared(): number {
     return quat.squaredLength(this);
   }
 
   // Calculates the dot product of two quat's
   // @return {Number}
-  dot(a, b) {
-    if (b !== undefined) {
-      throw new Error('Quaternion.dot only takes one argument');
-    }
+  dot(a: Readonly<NumericArray>): number {
     return quat.dot(this, a);
   }
 
@@ -159,12 +141,10 @@ export default class Quaternion extends MathArray {
   //   const angle = quat.getAxisAngle(axis, this);
   //   return {axis, angle};
   // }
-
   // MODIFIERS
-
   // Sets a quaternion to represent the shortest rotation from one vector
   // to another. Both vectors are assumed to be unit length.
-  rotationTo(vectorA, vectorB) {
+  rotationTo(vectorA: NumericArray, vectorB: NumericArray): this {
     quat.rotationTo(this, vectorA, vectorB);
     return this.check();
   }
@@ -175,62 +155,58 @@ export default class Quaternion extends MathArray {
   // setAxes() {
   //   Number
   // }
-
   // Performs a spherical linear interpolation with two control points
   // sqlerp() {
   //   Number;
   // }
-
   // Adds two quat's
-  add(a, b) {
-    if (b !== undefined) {
-      throw new Error('Quaternion.add only takes one argument');
-    }
+  add(a: Readonly<NumericArray>): this {
     quat.add(this, this, a);
     return this.check();
   }
 
   // Calculates the W component of a quat from the X, Y, and Z components.
   // Any existing W component will be ignored.
-  calculateW() {
+  calculateW(): this {
     quat.calculateW(this, this);
     return this.check();
   }
 
   // Calculates the conjugate of a quat If the quaternion is normalized,
   // this function is faster than quat.inverse and produces the same result.
-  conjugate() {
+  conjugate(): this {
     quat.conjugate(this, this);
     return this.check();
   }
 
   // Calculates the inverse of a quat
-  invert() {
+  invert(): this {
     quat.invert(this, this);
     return this.check();
   }
 
   // Performs a linear interpolation between two quat's
-  lerp(a, b, t) {
-    quat.lerp(this, a, b, t);
+  lerp(a: Readonly<NumericArray>, b: Readonly<NumericArray> | number, t?: number): this {
+    if (t === undefined) {
+      return this.lerp(this, a, b as number);
+    }
+    quat.lerp(this, a, b as NumericArray, t);
     return this.check();
   }
 
   // Multiplies two quat's
-  multiplyRight(a, b) {
-    assert(!b); // Quaternion.multiply only takes one argument
+  multiplyRight(a: Readonly<NumericArray>): this {
     quat.multiply(this, this, a);
     return this.check();
   }
 
-  multiplyLeft(a, b) {
-    assert(!b); // Quaternion.multiply only takes one argument
+  multiplyLeft(a: Readonly<NumericArray>): this {
     quat.multiply(this, a, this);
     return this.check();
   }
 
   // Normalize a quat
-  normalize() {
+  normalize(): this {
     // Handle 0 case
     const length = this.len();
     const l = length > 0 ? 1 / length : 0;
@@ -246,67 +222,103 @@ export default class Quaternion extends MathArray {
   }
 
   // Rotates a quaternion by the given angle about the X axis
-  rotateX(rad) {
+  rotateX(rad: number): this {
     quat.rotateX(this, this, rad);
     return this.check();
   }
 
   // Rotates a quaternion by the given angle about the Y axis
-  rotateY(rad) {
+  rotateY(rad: number): this {
     quat.rotateY(this, this, rad);
     return this.check();
   }
 
   // Rotates a quaternion by the given angle about the Z axis
-  rotateZ(rad) {
+  rotateZ(rad: number): this {
     quat.rotateZ(this, this, rad);
     return this.check();
   }
 
   // Scales a quat by a scalar number
-  scale(b) {
+  scale(b: number): this {
     quat.scale(this, this, b);
     return this.check();
   }
 
+  slerp(target: Readonly<NumericArray>, ratio: number): this;
+  slerp(start: Readonly<NumericArray>, target: Readonly<NumericArray>, ratio: number): this;
+  slerp(params: {
+    start: Readonly<NumericArray>;
+    target: Readonly<NumericArray>;
+    ratio: number;
+  }): this;
+
   // Performs a spherical linear interpolation between two quat
-  slerp(start, target, ratio) {
+  slerp(
+    arg0:
+      | Readonly<NumericArray>
+      | {
+          start: Readonly<NumericArray>;
+          target: Readonly<NumericArray>;
+          ratio: number;
+        },
+    arg1?: Readonly<NumericArray> | number,
+    arg2?: number
+  ) {
+    let start: Readonly<NumericArray>;
+    let target: Readonly<NumericArray>;
+    let ratio: number;
     // eslint-disable-next-line prefer-rest-params
     switch (arguments.length) {
       case 1: // Deprecated signature ({start, target, ratio})
         // eslint-disable-next-line prefer-rest-params
-        ({start = IDENTITY_QUATERNION, target, ratio} = arguments[0]);
+        ({
+          start = IDENTITY_QUATERNION,
+          target,
+          ratio
+        } = arg0 as {
+          start: Readonly<NumericArray>;
+          target: Readonly<NumericArray>;
+          ratio: number;
+        });
         break;
       case 2: // THREE.js compatibility signature (target, ration)
-        // eslint-disable-next-line prefer-rest-params
-        [target, ratio] = arguments;
         start = this; // eslint-disable-line
+        target = arg0 as Readonly<NumericArray>;
+        ratio = arg1 as number;
         break;
-      default: // Default signature: (start, target, ratio)
+      default:
+        // Default signature: (start, target, ratio)
+        start = arg0 as Readonly<NumericArray>;
+        target = arg1 as Readonly<NumericArray>;
+        ratio = arg2;
     }
     quat.slerp(this, start, target, ratio);
     return this.check();
   }
 
-  transformVector4(vector, result = vector) {
+  transformVector4(
+    vector: Readonly<NumericArray>,
+    result: NumericArray = new Vector4()
+  ): NumericArray {
     vec4.transformQuat(result, vector, this);
     return checkVector(result, 4);
   }
 
   // THREE.js Math API compatibility
-  lengthSq() {
+  lengthSq(): number {
     return this.lengthSquared();
   }
 
-  setFromAxisAngle(axis, rad) {
+  setFromAxisAngle(axis: Readonly<NumericArray>, rad: number): this {
     return this.setAxisAngle(axis, rad);
   }
 
-  premultiply(a, b) {
-    return this.multiplyLeft(a, b);
+  premultiply(a: Readonly<NumericArray>): this {
+    return this.multiplyLeft(a);
   }
 
-  multiply(a, b) {
-    return this.multiplyRight(a, b);
+  multiply(a: Readonly<NumericArray>) {
+    return this.multiplyRight(a);
   }
 }