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

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.3",
+  "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",
-    "gl-matrix": "^3.0.0"
+    "@math.gl/types": "3.6.0-alpha.1",
+    "gl-matrix": "~3.3.0"
   },
-  "gitHead": "b9183c9ec46dd309a601e1de7beb90a18a3e0fea"
+  "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/src/classes/euler.js

@@ -346,7 +346,7 @@ export default class Euler extends MathArray {
   // TODO - move to Quaternion
   getQuaternion() {
     const q = new Quaternion();
-    switch (this[4]) {
+    switch (this[3]) {
       case Euler.XYZ:
         return q.rotateX(this[0]).rotateY(this[1]).rotateZ(this[2]);
       case Euler.YXZ:

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}`);
   }

package/src/lib/common.ts

@@ -0,0 +1,283 @@
+// Copyright (c) 2017 Uber Technologies, Inc.
+// MIT License
+import {NumericArray} from '@math.gl/types';
+import assert from './assert';
+
+export type ConfigurationOptions = {
+  EPSILON?: number;
+  debug?: boolean;
+  precision?: number;
+  printTypes?: boolean;
+  printDegrees?: boolean;
+  printRowMajor?: boolean;
+  _cartographicRadians?: boolean;
+};
+
+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: ConfigurationOptions = {};
+
+config.EPSILON = 1e-12;
+config.debug = false;
+config.precision = 4;
+config.printTypes = false;
+config.printDegrees = false;
+config.printRowMajor = true;
+
+export function configure(options: ConfigurationOptions = {}): ConfigurationOptions {
+  // 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: number,
+  {precision = config.precision || 4}: ConfigurationOptions = {}
+): string {
+  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: unknown): boolean {
+  return Array.isArray(value) || (ArrayBuffer.isView(value) && !(value instanceof DataView));
+}
+
+export function clone(array: NumericArray): NumericArray {
+  // @ts-expect-error We are speculatively calling clone
+  return 'clone' in array ? array.clone() : new Array(...array);
+}
+
+export function toRadians(degrees: number): number;
+export function toRadians(degrees: NumericArray): NumericArray;
+
+export function toRadians(degrees): any {
+  return radians(degrees);
+}
+
+export function toDegrees(degrees: number): number;
+export function toDegrees(degrees: NumericArray): NumericArray;
+
+export function toDegrees(radians): any {
+  return degrees(radians);
+}
+
+// GLSL math function equivalents - Works on both single values and vectors
+
+/**
+ * "GLSL equivalent" radians: Works on single values and vectors
+ */
+export function radians(degrees: number): number;
+export function radians(degrees: NumericArray, result?: NumericArray): NumericArray;
+
+export function radians(degrees, result?) {
+  return map(degrees, (degrees) => degrees * DEGREES_TO_RADIANS, result);
+}
+
+/**
+ * "GLSL equivalent" degrees: Works on single values and vectors
+ */
+export function degrees(radians: number): number;
+export function degrees(radians: NumericArray, result?: NumericArray): NumericArray;
+
+export function degrees(radians: number | NumericArray, 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: any, result?: any): any {
+  return map(radians, (angle) => Math.sin(angle), result);
+}
+
+/**
+ * "GLSL equivalent" of `Math.cos`: Works on single values and vectors
+ * @deprecated
+ */
+export function cos(radians: number | NumericArray, 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: number | NumericArray, result?) {
+  return map(radians, (angle) => Math.tan(angle));
+}
+
+/**
+ * "GLSL equivalent" of `Math.asin`: Works on single values and vectors
+ * @deprecated
+ */
+export function asin(radians: number | NumericArray) {
+  return map(radians, (angle) => Math.asin(angle));
+}
+
+/**
+ * "GLSL equivalent" of `Math.acos`: Works on single values and vectors
+ * @deprecated
+ */
+export function acos(radians: number | NumericArray) {
+  return map(radians, (angle) => Math.acos(angle));
+}
+
+/**
+ * "GLSL equivalent" of `Math.atan`: Works on single values and vectors
+ * @deprecated
+ */
+export function atan(radians: number | NumericArray) {
+  return map(radians, (angle) => Math.atan(angle));
+}
+
+/**
+ * GLSL style value clamping: Works on single values and vectors
+ */
+export function clamp(value: number | NumericArray, min: number, max: number) {
+  return map(value, (value) => Math.max(min, Math.min(max, value)));
+}
+
+/**
+ * Interpolate between two numbers or two arrays
+ */
+export function lerp(a, b, t: number) {
+  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: unknown, b: unknown, epsilon?: number): boolean {
+  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): boolean {
+  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: number, func: Function): any {
+  const oldPrecision = config.EPSILON;
+  config.EPSILON = epsilon;
+  let value;
+  try {
+    value = func();
+  } finally {
+    config.EPSILON = oldPrecision;
+  }
+  return value;
+}
+
+// HELPERS
+
+function round(value: number): number {
+  return Math.round(value / config.EPSILON) * config.EPSILON;
+}
+
+// If the array has a clone function, calls it, otherwise returns a copy
+function duplicateArray(array: NumericArray): NumericArray {
+  // @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: number | NumericArray, func: Function, result?) {
+  if (isArray(value)) {
+    const array = value as NumericArray;
+    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/es5/addons/polygon.d.ts

@@ -1,17 +0,0 @@
-import {NumberArray} from '@math.gl/core/';
-
-type SegmentVisitor = (p1: NumberArray, p2: NumberArray, i1: number, i2: number) => void;
-
-export default class Polygon {
-  constructor(
-    points: NumberArray | NumberArray[],
-    options?: {start?: number; end?: number; size?: number; isClosed?: boolean}
-  );
-
-  // https://en.wikipedia.org/wiki/Shoelace_formula
-  getSignedArea(): number;
-  getArea(): number;
-  getWindingDirection(): number;
-  forEachSegment(visitor: SegmentVisitor): void;
-  modifyWindingDirection(direction: number): boolean;
-}

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

@@ -1,56 +0,0 @@
-
-/** Base class for vectors and matrices */
-export default abstract class MathArray<DerivedType> extends Array<number> {
-  // Defined by derived class
-  abstract get ELEMENTS(): number;
-
-  clone(): DerivedType;
-
-  // TODO - define more sophisticated object type per class?
-  from(array: readonly number[]): DerivedType;
-  from(object: object): DerivedType;
-
-  fromArray(array: readonly number[], offset?: number): DerivedType;
-  // todo
-  to(arrayOrObject): any;
-  toTarget(target): any;
-
-  toArray(array?: number[], offset?: number): number[];
-  toFloat32Array(): Float32Array;
-  toString(): string;
-  formatString(opts: object): string;
-  equals(array: readonly number[]): boolean;
-  exactEquals(array: readonly number[]): boolean;
-
-  // Modifiers
-
-  negate(): DerivedType;
-  lerp(a: readonly number[], b: readonly number[], t: number): DerivedType;
-
-  min(vector: readonly number[]): DerivedType;
-  max(vector: readonly number[]): DerivedType;
-
-  clamp(minVector: readonly number[], maxVector: readonly number[]): DerivedType;
-
-  add(...vectors): DerivedType;
-  subtract(...vectors): DerivedType;
-
-  scale(scale): DerivedType;
-
-  // three.js compatibility
-
-  sub(a): DerivedType;
-  setScalar(a): DerivedType;
-  addScalar(a): DerivedType;
-  subScalar(a): DerivedType;
-  multiplyScalar(scalar): DerivedType;
-  divideScalar(a): DerivedType;
-  clampScalar(min, max): DerivedType;
-  elements: number[];
-
-  // Cesium compatibility
-  multiplyByScalar(scalar): DerivedType;
-
-  // private
-  check(): DerivedType;
-}

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

@@ -1,15 +0,0 @@
-import MathArray from './math-array';
-
-export default abstract class Matrix<MatrixType> extends MathArray<MatrixType> {
-  abstract get RANK(): number;
-
-  toString(): string;
-
-  getElementIndex(row: number, col: number): number;
-  // By default assumes row major indices
-  getElement(row: number, col: number);
-  // By default assumes row major indices
-  setElement(row: number, col: number, value: number);
-  getColumn(columnIndex: number, result?: number[]);
-  setColumn(columnIndex: number, columnVector: number[]);
-}

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

@@ -1,45 +0,0 @@
-import MathArray from './math-array';
-
-/** Base class for vectors */
-export default abstract class Vector<VectorType> extends MathArray<VectorType> {
-  // VIRTUAL METHODS
-  // copy(vector) {
-
-  // ACCESSORS
-
-  x: number;
-  y: number;
-
-  // NOTE: `length` is a reserved word for Arrays, so we can't use `v.length()`
-  len(): number;
-  magnitude(): number;
-  lengthSquared(): number;
-  magnitudeSquared(): number;
-
-  distance(mathArray): number;
-
-  distanceSquared(mathArray): number;
-
-  dot(mathArray): number;
-  // MODIFIERS
-
-  normalize(): VectorType;
-
-  multiply(...vectors): VectorType;
-
-  divide(...vectors): VectorType;
-
-  // THREE.js compatibility
-  lengthSq(): number;
-  distanceTo(vector: VectorType): number;
-  distanceToSquared(vector): number;
-
-  getComponent(i): number;
-  setComponent(i, value): number;
-
-  addVectors(a: VectorType, b: VectorType): VectorType;
-  subVectors(a: VectorType, b: VectorType): VectorType;
-  multiplyVectors(a: VectorType, b: VectorType): VectorType;
-
-  addScaledVector(a: VectorType, b: VectorType): VectorType;
-}