@math.gl/core 4.0.0-beta.1 → 4.0.1

package/dist/classes/base/math-array.d.ts

@@ -1,5 +1,5 @@
 import { NumericArray } from '@math.gl/types';
-import { ConfigurationOptions } from '../../lib/common';
+import { ConfigurationOptions } from "../../lib/common.js";
 /** Base class for vectors and matrices */
 export declare abstract class MathArray extends Array<number> {
     /** Number of elements (values) in this array */
@@ -64,4 +64,3 @@ export declare abstract class MathArray extends Array<number> {
     /** @deprecated */
     get elements(): NumericArray;
 }
-//# sourceMappingURL=math-array.d.ts.map

package/dist/classes/base/math-array.js

@@ -1,269 +1,223 @@
-function _extendableBuiltin(cls) {
-  function ExtendableBuiltin() {
-    var instance = Reflect.construct(cls, Array.from(arguments));
-    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
-    return instance;
-  }
-
-  ExtendableBuiltin.prototype = Object.create(cls.prototype, {
-    constructor: {
-      value: cls,
-      enumerable: false,
-      writable: true,
-      configurable: true
-    }
-  });
-
-  if (Object.setPrototypeOf) {
-    Object.setPrototypeOf(ExtendableBuiltin, cls);
-  } else {
-    ExtendableBuiltin.__proto__ = cls;
-  }
-
-  return ExtendableBuiltin;
-}
-
 import { config, formatValue, equals, isArray } from "../../lib/common.js";
-export class MathArray extends _extendableBuiltin(Array) {
-  clone() {
-    return new this.constructor().copy(this);
-  }
-
-  fromArray(array, offset = 0) {
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      this[i] = array[i + offset];
-    }
-
-    return this.check();
-  }
-
-  toArray(targetArray = [], offset = 0) {
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      targetArray[offset + i] = this[i];
-    }
-
-    return targetArray;
-  }
-
-  toObject(targetObject) {
-    return targetObject;
-  }
-
-  from(arrayOrObject) {
-    return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
-  }
-
-  to(arrayOrObject) {
-    if (arrayOrObject === this) {
-      return this;
-    }
-
-    return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
-  }
-
-  toTarget(target) {
-    return target ? this.to(target) : this;
-  }
-
-  toFloat32Array() {
-    return new Float32Array(this);
-  }
-
-  toString() {
-    return this.formatString(config);
-  }
-
-  formatString(opts) {
-    let string = '';
-
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      string += (i > 0 ? ', ' : '') + formatValue(this[i], opts);
-    }
-
-    return "".concat(opts.printTypes ? this.constructor.name : '', "[").concat(string, "]");
-  }
-
-  equals(array) {
-    if (!array || this.length !== array.length) {
-      return false;
-    }
-
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      if (!equals(this[i], array[i])) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  exactEquals(array) {
-    if (!array || this.length !== array.length) {
-      return false;
-    }
-
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      if (this[i] !== array[i]) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  negate() {
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      this[i] = -this[i];
-    }
-
-    return this.check();
-  }
-
-  lerp(a, b, t) {
-    if (t === undefined) {
-      return this.lerp(this, a, b);
-    }
-
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      const ai = a[i];
-      const endValue = typeof b === 'number' ? b : b[i];
-      this[i] = ai + t * (endValue - ai);
-    }
-
-    return this.check();
-  }
-
-  min(vector) {
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      this[i] = Math.min(vector[i], this[i]);
-    }
-
-    return this.check();
-  }
-
-  max(vector) {
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      this[i] = Math.max(vector[i], this[i]);
-    }
-
-    return this.check();
-  }
-
-  clamp(minVector, maxVector) {
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]);
-    }
-
-    return this.check();
-  }
-
-  add(...vectors) {
-    for (const vector of vectors) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] += vector[i];
-      }
-    }
-
-    return this.check();
-  }
-
-  subtract(...vectors) {
-    for (const vector of vectors) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] -= vector[i];
-      }
-    }
-
-    return this.check();
-  }
-
-  scale(scale) {
-    if (typeof scale === 'number') {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] *= scale;
-      }
-    } else {
-      for (let i = 0; i < this.ELEMENTS && i < scale.length; ++i) {
-        this[i] *= scale[i];
-      }
-    }
-
-    return this.check();
-  }
-
-  multiplyByScalar(scalar) {
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      this[i] *= scalar;
-    }
-
-    return this.check();
-  }
-
-  check() {
-    if (config.debug && !this.validate()) {
-      throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'"));
-    }
-
-    return this;
-  }
-
-  validate() {
-    let valid = this.length === this.ELEMENTS;
-
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      valid = valid && Number.isFinite(this[i]);
-    }
-
-    return valid;
-  }
-
-  sub(a) {
-    return this.subtract(a);
-  }
-
-  setScalar(a) {
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      this[i] = a;
-    }
-
-    return this.check();
-  }
-
-  addScalar(a) {
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      this[i] += a;
-    }
-
-    return this.check();
-  }
-
-  subScalar(a) {
-    return this.addScalar(-a);
-  }
-
-  multiplyScalar(scalar) {
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      this[i] *= scalar;
-    }
-
-    return this.check();
-  }
-
-  divideScalar(a) {
-    return this.multiplyByScalar(1 / a);
-  }
-
-  clampScalar(min, max) {
-    for (let i = 0; i < this.ELEMENTS; ++i) {
-      this[i] = Math.min(Math.max(this[i], min), max);
+/** Base class for vectors and matrices */
+export class MathArray extends Array {
+    // Common methods
+    /**
+     * Clone the current object
+     * @returns a new copy of this object
+     */
+    clone() {
+        // @ts-expect-error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
+        return new this.constructor().copy(this); // eslint-disable-line
+    }
+    fromArray(array, offset = 0) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = array[i + offset];
+        }
+        return this.check();
+    }
+    toArray(targetArray = [], offset = 0) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            targetArray[offset + i] = this[i];
+        }
+        return targetArray;
+    }
+    toObject(targetObject) {
+        return targetObject;
+    }
+    from(arrayOrObject) {
+        return Array.isArray(arrayOrObject)
+            ? this.copy(arrayOrObject)
+            : // @ts-ignore
+                this.fromObject(arrayOrObject);
+    }
+    to(arrayOrObject) {
+        // @ts-ignore
+        if (arrayOrObject === this) {
+            return this;
+        }
+        // @ts-expect-error TS2339: Property 'toObject' does not exist on type 'MathArray'.
+        return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
+    }
+    toTarget(target) {
+        return target ? this.to(target) : this;
+    }
+    /** @deprecated */
+    toFloat32Array() {
+        return new Float32Array(this);
+    }
+    toString() {
+        return this.formatString(config);
+    }
+    /** Formats string according to options */
+    formatString(opts) {
+        let string = '';
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            string += (i > 0 ? ', ' : '') + formatValue(this[i], opts);
+        }
+        return `${opts.printTypes ? this.constructor.name : ''}[${string}]`;
+    }
+    equals(array) {
+        if (!array || this.length !== array.length) {
+            return false;
+        }
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            if (!equals(this[i], array[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    exactEquals(array) {
+        if (!array || this.length !== array.length) {
+            return false;
+        }
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            if (this[i] !== array[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Modifiers
+    /** Negates all values in this object */
+    negate() {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = -this[i];
+        }
+        return this.check();
+    }
+    lerp(a, b, t) {
+        if (t === undefined) {
+            return this.lerp(this, a, b);
+        }
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            const ai = a[i];
+            const endValue = typeof b === 'number' ? b : b[i];
+            this[i] = ai + t * (endValue - ai);
+        }
+        return this.check();
+    }
+    /** Minimal */
+    min(vector) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = Math.min(vector[i], this[i]);
+        }
+        return this.check();
+    }
+    /** Maximal */
+    max(vector) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = Math.max(vector[i], this[i]);
+        }
+        return this.check();
+    }
+    clamp(minVector, maxVector) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]);
+        }
+        return this.check();
+    }
+    add(...vectors) {
+        for (const vector of vectors) {
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                this[i] += vector[i];
+            }
+        }
+        return this.check();
+    }
+    subtract(...vectors) {
+        for (const vector of vectors) {
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                this[i] -= vector[i];
+            }
+        }
+        return this.check();
+    }
+    scale(scale) {
+        if (typeof scale === 'number') {
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                this[i] *= scale;
+            }
+        }
+        else {
+            for (let i = 0; i < this.ELEMENTS && i < scale.length; ++i) {
+                this[i] *= scale[i];
+            }
+        }
+        return this.check();
+    }
+    /**
+     * Multiplies all elements by `scale`
+     * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
+     */
+    multiplyByScalar(scalar) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] *= scalar;
+        }
+        return this.check();
+    }
+    // Debug checks
+    /** Throws an error if array length is incorrect or contains illegal values */
+    check() {
+        if (config.debug && !this.validate()) {
+            throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);
+        }
+        return this;
+    }
+    /** Returns false if the array length is incorrect or contains illegal values */
+    validate() {
+        let valid = this.length === this.ELEMENTS;
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            valid = valid && Number.isFinite(this[i]);
+        }
+        return valid;
+    }
+    // three.js compatibility
+    /** @deprecated */
+    sub(a) {
+        return this.subtract(a);
+    }
+    /** @deprecated */
+    setScalar(a) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = a;
+        }
+        return this.check();
+    }
+    /** @deprecated */
+    addScalar(a) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] += a;
+        }
+        return this.check();
+    }
+    /** @deprecated */
+    subScalar(a) {
+        return this.addScalar(-a);
+    }
+    /** @deprecated */
+    multiplyScalar(scalar) {
+        // Multiplies all elements
+        // `Matrix4.scale` only scales its 3x3 "minor"
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] *= scalar;
+        }
+        return this.check();
+    }
+    /** @deprecated */
+    divideScalar(a) {
+        return this.multiplyByScalar(1 / a);
+    }
+    /** @deprecated */
+    clampScalar(min, max) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = Math.min(Math.max(this[i], min), max);
+        }
+        return this.check();
+    }
+    /** @deprecated */
+    get elements() {
+        return this;
     }
-
-    return this.check();
-  }
-
-  get elements() {
-    return this;
-  }
-
 }
-//# sourceMappingURL=math-array.js.map

package/dist/classes/base/matrix.d.ts

@@ -1,5 +1,5 @@
 import { NumericArray } from '@math.gl/types';
-import { MathArray } from './math-array';
+import { MathArray } from "./math-array.js";
 /** Base class for matrices */
 export declare abstract class Matrix extends MathArray {
     abstract get RANK(): number;
@@ -11,4 +11,3 @@ export declare abstract class Matrix extends MathArray {
     getColumn(columnIndex: number): number[];
     setColumn(columnIndex: number, columnVector: Readonly<NumericArray>): this;
 }
-//# sourceMappingURL=matrix.d.ts.map

package/dist/classes/base/matrix.js

@@ -1,62 +1,61 @@
 import { MathArray } from "./math-array.js";
 import { checkNumber } from "../../lib/validators.js";
 import { config } from "../../lib/common.js";
+/** Base class for matrices */
 export class Matrix extends MathArray {
-  toString() {
-    let string = '[';
-
-    if (config.printRowMajor) {
-      string += 'row-major:';
-
-      for (let row = 0; row < this.RANK; ++row) {
-        for (let col = 0; col < this.RANK; ++col) {
-          string += " ".concat(this[col * this.RANK + row]);
+    // fromObject(object) {
+    //   const array = object.elements;
+    //   return this.fromRowMajor(array);
+    // }
+    // toObject(object) {
+    //   const array = object.elements;
+    //   this.toRowMajor(array);
+    //   return object;
+    // }
+    // TODO better override formatString?
+    toString() {
+        let string = '[';
+        if (config.printRowMajor) {
+            string += 'row-major:';
+            for (let row = 0; row < this.RANK; ++row) {
+                for (let col = 0; col < this.RANK; ++col) {
+                    string += ` ${this[col * this.RANK + row]}`;
+                }
+            }
         }
-      }
-    } else {
-      string += 'column-major:';
-
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        string += " ".concat(this[i]);
-      }
+        else {
+            string += 'column-major:';
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                string += ` ${this[i]}`;
+            }
+        }
+        string += ']';
+        return string;
+    }
+    getElementIndex(row, col) {
+        return col * this.RANK + row;
+    }
+    // By default assumes row major indices
+    getElement(row, col) {
+        return this[col * this.RANK + row];
     }
-
-    string += ']';
-    return string;
-  }
-
-  getElementIndex(row, col) {
-    return col * this.RANK + row;
-  }
-
-  getElement(row, col) {
-    return this[col * this.RANK + row];
-  }
-
-  setElement(row, col, value) {
-    this[col * this.RANK + row] = checkNumber(value);
-    return this;
-  }
-
-  getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) {
-    const firstIndex = columnIndex * this.RANK;
-
-    for (let i = 0; i < this.RANK; ++i) {
-      result[i] = this[firstIndex + i];
+    // By default assumes row major indices
+    setElement(row, col, value) {
+        this[col * this.RANK + row] = checkNumber(value);
+        return this;
     }
-
-    return result;
-  }
-
-  setColumn(columnIndex, columnVector) {
-    const firstIndex = columnIndex * this.RANK;
-
-    for (let i = 0; i < this.RANK; ++i) {
-      this[firstIndex + i] = columnVector[i];
+    getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) {
+        const firstIndex = columnIndex * this.RANK;
+        for (let i = 0; i < this.RANK; ++i) {
+            result[i] = this[firstIndex + i];
+        }
+        return result;
+    }
+    setColumn(columnIndex, columnVector) {
+        const firstIndex = columnIndex * this.RANK;
+        for (let i = 0; i < this.RANK; ++i) {
+            this[firstIndex + i] = columnVector[i];
+        }
+        return this;
     }
-
-    return this;
-  }
-
 }
-//# sourceMappingURL=matrix.js.map

package/dist/classes/base/vector.d.ts

@@ -1,5 +1,5 @@
 import { NumericArray } from '@math.gl/types';
-import { MathArray } from './math-array';
+import { MathArray } from "./math-array.js";
 /** Base class for vectors with at least 2 elements */
 export declare abstract class Vector extends MathArray {
     get x(): number;
@@ -41,4 +41,3 @@ export declare abstract class Vector extends MathArray {
     multiplyVectors(a: Readonly<NumericArray>, b: Readonly<NumericArray>): this;
     addScaledVector(a: Readonly<NumericArray>, b: number): this;
 }
-//# sourceMappingURL=vector.d.ts.map