@math.gl/core 3.5.6 → 3.6.0-alpha.1

package/dist/lib/common.d.ts

@@ -0,0 +1,90 @@
+import { NumericArray } from '@math.gl/types';
+export declare type ConfigurationOptions = {
+    EPSILON?: number;
+    debug?: boolean;
+    precision?: number;
+    printTypes?: boolean;
+    printDegrees?: boolean;
+    printRowMajor?: boolean;
+    _cartographicRadians?: boolean;
+};
+export declare const config: ConfigurationOptions;
+export declare function configure(options?: ConfigurationOptions): ConfigurationOptions;
+/**
+ * Formats a value into a string
+ * @param value
+ * @param param1
+ * @returns
+ */
+export declare function formatValue(value: number, { precision }?: ConfigurationOptions): string;
+/**
+ * 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
+ */
+export declare function isArray(value: unknown): boolean;
+export declare function clone(array: NumericArray): NumericArray;
+export declare function toRadians(degrees: number): number;
+export declare function toRadians(degrees: NumericArray): NumericArray;
+export declare function toDegrees(degrees: number): number;
+export declare function toDegrees(degrees: NumericArray): NumericArray;
+/**
+ * "GLSL equivalent" radians: Works on single values and vectors
+ */
+export declare function radians(degrees: number): number;
+export declare function radians(degrees: NumericArray, result?: NumericArray): NumericArray;
+/**
+ * "GLSL equivalent" degrees: Works on single values and vectors
+ */
+export declare function degrees(radians: number): number;
+export declare function degrees(radians: NumericArray, result?: NumericArray): NumericArray;
+/**
+ * "GLSL equivalent" of `Math.sin`: Works on single values and vectors
+ * @deprecated
+ */
+export declare function sin(radians: any, result?: any): any;
+/**
+ * "GLSL equivalent" of `Math.cos`: Works on single values and vectors
+ * @deprecated
+ */
+export declare function cos(radians: number | NumericArray, result?: any): any;
+/**
+ * "GLSL equivalent" of `Math.tan`: Works on single values and vectors
+ * @deprecated
+ */
+export declare function tan(radians: number | NumericArray, result?: any): any;
+/**
+ * "GLSL equivalent" of `Math.asin`: Works on single values and vectors
+ * @deprecated
+ */
+export declare function asin(radians: number | NumericArray): any;
+/**
+ * "GLSL equivalent" of `Math.acos`: Works on single values and vectors
+ * @deprecated
+ */
+export declare function acos(radians: number | NumericArray): any;
+/**
+ * "GLSL equivalent" of `Math.atan`: Works on single values and vectors
+ * @deprecated
+ */
+export declare function atan(radians: number | NumericArray): any;
+/**
+ * GLSL style value clamping: Works on single values and vectors
+ */
+export declare function clamp(value: number | NumericArray, min: number, max: number): any;
+/**
+ * Interpolate between two numbers or two arrays
+ */
+export declare function lerp(a: any, b: any, t: number): any;
+/**
+ * Compares any two math objects, using `equals` method if available.
+ * @param a
+ * @param b
+ * @param epsilon
+ * @returns
+ */
+export declare function equals(a: unknown, b: unknown, epsilon?: number): boolean;
+export declare function exactEquals(a: any, b: any): boolean;
+export declare function withEpsilon(epsilon: number, func: Function): any;
+//# sourceMappingURL=common.d.ts.map

package/dist/lib/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/lib/common.ts"],"names":[],"mappings":"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"}

package/dist/lib/common.js

@@ -0,0 +1,223 @@
+import assert from './assert';
+const RADIANS_TO_DEGREES = (1 / Math.PI) * 180;
+const DEGREES_TO_RADIANS = (1 / 180) * Math.PI;
+// TODO - remove
+/* eslint-disable no-shadow */
+export const config = {};
+config.EPSILON = 1e-12;
+config.debug = false;
+config.precision = 4;
+config.printTypes = false;
+config.printDegrees = false;
+config.printRowMajor = true;
+export function configure(options = {}) {
+    // Only copy existing keys
+    for (const key in options) {
+        assert(key in config);
+        config[key] = options[key];
+    }
+    return config;
+}
+/**
+ * Formats a value into a string
+ * @param value
+ * @param param1
+ * @returns
+ */
+export function formatValue(value, { precision = config.precision || 4 } = {}) {
+    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
+ */
+export function isArray(value) {
+    return Array.isArray(value) || (ArrayBuffer.isView(value) && !(value instanceof DataView));
+}
+export function clone(array) {
+    // @ts-expect-error We are speculatively calling clone
+    return 'clone' in array ? array.clone() : new Array(...array);
+}
+export function toRadians(degrees) {
+    return radians(degrees);
+}
+export function toDegrees(radians) {
+    return degrees(radians);
+}
+export function radians(degrees, result) {
+    return map(degrees, (degrees) => degrees * DEGREES_TO_RADIANS, result);
+}
+export function degrees(radians, 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);
+}
+/**
+ * "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);
+}
+/**
+ * "GLSL equivalent" of `Math.tan`: Works on single values and vectors
+ * @deprecated
+ */
+export function tan(radians, result) {
+    return map(radians, (angle) => Math.tan(angle));
+}
+/**
+ * "GLSL equivalent" of `Math.asin`: Works on single values and vectors
+ * @deprecated
+ */
+export function asin(radians) {
+    return map(radians, (angle) => Math.asin(angle));
+}
+/**
+ * "GLSL equivalent" of `Math.acos`: Works on single values and vectors
+ * @deprecated
+ */
+export function acos(radians) {
+    return map(radians, (angle) => Math.acos(angle));
+}
+/**
+ * "GLSL equivalent" of `Math.atan`: Works on single values and vectors
+ * @deprecated
+ */
+export function atan(radians) {
+    return map(radians, (angle) => Math.atan(angle));
+}
+/**
+ * GLSL style value clamping: Works on single values and vectors
+ */
+export function clamp(value, min, max) {
+    return map(value, (value) => Math.max(min, Math.min(max, value)));
+}
+/**
+ * Interpolate between two numbers or two arrays
+ */
+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;
+}
+/**
+ * Compares any two math objects, using `equals` method if available.
+ * @param a
+ * @param b
+ * @param epsilon
+ * @returns
+ */
+// eslint-disable-next-line complexity
+export function equals(a, b, epsilon) {
+    const oldEpsilon = config.EPSILON;
+    if (epsilon) {
+        config.EPSILON = epsilon;
+    }
+    try {
+        if (a === b) {
+            return true;
+        }
+        if (isArray(a) && isArray(b)) {
+            // @ts-expect-error isArray has checked
+            if (a.length !== b.length) {
+                return false;
+            }
+            // @ts-expect-error isArray has checked
+            for (let i = 0; i < a.length; ++i) {
+                // eslint-disable-next-line max-depth
+                if (!equals(a[i], b[i])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        // @ts-expect-error Dynamic testing
+        if (a && a.equals) {
+            // @ts-expect-error Dynamic testing
+            return a.equals(b);
+        }
+        // @ts-expect-error Dynamic testing
+        if (b && b.equals) {
+            // @ts-expect-error Dynamic testing
+            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;
+    }
+    finally {
+        config.EPSILON = oldEpsilon;
+    }
+}
+// eslint-disable-next-line complexity
+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 (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 false;
+}
+export function withEpsilon(epsilon, func) {
+    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;
+}
+// If the array has a clone function, calls it, otherwise returns a copy
+function duplicateArray(array) {
+    // @ts-expect-error We check for math.gl class methods
+    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) {
+            result[i] = func(value[i], i, result);
+        }
+        return result;
+    }
+    return func(value);
+}

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

@@ -0,0 +1,6 @@
+export declare function vec2_transformMat4AsVector(out: any, a: any, m: any): any;
+export declare function vec3_transformMat4AsVector(out: any, a: any, m: any): any;
+export declare function vec3_transformMat2(out: any, a: any, m: any): any;
+export declare function vec4_transformMat2(out: any, a: any, m: any): any;
+export declare function vec4_transformMat3(out: any, a: any, m: any): any;
+//# sourceMappingURL=gl-matrix-extras.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gl-matrix-extras.d.ts","sourceRoot":"","sources":["../../src/lib/gl-matrix-extras.ts"],"names":[],"mappings":"AAGA,wBAAgB,0BAA0B,CAAC,GAAG,KAAA,EAAE,CAAC,KAAA,EAAE,CAAC,KAAA,OAOnD;AAKD,wBAAgB,0BAA0B,CAAC,GAAG,KAAA,EAAE,CAAC,KAAA,EAAE,CAAC,KAAA,OASnD;AAED,wBAAgB,kBAAkB,CAAC,GAAG,KAAA,EAAE,CAAC,KAAA,EAAE,CAAC,KAAA,OAO3C;AAID,wBAAgB,kBAAkB,CAAC,GAAG,KAAA,EAAE,CAAC,KAAA,EAAE,CAAC,KAAA,OAQ3C;AAED,wBAAgB,kBAAkB,CAAC,GAAG,KAAA,EAAE,CAAC,KAAA,EAAE,CAAC,KAAA,OAS3C"}

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

@@ -0,0 +1,50 @@
+/* eslint-disable camelcase */
+// 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;
+}
+// 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;
+}
+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;
+}
+// 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;
+}
+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;
+}

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

@@ -0,0 +1,28 @@
+declare const _default: {
+    EPSILON1: number;
+    EPSILON2: number;
+    EPSILON3: number;
+    EPSILON4: number;
+    EPSILON5: number;
+    EPSILON6: number;
+    EPSILON7: number;
+    EPSILON8: number;
+    EPSILON9: number;
+    EPSILON10: number;
+    EPSILON11: number;
+    EPSILON12: number;
+    EPSILON13: number;
+    EPSILON14: number;
+    EPSILON15: number;
+    EPSILON16: number;
+    EPSILON17: number;
+    EPSILON18: number;
+    EPSILON19: number;
+    EPSILON20: number;
+    PI_OVER_TWO: number;
+    PI_OVER_FOUR: number;
+    PI_OVER_SIX: number;
+    TWO_PI: number;
+};
+export default _default;
+//# sourceMappingURL=math-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"math-utils.d.ts","sourceRoot":"","sources":["../../src/lib/math-utils.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,wBA2BE"}

package/dist/lib/math-utils.js

@@ -0,0 +1,28 @@
+// NOTE: Added to make Cesium-derived test cases work
+// TODO: Determine if/how to keep
+export default {
+    EPSILON1: 1e-1,
+    EPSILON2: 1e-2,
+    EPSILON3: 1e-3,
+    EPSILON4: 1e-4,
+    EPSILON5: 1e-5,
+    EPSILON6: 1e-6,
+    EPSILON7: 1e-7,
+    EPSILON8: 1e-8,
+    EPSILON9: 1e-9,
+    EPSILON10: 1e-10,
+    EPSILON11: 1e-11,
+    EPSILON12: 1e-12,
+    EPSILON13: 1e-13,
+    EPSILON14: 1e-14,
+    EPSILON15: 1e-15,
+    EPSILON16: 1e-16,
+    EPSILON17: 1e-17,
+    EPSILON18: 1e-18,
+    EPSILON19: 1e-19,
+    EPSILON20: 1e-20,
+    PI_OVER_TWO: Math.PI / 2,
+    PI_OVER_FOUR: Math.PI / 4,
+    PI_OVER_SIX: Math.PI / 6,
+    TWO_PI: Math.PI * 2
+};

package/dist/lib/validators.d.ts

@@ -0,0 +1,5 @@
+export declare function validateVector(v: any, length: any): boolean;
+export declare function checkNumber(value: any): any;
+export declare function checkVector(v: any, length: any, callerName?: string): any;
+export declare function deprecated(method: any, version: any): void;
+//# sourceMappingURL=validators.d.ts.map

package/dist/lib/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../src/lib/validators.ts"],"names":[],"mappings":"AAsBA,wBAAgB,cAAc,CAAC,CAAC,KAAA,EAAE,MAAM,KAAA,WAWvC;AAED,wBAAgB,WAAW,CAAC,KAAK,KAAA,OAKhC;AAED,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,MAAM,KAAA,EAAE,UAAU,SAAK,OAKrD;AAID,wBAAgB,UAAU,CAAC,MAAM,KAAA,EAAE,OAAO,KAAA,QAQzC"}

package/dist/lib/validators.js

@@ -0,0 +1,52 @@
+// 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.
+import { config } from './common';
+export function validateVector(v, length) {
+    if (v.length !== length) {
+        return false;
+    }
+    // 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 ${value}`);
+    }
+    return value;
+}
+export function checkVector(v, length, callerName = '') {
+    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;
+        // eslint-disable-next-line
+        console.warn(`${method} has been removed in version ${version}, see upgrade guide for more information`);
+    }
+}

package/package.json

@@ -5,7 +5,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.5.6",
+  "version": "3.6.0-alpha.1",
   "keywords": [
     "webgl",
     "javascript",
@@ -26,7 +26,7 @@
     "type": "git",
     "url": "https://github.com/uber-web/math.gl.git"
   },
-  "types": "src/index.d.ts",
+  "types": "src/index.ts",
   "main": "dist/es5/index.js",
   "module": "dist/esm/index.js",
   "files": [
@@ -38,7 +38,8 @@
   ],
   "dependencies": {
     "@babel/runtime": "^7.12.0",
+    "@math.gl/types": "3.6.0-alpha.1",
     "gl-matrix": "~3.3.0"
   },
-  "gitHead": "0e69c70ff2e6373fed84d303cbf8198a6972944f"
+  "gitHead": "45386981340895bf201c2ebb76257c9bbffd8ff6"
 }

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

@@ -1,4 +1,3 @@
-
 /** Base class for vectors and matrices */
 export default abstract class MathArray<DerivedType> extends Array<number> {
   // Defined by derived class

package/{dist/esm/index.d.ts → src/index.ts}

@@ -1,5 +1,7 @@
-// lib
-export * from './lib/common';
+// luma.gl, MIT license
+
+// types
+export type {TypedArray, NumericArray} from '@math.gl/types';
 
 // classes
 export {default as Vector2} from './classes/vector2';
@@ -9,44 +11,40 @@ export {default as Matrix3} from './classes/matrix3';
 export {default as Matrix4} from './classes/matrix4';
 export {default as Quaternion} from './classes/quaternion';
 
-// extras
-
-// export {checkNumber} from './lib/validators';
-export function assert(condition: boolean, message?: string): void;
-
 // experimental
 export {default as SphericalCoordinates} from './classes/spherical-coordinates';
 export {default as Pose} from './classes/pose';
 export {default as Euler} from './classes/euler';
 
-export const _MathUtils: {
-  EPSILON1: number;
-  EPSILON2: number;
-  EPSILON3: number;
-  EPSILON4: number;
-  EPSILON5: number;
-  EPSILON6: number;
-  EPSILON7: number;
-  EPSILON8: number;
-  EPSILON9: number;
-  EPSILON10: number;
-  EPSILON11: number;
-  EPSILON12: number;
-  EPSILON13: number;
-  EPSILON14: number;
-  EPSILON15: number;
-  EPSILON16: number;
-  EPSILON17: number;
-  EPSILON18: number;
-  EPSILON19: number;
-  EPSILON20: number;
-
-  PI_OVER_TWO: number;
-  PI_OVER_FOUR: number;
-  PI_OVER_SIX: number;
+export {default as _MathUtils} from './lib/math-utils';
 
-  TWO_PI: number;
-};
+// lib
+export {default as assert} from './lib/assert';
+
+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';
 
 // DEPRECATED
 export {default as _SphericalCoordinates} from './classes/spherical-coordinates';

package/src/lib/{assert.js → assert.ts}

@@ -1,4 +1,4 @@
-export default function assert(condition, message) {
+export default function assert(condition: unknown, message?: string): void {
   if (!condition) {
     throw new Error(`math.gl assertion ${message}`);
   }