@math.gl/core 4.0.0 → 4.0.1

package/dist/index.d.ts

@@ -1,30 +1,29 @@
 export type { TypedArray, NumericArray } from '@math.gl/types';
 export type { isTypedArray, isNumericArray } from '@math.gl/types';
-export { Vector2 } from './classes/vector2';
-export { Vector3 } from './classes/vector3';
-export { Vector4 } from './classes/vector4';
-export { Matrix3 } from './classes/matrix3';
-export { Matrix4 } from './classes/matrix4';
-export { Quaternion } from './classes/quaternion';
-export { SphericalCoordinates } from './classes/spherical-coordinates';
-export { Pose } from './classes/pose';
-export { Euler } from './classes/euler';
-export * as _MathUtils from './lib/math-utils';
-export { assert } from './lib/assert';
-export { config, configure, formatValue, isArray, clone, equals, exactEquals, toRadians, toDegrees, radians, degrees, sin, cos, tan, asin, acos, atan, clamp, lerp, withEpsilon } from './lib/common';
-export { SphericalCoordinates as _SphericalCoordinates } from './classes/spherical-coordinates';
-export { Pose as _Pose } from './classes/pose';
-export { Euler as _Euler } from './classes/euler';
+export { Vector2 } from "./classes/vector2.js";
+export { Vector3 } from "./classes/vector3.js";
+export { Vector4 } from "./classes/vector4.js";
+export { Matrix3 } from "./classes/matrix3.js";
+export { Matrix4 } from "./classes/matrix4.js";
+export { Quaternion } from "./classes/quaternion.js";
+export { SphericalCoordinates } from "./classes/spherical-coordinates.js";
+export { Pose } from "./classes/pose.js";
+export { Euler } from "./classes/euler.js";
+export * as _MathUtils from "./lib/math-utils.js";
+export { assert } from "./lib/assert.js";
+export { config, configure, formatValue, isArray, clone, equals, exactEquals, toRadians, toDegrees, radians, degrees, sin, cos, tan, asin, acos, atan, clamp, lerp, withEpsilon } from "./lib/common.js";
+export { SphericalCoordinates as _SphericalCoordinates } from "./classes/spherical-coordinates.js";
+export { Pose as _Pose } from "./classes/pose.js";
+export { Euler as _Euler } from "./classes/euler.js";
 /** @deprecated Use Matrix3 */
-export * as mat3 from './gl-matrix/mat3';
+export * as mat3 from "./gl-matrix/mat3.js";
 /** @deprecated Use Matrix4 */
-export * as mat4 from './gl-matrix/mat4';
+export * as mat4 from "./gl-matrix/mat4.js";
 /** @deprecated Use Quaterinion */
-export * as quat from './gl-matrix/quat';
+export * as quat from "./gl-matrix/quat.js";
 /** @deprecated UseVector */
-export * as vec2 from './gl-matrix/vec2';
+export * as vec2 from "./gl-matrix/vec2.js";
 /** @deprecated Use Vector3 */
-export * as vec3 from './gl-matrix/vec3';
+export * as vec3 from "./gl-matrix/vec3.js";
 /** @deprecated Use Vector4 */
-export * as vec4 from './gl-matrix/vec4';
-//# sourceMappingURL=index.d.ts.map
+export * as vec4 from "./gl-matrix/vec4.js";

package/dist/index.js

@@ -1,29 +1,36 @@
+// luma.gl, MIT license
+// classes
 export { Vector2 } from "./classes/vector2.js";
 export { Vector3 } from "./classes/vector3.js";
 export { Vector4 } from "./classes/vector4.js";
 export { Matrix3 } from "./classes/matrix3.js";
 export { Matrix4 } from "./classes/matrix4.js";
 export { Quaternion } from "./classes/quaternion.js";
+// experimental
 export { SphericalCoordinates } from "./classes/spherical-coordinates.js";
 export { Pose } from "./classes/pose.js";
 export { Euler } from "./classes/euler.js";
-import * as _MathUtils from "./lib/math-utils.js";
-export { _MathUtils };
+export * as _MathUtils from "./lib/math-utils.js";
+// lib
 export { assert } from "./lib/assert.js";
-export { config, configure, formatValue, isArray, clone, equals, exactEquals, toRadians, toDegrees, radians, degrees, sin, cos, tan, asin, acos, atan, clamp, lerp, withEpsilon } from "./lib/common.js";
+export { 
+// math.gl global utility methods
+config, configure, formatValue, isArray, clone, equals, exactEquals, toRadians, toDegrees, 
+// math.gl "GLSL"-style functions
+radians, degrees, sin, cos, tan, asin, acos, atan, clamp, lerp, withEpsilon } from "./lib/common.js";
+// DEPRECATED
 export { SphericalCoordinates as _SphericalCoordinates } from "./classes/spherical-coordinates.js";
 export { Pose as _Pose } from "./classes/pose.js";
 export { Euler as _Euler } from "./classes/euler.js";
-import * as _mat from "./gl-matrix/mat3.js";
-export { _mat as mat3 };
-import * as _mat2 from "./gl-matrix/mat4.js";
-export { _mat2 as mat4 };
-import * as _quat from "./gl-matrix/quat.js";
-export { _quat as quat };
-import * as _vec from "./gl-matrix/vec2.js";
-export { _vec as vec2 };
-import * as _vec2 from "./gl-matrix/vec3.js";
-export { _vec2 as vec3 };
-import * as _vec3 from "./gl-matrix/vec4.js";
-export { _vec3 as vec4 };
-//# sourceMappingURL=index.js.map
+/** @deprecated Use Matrix3 */
+export * as mat3 from "./gl-matrix/mat3.js";
+/** @deprecated Use Matrix4 */
+export * as mat4 from "./gl-matrix/mat4.js";
+/** @deprecated Use Quaterinion */
+export * as quat from "./gl-matrix/quat.js";
+/** @deprecated UseVector */
+export * as vec2 from "./gl-matrix/vec2.js";
+/** @deprecated Use Vector3 */
+export * as vec3 from "./gl-matrix/vec3.js";
+/** @deprecated Use Vector4 */
+export * as vec4 from "./gl-matrix/vec4.js";

package/dist/lib/assert.d.ts

@@ -1,2 +1 @@
 export declare function assert(condition: unknown, message?: string): void;
-//# sourceMappingURL=assert.d.ts.map

package/dist/lib/assert.js

@@ -1,6 +1,5 @@
 export function assert(condition, message) {
-  if (!condition) {
-    throw new Error("math.gl assertion ".concat(message));
-  }
+    if (!condition) {
+        throw new Error(`math.gl assertion ${message}`);
+    }
 }
-//# sourceMappingURL=assert.js.map

package/dist/lib/common.d.ts

@@ -1,6 +1,6 @@
 import type { NumericArray } from '@math.gl/types';
-import type { MathArray } from '../classes/base/math-array';
-export declare type ConfigurationOptions = {
+import type { MathArray } from "../classes/base/math-array.js";
+export type ConfigurationOptions = {
     EPSILON: number;
     debug?: boolean;
     precision: number;
@@ -97,4 +97,3 @@ export declare function lerp(a: NumericArray, b: NumericArray, t: number): Numer
 export declare function equals(a: any, b: any, epsilon?: number): boolean;
 export declare function exactEquals(a: any, b: any): boolean;
 export declare function withEpsilon<T>(epsilon: number, func: () => T): T;
-//# sourceMappingURL=common.d.ts.map

package/dist/lib/common.js

@@ -1,184 +1,213 @@
-const RADIANS_TO_DEGREES = 1 / Math.PI * 180;
-const DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
+// math.gl, MIT license
+const RADIANS_TO_DEGREES = (1 / Math.PI) * 180;
+const DEGREES_TO_RADIANS = (1 / 180) * Math.PI;
 const DEFAULT_CONFIG = {
-  EPSILON: 1e-12,
-  debug: false,
-  precision: 4,
-  printTypes: false,
-  printDegrees: false,
-  printRowMajor: true,
-  _cartographicRadians: false
-};
-globalThis.mathgl = globalThis.mathgl || {
-  config: { ...DEFAULT_CONFIG
-  }
+    EPSILON: 1e-12,
+    debug: false,
+    precision: 4,
+    printTypes: false,
+    printDegrees: false,
+    printRowMajor: true,
+    _cartographicRadians: false
 };
+// Configuration is truly global as of v3.6 to ensure single config even if multiple copies of math.gl
+// Multiple copies of config can be quite tricky to debug...
+globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
 export const config = globalThis.mathgl.config;
 export function configure(options) {
-  Object.assign(config, options);
-  return config;
-}
-export function formatValue(value, {
-  precision = config.precision
-} = {}) {
-  value = round(value);
-  return "".concat(parseFloat(value.toPrecision(precision)));
-}
+    // Only copy existing keys
+    Object.assign(config, options);
+    return config;
+}
+/**
+ * Formats a value into a string
+ * @param value
+ * @param param1
+ * @returns
+ */
+export function formatValue(value, { precision = config.precision } = {}) {
+    value = round(value);
+    // get rid of trailing zeros
+    return `${parseFloat(value.toPrecision(precision))}`;
+}
+/**
+ * Check if value is an "array"
+ * Returns `true` if value is either an array or a typed array
+ * Note: returns `false` for `ArrayBuffer` and `DataView` instances
+ * @note isTypedArray and isNumericArray are often more useful in TypeScript
+ */
 export function isArray(value) {
-  return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+    return Array.isArray(value) || (ArrayBuffer.isView(value) && !(value instanceof DataView));
 }
 export function clone(array) {
-  return 'clone' in array ? array.clone() : array.slice();
+    return 'clone' in array ? array.clone() : array.slice();
 }
 export function toRadians(degrees) {
-  return radians(degrees);
+    return radians(degrees);
 }
 export function toDegrees(radians) {
-  return degrees(radians);
+    return degrees(radians);
 }
 export function radians(degrees, result) {
-  return map(degrees, degrees => degrees * DEGREES_TO_RADIANS, result);
+    return map(degrees, (degrees) => degrees * DEGREES_TO_RADIANS, result);
 }
 export function degrees(radians, result) {
-  return map(radians, radians => radians * RADIANS_TO_DEGREES, result);
+    return map(radians, (radians) => radians * RADIANS_TO_DEGREES, result);
 }
+/**
+ * "GLSL equivalent" of `Math.sin`: Works on single values and vectors
+ * @deprecated
+ */
 export function sin(radians, result) {
-  return map(radians, angle => Math.sin(angle), result);
+    return map(radians, (angle) => Math.sin(angle), result);
 }
+/**
+ * "GLSL equivalent" of `Math.cos`: Works on single values and vectors
+ * @deprecated
+ */
 export function cos(radians, result) {
-  return map(radians, angle => Math.cos(angle), result);
+    return map(radians, (angle) => Math.cos(angle), result);
 }
+/**
+ * "GLSL equivalent" of `Math.tan`: Works on single values and vectors
+ * @deprecated
+ */
 export function tan(radians, result) {
-  return map(radians, angle => Math.tan(angle), result);
+    return map(radians, (angle) => Math.tan(angle), result);
 }
+/**
+ * "GLSL equivalent" of `Math.asin`: Works on single values and vectors
+ * @deprecated
+ */
 export function asin(radians, result) {
-  return map(radians, angle => Math.asin(angle), result);
+    return map(radians, (angle) => Math.asin(angle), result);
 }
+/**
+ * "GLSL equivalent" of `Math.acos`: Works on single values and vectors
+ * @deprecated
+ */
 export function acos(radians, result) {
-  return map(radians, angle => Math.acos(angle), result);
+    return map(radians, (angle) => Math.acos(angle), result);
 }
+/**
+ * "GLSL equivalent" of `Math.atan`: Works on single values and vectors
+ * @deprecated
+ */
 export function atan(radians, result) {
-  return map(radians, angle => Math.atan(angle), result);
+    return map(radians, (angle) => Math.atan(angle), result);
 }
 export function clamp(value, min, max) {
-  return map(value, value => Math.max(min, Math.min(max, value)));
+    return map(value, (value) => Math.max(min, Math.min(max, value)));
 }
 export function lerp(a, b, t) {
-  if (isArray(a)) {
-    return a.map((ai, i) => lerp(ai, b[i], t));
-  }
-
-  return t * b + (1 - t) * a;
-}
+    if (isArray(a)) {
+        return a.map((ai, i) => lerp(ai, b[i], t));
+    }
+    return t * b + (1 - t) * a;
+}
+/* eslint-disable */
+/**
+ * Compares any two math objects, using `equals` method if available.
+ * @param a
+ * @param b
+ * @param epsilon
+ * @returns
+ */
 export function equals(a, b, epsilon) {
-  const oldEpsilon = config.EPSILON;
-
-  if (epsilon) {
-    config.EPSILON = epsilon;
-  }
-
-  try {
-    if (a === b) {
-      return true;
+    const oldEpsilon = config.EPSILON;
+    if (epsilon) {
+        config.EPSILON = epsilon;
     }
-
-    if (isArray(a) && isArray(b)) {
-      if (a.length !== b.length) {
-        return false;
-      }
-
-      for (let i = 0; i < a.length; ++i) {
-        if (!equals(a[i], b[i])) {
-          return false;
+    try {
+        if (a === b) {
+            return true;
         }
-      }
-
-      return true;
-    }
-
-    if (a && a.equals) {
-      return a.equals(b);
-    }
-
-    if (b && b.equals) {
-      return b.equals(a);
+        if (isArray(a) && isArray(b)) {
+            if (a.length !== b.length) {
+                return false;
+            }
+            for (let i = 0; i < a.length; ++i) {
+                // eslint-disable-next-line max-depth
+                if (!equals(a[i], b[i])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (a && a.equals) {
+            return a.equals(b);
+        }
+        if (b && b.equals) {
+            return b.equals(a);
+        }
+        if (typeof a === 'number' && typeof b === 'number') {
+            return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
+        }
+        return false;
     }
-
-    if (typeof a === 'number' && typeof b === 'number') {
-      return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
+    finally {
+        config.EPSILON = oldEpsilon;
     }
-
-    return false;
-  } finally {
-    config.EPSILON = oldEpsilon;
-  }
 }
 export function exactEquals(a, b) {
-  if (a === b) {
-    return true;
-  }
-
-  if (a && typeof a === 'object' && b && typeof b === 'object') {
-    if (a.constructor !== b.constructor) {
-      return false;
-    }
-
-    if (a.exactEquals) {
-      return a.exactEquals(b);
+    if (a === b) {
+        return true;
     }
-  }
-
-  if (isArray(a) && isArray(b)) {
-    if (a.length !== b.length) {
-      return false;
+    if (a && typeof a === 'object' && b && typeof b === 'object') {
+        if (a.constructor !== b.constructor) {
+            return false;
+        }
+        if (a.exactEquals) {
+            return a.exactEquals(b);
+        }
     }
-
-    for (let i = 0; i < a.length; ++i) {
-      if (!exactEquals(a[i], b[i])) {
-        return false;
-      }
+    if (isArray(a) && isArray(b)) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; ++i) {
+            if (!exactEquals(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
     }
-
-    return true;
-  }
-
-  return false;
+    return false;
 }
+/* eslint-enable */
 export function withEpsilon(epsilon, func) {
-  const oldPrecision = config.EPSILON;
-  config.EPSILON = epsilon;
-  let value;
-
-  try {
-    value = func();
-  } finally {
-    config.EPSILON = oldPrecision;
-  }
-
-  return value;
-}
-
+    const oldPrecision = config.EPSILON;
+    config.EPSILON = epsilon;
+    let value;
+    try {
+        value = func();
+    }
+    finally {
+        config.EPSILON = oldPrecision;
+    }
+    return value;
+}
+// HELPERS
 function round(value) {
-  return Math.round(value / config.EPSILON) * config.EPSILON;
+    return Math.round(value / config.EPSILON) * config.EPSILON;
 }
-
+// If the array has a clone function, calls it, otherwise returns a copy
 function duplicateArray(array) {
-  return array.clone ? array.clone() : new Array(array.length);
+    // @ts-expect-error We check for math.gl class methods
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    return array.clone ? array.clone() : new Array(array.length);
 }
-
+// If the argument value is an array, applies the func element wise,
+// otherwise applies func to the argument value
 function map(value, func, result) {
-  if (isArray(value)) {
-    const array = value;
-    result = result || duplicateArray(array);
-
-    for (let i = 0; i < result.length && i < array.length; ++i) {
-      const val = typeof value === 'number' ? value : value[i];
-      result[i] = func(val, i, result);
+    if (isArray(value)) {
+        const array = value;
+        result = result || duplicateArray(array);
+        for (let i = 0; i < result.length && i < array.length; ++i) {
+            const val = typeof value === 'number' ? value : value[i];
+            result[i] = func(val, i, result);
+        }
+        return result;
     }
-
-    return result;
-  }
-
-  return func(value);
+    return func(value);
 }
-//# sourceMappingURL=common.js.map

package/dist/lib/gl-matrix-extras.d.ts

@@ -4,4 +4,3 @@ export declare function vec3_transformMat4AsVector<T extends NumericArray>(out:
 export declare function vec3_transformMat2<T extends NumericArray>(out: T, a: Readonly<NumericArray>, m: Readonly<NumericArray>): T;
 export declare function vec4_transformMat2<T extends NumericArray>(out: T, a: Readonly<NumericArray>, m: Readonly<NumericArray>): T;
 export declare function vec4_transformMat3<T extends NumericArray>(out: T, a: Readonly<NumericArray>, m: Readonly<NumericArray>): T;
-//# sourceMappingURL=gl-matrix-extras.d.ts.map

package/dist/lib/gl-matrix-extras.js

@@ -1,46 +1,49 @@
+// vec2 additions
 export function vec2_transformMat4AsVector(out, a, m) {
-  const x = a[0];
-  const y = a[1];
-  const w = m[3] * x + m[7] * y || 1.0;
-  out[0] = (m[0] * x + m[4] * y) / w;
-  out[1] = (m[1] * x + m[5] * y) / w;
-  return out;
+    const x = a[0];
+    const y = a[1];
+    const w = m[3] * x + m[7] * y || 1.0;
+    out[0] = (m[0] * x + m[4] * y) / w;
+    out[1] = (m[1] * x + m[5] * y) / w;
+    return out;
 }
+// vec3 additions
+// Transform as vector, only uses 3x3 minor matrix
 export function vec3_transformMat4AsVector(out, a, m) {
-  const x = a[0];
-  const y = a[1];
-  const z = a[2];
-  const w = m[3] * x + m[7] * y + m[11] * z || 1.0;
-  out[0] = (m[0] * x + m[4] * y + m[8] * z) / w;
-  out[1] = (m[1] * x + m[5] * y + m[9] * z) / w;
-  out[2] = (m[2] * x + m[6] * y + m[10] * z) / w;
-  return out;
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    const w = m[3] * x + m[7] * y + m[11] * z || 1.0;
+    out[0] = (m[0] * x + m[4] * y + m[8] * z) / w;
+    out[1] = (m[1] * x + m[5] * y + m[9] * z) / w;
+    out[2] = (m[2] * x + m[6] * y + m[10] * z) / w;
+    return out;
 }
 export function vec3_transformMat2(out, a, m) {
-  const x = a[0];
-  const y = a[1];
-  out[0] = m[0] * x + m[2] * y;
-  out[1] = m[1] * x + m[3] * y;
-  out[2] = a[2];
-  return out;
+    const x = a[0];
+    const y = a[1];
+    out[0] = m[0] * x + m[2] * y;
+    out[1] = m[1] * x + m[3] * y;
+    out[2] = a[2];
+    return out;
 }
+// vec4 additions
 export function vec4_transformMat2(out, a, m) {
-  const x = a[0];
-  const y = a[1];
-  out[0] = m[0] * x + m[2] * y;
-  out[1] = m[1] * x + m[3] * y;
-  out[2] = a[2];
-  out[3] = a[3];
-  return out;
+    const x = a[0];
+    const y = a[1];
+    out[0] = m[0] * x + m[2] * y;
+    out[1] = m[1] * x + m[3] * y;
+    out[2] = a[2];
+    out[3] = a[3];
+    return out;
 }
 export function vec4_transformMat3(out, a, m) {
-  const x = a[0];
-  const y = a[1];
-  const z = a[2];
-  out[0] = m[0] * x + m[3] * y + m[6] * z;
-  out[1] = m[1] * x + m[4] * y + m[7] * z;
-  out[2] = m[2] * x + m[5] * y + m[8] * z;
-  out[3] = a[3];
-  return out;
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    out[0] = m[0] * x + m[3] * y + m[6] * z;
+    out[1] = m[1] * x + m[4] * y + m[7] * z;
+    out[2] = m[2] * x + m[5] * y + m[8] * z;
+    out[3] = a[3];
+    return out;
 }
-//# sourceMappingURL=gl-matrix-extras.js.map

package/dist/lib/math-utils.d.ts

@@ -22,4 +22,3 @@ export declare const PI_OVER_TWO: number;
 export declare const PI_OVER_FOUR: number;
 export declare const PI_OVER_SIX: number;
 export declare const TWO_PI: number;
-//# sourceMappingURL=math-utils.d.ts.map

package/dist/lib/math-utils.js

@@ -1,3 +1,5 @@
+// NOTE: Added to make Cesium-derived test cases work
+// TODO: Determine if/how to keep
 export const EPSILON1 = 1e-1;
 export const EPSILON2 = 1e-2;
 export const EPSILON3 = 1e-3;
@@ -22,4 +24,3 @@ export const PI_OVER_TWO = Math.PI / 2;
 export const PI_OVER_FOUR = Math.PI / 4;
 export const PI_OVER_SIX = Math.PI / 6;
 export const TWO_PI = Math.PI * 2;
-//# sourceMappingURL=math-utils.js.map

package/dist/lib/validators.d.ts

@@ -3,4 +3,3 @@ export declare function validateVector(v: NumberArray, length: number): boolean;
 export declare function checkNumber(value: unknown): number;
 export declare function checkVector<T extends NumberArray>(v: T, length: number, callerName?: string): T;
 export declare function deprecated(method: string, version: string): void;
-//# sourceMappingURL=validators.d.ts.map

package/dist/lib/validators.js

@@ -1,36 +1,33 @@
 import { config } from "./common.js";
 export function validateVector(v, length) {
-  if (v.length !== length) {
-    return false;
-  }
-
-  for (let i = 0; i < v.length; ++i) {
-    if (!Number.isFinite(v[i])) {
-      return false;
+    if (v.length !== length) {
+        return false;
     }
-  }
-
-  return true;
+    // Could be arguments "array" (v.every not availasble)
+    for (let i = 0; i < v.length; ++i) {
+        if (!Number.isFinite(v[i])) {
+            return false;
+        }
+    }
+    return true;
 }
 export function checkNumber(value) {
-  if (!Number.isFinite(value)) {
-    throw new Error("Invalid number ".concat(JSON.stringify(value)));
-  }
-
-  return value;
+    if (!Number.isFinite(value)) {
+        throw new Error(`Invalid number ${JSON.stringify(value)}`);
+    }
+    return value;
 }
 export function checkVector(v, length, callerName = '') {
-  if (config.debug && !validateVector(v, length)) {
-    throw new Error("math.gl: ".concat(callerName, " some fields set to invalid numbers'"));
-  }
-
-  return v;
+    if (config.debug && !validateVector(v, length)) {
+        throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
+    }
+    return v;
 }
 const map = {};
 export function deprecated(method, version) {
-  if (!map[method]) {
-    map[method] = true;
-    console.warn("".concat(method, " has been removed in version ").concat(version, ", see upgrade guide for more information"));
-  }
+    if (!map[method]) {
+        map[method] = true;
+        // eslint-disable-next-line
+        console.warn(`${method} has been removed in version ${version}, see upgrade guide for more information`);
+    }
 }
-//# sourceMappingURL=validators.js.map