@math.gl/geospatial 3.6.3 → 4.0.0-alpha.2

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { default as Ellipsoid } from './ellipsoid/ellipsoid';
+export { Ellipsoid } from './ellipsoid/ellipsoid';
 export { isWGS84 } from './type-utils';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAC,OAAO,EAAC,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAC,OAAO,EAAC,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { Ellipsoid } from "./ellipsoid/ellipsoid.js";
+export { isWGS84 } from "./type-utils.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":["Ellipsoid","isWGS84"],"mappings":"SAAQA,S;SACAC,O","sourcesContent":["export {Ellipsoid} from './ellipsoid/ellipsoid';\nexport {isWGS84} from './type-utils';\n"],"file":"index.js"}

package/dist/type-utils.d.ts

@@ -10,12 +10,12 @@ declare type XYZObject = {
     z: number;
 };
 declare type Cartographic = LngLatHeightObject | XYZObject | NumericArray;
-export declare function fromCartographic(cartographic: Cartographic): number[];
-export declare function fromCartographic<NumArrayT>(cartographic: Cartographic, result: NumArrayT, map?: (x: number) => number): NumArrayT;
-export declare function fromCartographicToRadians(cartographic: Cartographic, result?: number[]): number[];
-export declare function fromCartographicToRadians<TArray>(cartographic: Cartographic, result: TArray): TArray;
-export declare function fromCartographicToDegrees(cartographic: Cartographic, result?: number[]): number[];
-export declare function fromCartographicToDegrees<TArray>(cartographic: Cartographic, result: TArray): TArray;
+export declare function fromCartographic(cartographic: Readonly<Cartographic>): number[];
+export declare function fromCartographic<NumArrayT>(cartographic: Readonly<Cartographic>, result: NumArrayT, map?: (x: number) => number): NumArrayT;
+export declare function fromCartographicToRadians(cartographic: Readonly<Cartographic>, result?: number[]): number[];
+export declare function fromCartographicToRadians<TArray>(cartographic: Readonly<Cartographic>, result: TArray): TArray;
+export declare function fromCartographicToDegrees(cartographic: Readonly<Cartographic>, result?: number[]): number[];
+export declare function fromCartographicToDegrees<TArray>(cartographic: Readonly<Cartographic>, result: TArray): TArray;
 export declare function toCartographic<T extends Cartographic>(vector: Readonly<NumericArray>, cartographic: T, map?: (x: number) => number): T;
 export declare function toCartographicFromRadians<T extends Cartographic>(vector: Readonly<NumericArray>, cartographic: T): T;
 export declare function toCartographicFromDegrees<T extends Cartographic>(vector: Readonly<NumericArray>, cartographic: T): T;

package/dist/type-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"type-utils.d.ts","sourceRoot":"","sources":["../src/type-utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAIhD,aAAK,kBAAkB,GAAG;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,aAAK,SAAS,GAAG;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,aAAK,YAAY,GAAG,kBAAkB,GAAG,SAAS,GAAG,YAAY,CAAC;AAQlE,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAC;AACvE,wBAAgB,gBAAgB,CAAC,SAAS,EACxC,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,SAAS,EACjB,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,GAC1B,SAAS,CAAC;AAsBb,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;AACnG,wBAAgB,yBAAyB,CAAC,MAAM,EAC9C,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,MAAM,GACb,MAAM,CAAC;AAQV,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;AACnG,wBAAgB,yBAAyB,CAAC,MAAM,EAC9C,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,MAAM,GACb,MAAM,CAAC;AAQV,wBAAgB,cAAc,CAAC,CAAC,SAAS,YAAY,EACnD,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,EAC9B,YAAY,EAAE,CAAC,EACf,GAAG,GAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAiB,GACpC,CAAC,CAeH;AAED,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,YAAY,EAC9D,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,EAC9B,YAAY,EAAE,CAAC,GACd,CAAC,CAEH;AAED,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,YAAY,EAC9D,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,EAC9B,YAAY,EAAE,CAAC,GACd,CAAC,CAEH;AAGD,wBAAgB,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,OAAO,CAU/D"}
+{"version":3,"file":"type-utils.d.ts","sourceRoot":"","sources":["../src/type-utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAIhD,aAAK,kBAAkB,GAAG;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,aAAK,SAAS,GAAG;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,aAAK,YAAY,GAAG,kBAAkB,GAAG,SAAS,GAAG,YAAY,CAAC;AAQlE,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,MAAM,EAAE,CAAC;AACjF,wBAAgB,gBAAgB,CAAC,SAAS,EACxC,YAAY,EAAE,QAAQ,CAAC,YAAY,CAAC,EACpC,MAAM,EAAE,SAAS,EACjB,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,GAC1B,SAAS,CAAC;AAsBb,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,QAAQ,CAAC,YAAY,CAAC,EACpC,MAAM,CAAC,EAAE,MAAM,EAAE,GAChB,MAAM,EAAE,CAAC;AACZ,wBAAgB,yBAAyB,CAAC,MAAM,EAC9C,YAAY,EAAE,QAAQ,CAAC,YAAY,CAAC,EACpC,MAAM,EAAE,MAAM,GACb,MAAM,CAAC;AAQV,wBAAgB,yBAAyB,CACvC,YAAY,EAAE,QAAQ,CAAC,YAAY,CAAC,EACpC,MAAM,CAAC,EAAE,MAAM,EAAE,GAChB,MAAM,EAAE,CAAC;AACZ,wBAAgB,yBAAyB,CAAC,MAAM,EAC9C,YAAY,EAAE,QAAQ,CAAC,YAAY,CAAC,EACpC,MAAM,EAAE,MAAM,GACb,MAAM,CAAC;AAQV,wBAAgB,cAAc,CAAC,CAAC,SAAS,YAAY,EACnD,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,EAC9B,YAAY,EAAE,CAAC,EACf,GAAG,GAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAiB,GACpC,CAAC,CAeH;AAED,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,YAAY,EAC9D,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,EAC9B,YAAY,EAAE,CAAC,GACd,CAAC,CAEH;AAED,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,YAAY,EAC9D,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,EAC9B,YAAY,EAAE,CAAC,GACd,CAAC,CAEH;AAGD,wBAAgB,OAAO,CAAC,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,OAAO,CAU/D"}

package/dist/{esm/type-utils.js → type-utils.js}

@@ -1,5 +1,5 @@
 import { Vector3, toRadians, toDegrees, config } from '@math.gl/core';
-import { WGS84_CONSTANTS } from './constants';
+import { WGS84_CONSTANTS } from "./constants.js";
 
 function identity(x) {
   return x;

package/dist/type-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/type-utils.ts"],"names":["Vector3","toRadians","toDegrees","config","WGS84_CONSTANTS","identity","x","scratchVector","fromCartographic","cartographic","result","map","longitude","latitude","height","y","z","fromCartographicToRadians","vector","_cartographicRadians","fromCartographicToDegrees","toCartographic","toCartographicFromRadians","toCartographicFromDegrees","isWGS84","from","oneOverRadiiSquared","centerToleranceSquared","x2","y2","z2","Math","abs"],"mappings":"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","sourcesContent":["// This file is derived from the Cesium math library under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport type {NumericArray} from '@math.gl/core';\nimport {Vector3, toRadians, toDegrees, config} from '@math.gl/core';\nimport {WGS84_CONSTANTS} from './constants';\n\ntype LngLatHeightObject = {\n  longitude: number;\n  latitude: number;\n  height: number;\n};\n\ntype XYZObject = {\n  x: number;\n  y: number;\n  z: number;\n};\n\ntype Cartographic = LngLatHeightObject | XYZObject | NumericArray;\n\nfunction identity(x: number): number {\n  return x;\n}\n\nconst scratchVector = new Vector3();\n\nexport function fromCartographic(cartographic: Readonly<Cartographic>): number[];\nexport function fromCartographic<NumArrayT>(\n  cartographic: Readonly<Cartographic>,\n  result: NumArrayT,\n  map?: (x: number) => number\n): NumArrayT;\nexport function fromCartographic(\n  cartographic: Readonly<Cartographic>,\n  result = [] as number[],\n  map = identity\n): number[] {\n  if ('longitude' in cartographic) {\n    result[0] = map(cartographic.longitude);\n    result[1] = map(cartographic.latitude);\n    result[2] = cartographic.height;\n  } else if ('x' in cartographic) {\n    result[0] = map(cartographic.x);\n    result[1] = map(cartographic.y);\n    result[2] = cartographic.z;\n  } else {\n    result[0] = map(cartographic[0]);\n    result[1] = map(cartographic[1]);\n    result[2] = cartographic[2];\n  }\n  return result;\n}\n\nexport function fromCartographicToRadians(\n  cartographic: Readonly<Cartographic>,\n  result?: number[]\n): number[];\nexport function fromCartographicToRadians<TArray>(\n  cartographic: Readonly<Cartographic>,\n  result: TArray\n): TArray;\nexport function fromCartographicToRadians(\n  cartographic: Readonly<Cartographic>,\n  vector = [] as number[]\n): number[] {\n  return fromCartographic(cartographic, vector, config._cartographicRadians ? identity : toRadians);\n}\n\nexport function fromCartographicToDegrees(\n  cartographic: Readonly<Cartographic>,\n  result?: number[]\n): number[];\nexport function fromCartographicToDegrees<TArray>(\n  cartographic: Readonly<Cartographic>,\n  result: TArray\n): TArray;\nexport function fromCartographicToDegrees(\n  cartographic: Readonly<Cartographic>,\n  vector = [] as number[]\n): number[] {\n  return fromCartographic(cartographic, vector, config._cartographicRadians ? toDegrees : identity);\n}\n\nexport function toCartographic<T extends Cartographic>(\n  vector: Readonly<NumericArray>,\n  cartographic: T,\n  map: (x: number) => number = identity\n): T {\n  if ('longitude' in cartographic) {\n    cartographic.longitude = map(vector[0]);\n    cartographic.latitude = map(vector[1]);\n    cartographic.height = vector[2];\n  } else if ('x' in cartographic) {\n    cartographic.x = map(vector[0]);\n    cartographic.y = map(vector[1]);\n    cartographic.z = vector[2];\n  } else {\n    cartographic[0] = map(vector[0]);\n    cartographic[1] = map(vector[1]);\n    cartographic[2] = vector[2];\n  }\n  return cartographic;\n}\n\nexport function toCartographicFromRadians<T extends Cartographic>(\n  vector: Readonly<NumericArray>,\n  cartographic: T\n): T {\n  return toCartographic(vector, cartographic, config._cartographicRadians ? identity : toDegrees);\n}\n\nexport function toCartographicFromDegrees<T extends Cartographic>(\n  vector: Readonly<NumericArray>,\n  cartographic: T\n): T {\n  return toCartographic(vector, cartographic, config._cartographicRadians ? toRadians : identity);\n}\n\n// Estimates if a vector is close to the surface of the WGS84 Ellipsoid\nexport function isWGS84(vector: Readonly<NumericArray>): boolean {\n  if (!vector) {\n    return false;\n  }\n  scratchVector.from(vector);\n  const {oneOverRadiiSquared, centerToleranceSquared} = WGS84_CONSTANTS;\n  const x2 = vector[0] * vector[0] * oneOverRadiiSquared[0];\n  const y2 = vector[1] * vector[1] * oneOverRadiiSquared[1];\n  const z2 = vector[2] * vector[2] * oneOverRadiiSquared[2];\n  return Math.abs(x2 + y2 + z2 - 1) < centerToleranceSquared;\n}\n\n/*\n\nexport function fromCartographic(cartographic: Cartographic, result?: number[]): number[];\nexport function fromCartographic(cartographic: Cartographic, result: TypedArray): TypedArray;\nexport function fromCartographicToRadians(cartographic: Cartographic, result?: number[]): number[];\nexport function fromCartographicToRadians(\n  cartographic: Cartographic,\n  result: TypedArray\n): TypedArray;\nexport function fromCartographicToDegrees(cartographic: Cartographic, result?: number[]): number[];\nexport function fromCartographicToDegrees(\n  cartographic: Cartographic,\n  result: TypedArray\n): TypedArray;\n\nexport function toCartographic(vector: number[] | TypedArray, result: Cartographic): number[];\nexport function toCartographicFromRadians(\n  vector: number[] | TypedArray,\n  result: Cartographic\n): number[];\nexport function toCartographicFromDegrees(\n  vector: number[] | TypedArray,\n  result: Cartographic\n): number[];\n\n// Estimates if a vector is close to the surface of the WGS84 Ellipsoid\nexport function isWGS84(vector: number[] | TypedArray): boolean;\n*/\n"],"file":"type-utils.js"}

package/package.json

@@ -2,10 +2,11 @@
   "name": "@math.gl/geospatial",
   "description": "Geospatial classes",
   "license": "MIT",
+  "type": "module",
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.6.3",
+  "version": "4.0.0-alpha.2",
   "keywords": [
     "webgl",
     "javascript",
@@ -24,16 +25,16 @@
     "url": "https://github.com/uber-web/math.gl.git"
   },
   "types": "dist/index.d.ts",
-  "main": "dist/es5/index.js",
-  "module": "dist/esm/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "files": [
     "dist",
     "src"
   ],
   "dependencies": {
     "@babel/runtime": "^7.12.0",
-    "@math.gl/core": "3.6.3",
-    "gl-matrix": "^3.4.0"
+    "@math.gl/core": "4.0.0-alpha.2",
+    "gl-matrix": "^3.4.3"
   },
-  "gitHead": "0efab394df9babad7ed93027c1003f30528b2090"
+  "gitHead": "2e693639e3cf898fee8e323c93efdd07be7c2ca7"
 }

package/src/ellipsoid/ellipsoid.ts

@@ -2,23 +2,16 @@
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 
 /* eslint-disable */
-import {
-  Vector3,
-  Matrix4,
-  toRadians,
-  toDegrees,
-  assert,
-  equals,
-  _MathUtils,
-  NumericArray
-} from '@math.gl/core';
+import {Vector3, Matrix4, assert, equals, _MathUtils, NumericArray} from '@math.gl/core';
+// @ts-ignore gl-matrix typings...
 import * as vec3 from 'gl-matrix/vec3';
 
 import {WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z} from '../constants';
 import {fromCartographicToRadians, toCartographicFromRadians} from '../type-utils';
 
-import scaleToGeodeticSurface from './helpers/scale-to-geodetic-surface';
-import localFrameToFixedFrame from './helpers/ellipsoid-transform';
+import type {AxisDirection} from './helpers/ellipsoid-transform';
+import {localFrameToFixedFrame} from './helpers/ellipsoid-transform';
+import {scaleToGeodeticSurface} from './helpers/scale-to-geodetic-surface';
 
 const scratchVector = new Vector3();
 const scratchNormal = new Vector3();
@@ -27,14 +20,12 @@ const scratchPosition = new Vector3();
 const scratchHeight = new Vector3();
 const scratchCartesian = new Vector3();
 
-let wgs84;
-
 /**
  * A quadratic surface defined in Cartesian coordinates by the equation
  * `(x / a)^2 + (y / b)^2 + (z / c)^2 = 1`.  Primarily used
  * to represent the shape of planetary bodies.
  */
-export default class Ellipsoid {
+export class Ellipsoid {
   /** An Ellipsoid instance initialized to the WGS84 standard. */
   static readonly WGS84: Ellipsoid = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
 
@@ -100,7 +91,7 @@ export default class Ellipsoid {
   cartographicToCartesian(cartographic: number[], result: Vector3): Vector3;
   cartographicToCartesian(cartographic: number[], result?: number[]): number[];
 
-  cartographicToCartesian(cartographic, result = [0, 0, 0]) {
+  cartographicToCartesian(cartographic: Readonly<NumericArray>, result = [0, 0, 0]) {
     const normal = scratchNormal;
     const k = scratchK;
 
@@ -120,10 +111,10 @@ export default class Ellipsoid {
 
   /** Converts the provided cartesian to cartographic (lng/lat/z) representation.
    * The cartesian is undefined at the center of the ellipsoid. */
-  cartesianToCartographic(cartesian: number[], result: Vector3): Vector3;
-  cartesianToCartographic(cartesian: number[], result?: number[]): number[];
+  cartesianToCartographic(cartesian: Readonly<NumericArray>, result: Vector3): Vector3;
+  cartesianToCartographic(cartesian: Readonly<NumericArray>, result?: number[]): number[];
 
-  cartesianToCartographic(cartesian, result = [0, 0, 0]) {
+  cartesianToCartographic(cartesian: Readonly<NumericArray>, result = [0, 0, 0]) {
     scratchCartesian.from(cartesian);
     const point = this.scaleToGeodeticSurface(scratchCartesian, scratchPosition);
 
@@ -145,10 +136,10 @@ export default class Ellipsoid {
 
   /** Computes a 4x4 transformation matrix from a reference frame with an east-north-up axes
    * centered at the provided origin to the provided ellipsoid's fixed reference frame. */
-  eastNorthUpToFixedFrame(origin: number[], result?: Matrix4): Matrix4;
-  eastNorthUpToFixedFrame(origin: number[], result: number[]): number[];
+  eastNorthUpToFixedFrame(origin: Readonly<NumericArray>, result?: Matrix4): Matrix4;
+  eastNorthUpToFixedFrame(origin: Readonly<NumericArray>, result: number[]): number[];
 
-  eastNorthUpToFixedFrame(origin, result = new Matrix4()) {
+  eastNorthUpToFixedFrame(origin: Readonly<NumericArray>, result = new Matrix4()) {
     return localFrameToFixedFrame(this, 'east', 'north', 'up', origin, result);
   }
 
@@ -156,23 +147,29 @@ export default class Ellipsoid {
    * the provided origin to the ellipsoid's fixed reference frame.
    */
   localFrameToFixedFrame(
-    firstAxis: string,
-    secondAxis: string,
-    thirdAxis: string,
+    firstAxis: AxisDirection,
+    secondAxis: AxisDirection,
+    thirdAxis: AxisDirection,
     origin: Readonly<NumericArray>,
     result?: Matrix4
   ): Matrix4;
   localFrameToFixedFrame<Matrix4T>(
-    firstAxis: string,
-    secondAxis: string,
-    thirdAxis: string,
+    firstAxis: AxisDirection,
+    secondAxis: AxisDirection,
+    thirdAxis: AxisDirection,
     origin: Readonly<NumericArray>,
     result: number[]
   ): number[];
 
   // Computes a 4x4 transformation matrix from a reference frame centered at
   // the provided origin to the ellipsoid's fixed reference frame.
-  localFrameToFixedFrame(firstAxis, secondAxis, thirdAxis, origin, result = new Matrix4()) {
+  localFrameToFixedFrame(
+    firstAxis: AxisDirection,
+    secondAxis: AxisDirection,
+    thirdAxis: AxisDirection,
+    origin: Readonly<NumericArray>,
+    result = new Matrix4()
+  ) {
     return localFrameToFixedFrame(this, firstAxis, secondAxis, thirdAxis, origin, result);
   }
 
@@ -180,14 +177,17 @@ export default class Ellipsoid {
    * the provided Cartesian position. */
   geocentricSurfaceNormal(cartesian: number[], result?: number[]): number[];
   geocentricSurfaceNormal<NumArray>(cartesian: number[], result: NumArray): NumArray;
-  geocentricSurfaceNormal(cartesian, result = [0, 0, 0]) {
+  geocentricSurfaceNormal(cartesian: Readonly<NumericArray>, result = [0, 0, 0]) {
     return scratchVector.from(cartesian).normalize().to(result);
   }
 
   /** Computes the normal of the plane tangent to the surface of the ellipsoid at provided position. */
-  geodeticSurfaceNormalCartographic<NumArray>(cartographic: number[], result: NumArray): NumArray;
+  geodeticSurfaceNormalCartographic<NumArray>(
+    cartographic: Readonly<NumericArray>,
+    result: NumArray
+  ): NumArray;
   geodeticSurfaceNormalCartographic(cartographic: number[]): number[];
-  geodeticSurfaceNormalCartographic(cartographic, result = [0, 0, 0]) {
+  geodeticSurfaceNormalCartographic(cartographic: Readonly<NumericArray>, result = [0, 0, 0]) {
     const cartographicVectorRadians = fromCartographicToRadians(cartographic);
 
     const longitude = cartographicVectorRadians[0];
@@ -205,7 +205,7 @@ export default class Ellipsoid {
   /** Computes the normal of the plane tangent to the surface of the ellipsoid at the provided position. */
   geodeticSurfaceNormal<NumArrayT>(cartesian: number[], result: NumArrayT): NumArrayT;
   geodeticSurfaceNormal(cartesian: number[]): number[];
-  geodeticSurfaceNormal(cartesian, result = [0, 0, 0]) {
+  geodeticSurfaceNormal(cartesian: Readonly<NumericArray>, result = [0, 0, 0]) {
     return scratchVector.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);
   }
 

package/src/ellipsoid/helpers/ellipsoid-transform.ts

@@ -1,13 +1,18 @@
-import {Vector3, assert, equals as equalsEpsilon} from '@math.gl/core';
+import {NumericArray, Vector3, assert, equals as equalsEpsilon} from '@math.gl/core';
 
-import type Ellipsoid from '../ellipsoid';
+import type {Ellipsoid} from '../ellipsoid';
 
 const EPSILON14 = 1e-14;
 
 const scratchOrigin = new Vector3();
 
+export type AxisDirection = 'up' | 'down' | 'north' | 'east' | 'south' | 'west';
+
 // Caclulate third axis from given two axii
-const VECTOR_PRODUCT_LOCAL_FRAME = {
+const VECTOR_PRODUCT_LOCAL_FRAME: Record<
+  AxisDirection,
+  Partial<Record<AxisDirection, AxisDirection>>
+> = {
   up: {
     south: 'east',
     north: 'west',
@@ -68,22 +73,19 @@ const scratchVector1 = new Vector3();
 const scratchVector2 = new Vector3();
 const scratchVector3 = new Vector3();
 
-type Axis = 'up' | 'down' | 'north' | 'east' | 'south' | 'west';
-
 // Computes a 4x4 transformation matrix from a reference frame
 // centered at the provided origin to the provided ellipsoid's fixed reference frame.
 // eslint-disable-next-line max-statements, max-params, complexity
-export default function localFrameToFixedFrame(
+export function localFrameToFixedFrame(
   ellipsoid: Ellipsoid,
-  firstAxis: Axis,
-  secondAxis: Axis,
-  thirdAxis: Axis,
-  cartesianOrigin: number[],
+  firstAxis: AxisDirection,
+  secondAxis: AxisDirection,
+  thirdAxis: AxisDirection,
+  cartesianOrigin: Readonly<NumericArray>,
   result: number[]
 ): number[] {
   const thirdAxisInferred =
-    VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] &&
-    (VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis] as Axis);
+    VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] && VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];
   // firstAxis and secondAxis must be east, north, up, west, south or down.');
   assert(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
 

package/src/ellipsoid/helpers/scale-to-geodetic-surface.ts

@@ -1,6 +1,6 @@
 /* eslint-disable */
 import {Vector3, _MathUtils} from '@math.gl/core';
-import type Ellipsoid from '../ellipsoid';
+import type {Ellipsoid} from '../ellipsoid';
 
 const scratchVector = new Vector3();
 const scaleToGeodeticSurfaceIntersection = new Vector3();
@@ -9,7 +9,7 @@ const scaleToGeodeticSurfaceGradient = new Vector3();
 // Scales the provided Cartesian position along the geodetic surface normal
 // so that it is on the surface of this ellipsoid.  If the position is
 // at the center of the ellipsoid, this function returns undefined.
-export default function scaleToGeodeticSurface(
+export function scaleToGeodeticSurface(
   cartesian: number[],
   ellipsoid: Ellipsoid,
   result: number[] = []

package/src/index.ts

@@ -1,2 +1,2 @@
-export {default as Ellipsoid} from './ellipsoid/ellipsoid';
+export {Ellipsoid} from './ellipsoid/ellipsoid';
 export {isWGS84} from './type-utils';

package/src/type-utils.ts

@@ -25,14 +25,14 @@ function identity(x: number): number {
 
 const scratchVector = new Vector3();
 
-export function fromCartographic(cartographic: Cartographic): number[];
+export function fromCartographic(cartographic: Readonly<Cartographic>): number[];
 export function fromCartographic<NumArrayT>(
-  cartographic: Cartographic,
+  cartographic: Readonly<Cartographic>,
   result: NumArrayT,
   map?: (x: number) => number
 ): NumArrayT;
 export function fromCartographic(
-  cartographic: Cartographic,
+  cartographic: Readonly<Cartographic>,
   result = [] as number[],
   map = identity
 ): number[] {
@@ -52,25 +52,31 @@ export function fromCartographic(
   return result;
 }
 
-export function fromCartographicToRadians(cartographic: Cartographic, result?: number[]): number[];
+export function fromCartographicToRadians(
+  cartographic: Readonly<Cartographic>,
+  result?: number[]
+): number[];
 export function fromCartographicToRadians<TArray>(
-  cartographic: Cartographic,
+  cartographic: Readonly<Cartographic>,
   result: TArray
 ): TArray;
 export function fromCartographicToRadians(
-  cartographic: Cartographic,
+  cartographic: Readonly<Cartographic>,
   vector = [] as number[]
 ): number[] {
   return fromCartographic(cartographic, vector, config._cartographicRadians ? identity : toRadians);
 }
 
-export function fromCartographicToDegrees(cartographic: Cartographic, result?: number[]): number[];
+export function fromCartographicToDegrees(
+  cartographic: Readonly<Cartographic>,
+  result?: number[]
+): number[];
 export function fromCartographicToDegrees<TArray>(
-  cartographic: Cartographic,
+  cartographic: Readonly<Cartographic>,
   result: TArray
 ): TArray;
 export function fromCartographicToDegrees(
-  cartographic: Cartographic,
+  cartographic: Readonly<Cartographic>,
   vector = [] as number[]
 ): number[] {
   return fromCartographic(cartographic, vector, config._cartographicRadians ? toDegrees : identity);

package/dist/es5/constants.js

@@ -1,22 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.WGS84_CONSTANTS = exports.WGS84_RADIUS_Z = exports.WGS84_RADIUS_Y = exports.WGS84_RADIUS_X = void 0;
-var WGS84_RADIUS_X = 6378137.0;
-exports.WGS84_RADIUS_X = WGS84_RADIUS_X;
-var WGS84_RADIUS_Y = 6378137.0;
-exports.WGS84_RADIUS_Y = WGS84_RADIUS_Y;
-var WGS84_RADIUS_Z = 6356752.3142451793;
-exports.WGS84_RADIUS_Z = WGS84_RADIUS_Z;
-var WGS84_CONSTANTS = {
-  radii: [WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z],
-  radiiSquared: [WGS84_RADIUS_X * WGS84_RADIUS_X, WGS84_RADIUS_Y * WGS84_RADIUS_Y, WGS84_RADIUS_Z * WGS84_RADIUS_Z],
-  oneOverRadii: [1.0 / WGS84_RADIUS_X, 1.0 / WGS84_RADIUS_Y, 1.0 / WGS84_RADIUS_Z],
-  oneOverRadiiSquared: [1.0 / (WGS84_RADIUS_X * WGS84_RADIUS_X), 1.0 / (WGS84_RADIUS_Y * WGS84_RADIUS_Y), 1.0 / (WGS84_RADIUS_Z * WGS84_RADIUS_Z)],
-  maximumRadius: Math.max(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z),
-  centerToleranceSquared: 1e-1
-};
-exports.WGS84_CONSTANTS = WGS84_CONSTANTS;
-//# sourceMappingURL=constants.js.map

package/dist/es5/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/constants.ts"],"names":["WGS84_RADIUS_X","WGS84_RADIUS_Y","WGS84_RADIUS_Z","WGS84_CONSTANTS","radii","radiiSquared","oneOverRadii","oneOverRadiiSquared","maximumRadius","Math","max","centerToleranceSquared"],"mappings":";;;;;;AAGO,IAAMA,cAAc,GAAG,SAAvB;;AACA,IAAMC,cAAc,GAAG,SAAvB;;AACA,IAAMC,cAAc,GAAG,kBAAvB;;AAIA,IAAMC,eAAe,GAAG;AAC7BC,EAAAA,KAAK,EAAE,CAACJ,cAAD,EAAiBC,cAAjB,EAAiCC,cAAjC,CADsB;AAE7BG,EAAAA,YAAY,EAAE,CACZL,cAAc,GAAGA,cADL,EAEZC,cAAc,GAAGA,cAFL,EAGZC,cAAc,GAAGA,cAHL,CAFe;AAO7BI,EAAAA,YAAY,EAAE,CAAC,MAAMN,cAAP,EAAuB,MAAMC,cAA7B,EAA6C,MAAMC,cAAnD,CAPe;AAQ7BK,EAAAA,mBAAmB,EAAE,CACnB,OAAOP,cAAc,GAAGA,cAAxB,CADmB,EAEnB,OAAOC,cAAc,GAAGA,cAAxB,CAFmB,EAGnB,OAAOC,cAAc,GAAGA,cAAxB,CAHmB,CARQ;AAa7BM,EAAAA,aAAa,EAAEC,IAAI,CAACC,GAAL,CAASV,cAAT,EAAyBC,cAAzB,EAAyCC,cAAzC,CAbc;AAc7BS,EAAAA,sBAAsB,EAAE;AAdK,CAAxB","sourcesContent":["// This file is derived from the Cesium math library under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nexport const WGS84_RADIUS_X = 6378137.0;\nexport const WGS84_RADIUS_Y = 6378137.0;\nexport const WGS84_RADIUS_Z = 6356752.3142451793;\n\n// Pre-calculated ellipsoid defaults to avoid utils depending on `ellipsoid.js`\n\nexport const WGS84_CONSTANTS = {\n  radii: [WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z],\n  radiiSquared: [\n    WGS84_RADIUS_X * WGS84_RADIUS_X,\n    WGS84_RADIUS_Y * WGS84_RADIUS_Y,\n    WGS84_RADIUS_Z * WGS84_RADIUS_Z\n  ],\n  oneOverRadii: [1.0 / WGS84_RADIUS_X, 1.0 / WGS84_RADIUS_Y, 1.0 / WGS84_RADIUS_Z],\n  oneOverRadiiSquared: [\n    1.0 / (WGS84_RADIUS_X * WGS84_RADIUS_X),\n    1.0 / (WGS84_RADIUS_Y * WGS84_RADIUS_Y),\n    1.0 / (WGS84_RADIUS_Z * WGS84_RADIUS_Z)\n  ],\n  maximumRadius: Math.max(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z),\n  centerToleranceSquared: 1e-1 // EPSILON1;\n};\n"],"file":"constants.js"}

package/dist/es5/ellipsoid/ellipsoid.js

@@ -1,210 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-var _typeof = require("@babel/runtime/helpers/typeof");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _core = require("@math.gl/core");
-
-var vec3 = _interopRequireWildcard(require("gl-matrix/vec3"));
-
-var _constants = require("../constants");
-
-var _typeUtils = require("../type-utils");
-
-var _scaleToGeodeticSurface2 = _interopRequireDefault(require("./helpers/scale-to-geodetic-surface"));
-
-var _ellipsoidTransform = _interopRequireDefault(require("./helpers/ellipsoid-transform"));
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
-var scratchVector = new _core.Vector3();
-var scratchNormal = new _core.Vector3();
-var scratchK = new _core.Vector3();
-var scratchPosition = new _core.Vector3();
-var scratchHeight = new _core.Vector3();
-var scratchCartesian = new _core.Vector3();
-var wgs84;
-
-var Ellipsoid = function () {
-  function Ellipsoid() {
-    var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0.0;
-    var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.0;
-    var z = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0.0;
-    (0, _classCallCheck2.default)(this, Ellipsoid);
-    (0, _defineProperty2.default)(this, "radii", void 0);
-    (0, _defineProperty2.default)(this, "radiiSquared", void 0);
-    (0, _defineProperty2.default)(this, "radiiToTheFourth", void 0);
-    (0, _defineProperty2.default)(this, "oneOverRadii", void 0);
-    (0, _defineProperty2.default)(this, "oneOverRadiiSquared", void 0);
-    (0, _defineProperty2.default)(this, "minimumRadius", void 0);
-    (0, _defineProperty2.default)(this, "maximumRadius", void 0);
-    (0, _defineProperty2.default)(this, "centerToleranceSquared", _core._MathUtils.EPSILON1);
-    (0, _defineProperty2.default)(this, "squaredXOverSquaredZ", void 0);
-    (0, _core.assert)(x >= 0.0);
-    (0, _core.assert)(y >= 0.0);
-    (0, _core.assert)(z >= 0.0);
-    this.radii = new _core.Vector3(x, y, z);
-    this.radiiSquared = new _core.Vector3(x * x, y * y, z * z);
-    this.radiiToTheFourth = new _core.Vector3(x * x * x * x, y * y * y * y, z * z * z * z);
-    this.oneOverRadii = new _core.Vector3(x === 0.0 ? 0.0 : 1.0 / x, y === 0.0 ? 0.0 : 1.0 / y, z === 0.0 ? 0.0 : 1.0 / z);
-    this.oneOverRadiiSquared = new _core.Vector3(x === 0.0 ? 0.0 : 1.0 / (x * x), y === 0.0 ? 0.0 : 1.0 / (y * y), z === 0.0 ? 0.0 : 1.0 / (z * z));
-    this.minimumRadius = Math.min(x, y, z);
-    this.maximumRadius = Math.max(x, y, z);
-
-    if (this.radiiSquared.z !== 0) {
-      this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;
-    }
-
-    Object.freeze(this);
-  }
-
-  (0, _createClass2.default)(Ellipsoid, [{
-    key: "equals",
-    value: function equals(right) {
-      return this === right || Boolean(right && this.radii.equals(right.radii));
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return this.radii.toString();
-    }
-  }, {
-    key: "cartographicToCartesian",
-    value: function cartographicToCartesian(cartographic) {
-      var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0];
-      var normal = scratchNormal;
-      var k = scratchK;
-
-      var _cartographic = (0, _slicedToArray2.default)(cartographic, 3),
-          height = _cartographic[2];
-
-      this.geodeticSurfaceNormalCartographic(cartographic, normal);
-      k.copy(this.radiiSquared).scale(normal);
-      var gamma = Math.sqrt(normal.dot(k));
-      k.scale(1 / gamma);
-      normal.scale(height);
-      k.add(normal);
-      return k.to(result);
-    }
-  }, {
-    key: "cartesianToCartographic",
-    value: function cartesianToCartographic(cartesian) {
-      var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0];
-      scratchCartesian.from(cartesian);
-      var point = this.scaleToGeodeticSurface(scratchCartesian, scratchPosition);
-
-      if (!point) {
-        return undefined;
-      }
-
-      var normal = this.geodeticSurfaceNormal(point, scratchNormal);
-      var h = scratchHeight;
-      h.copy(scratchCartesian).subtract(point);
-      var longitude = Math.atan2(normal.y, normal.x);
-      var latitude = Math.asin(normal.z);
-      var height = Math.sign(vec3.dot(h, scratchCartesian)) * vec3.length(h);
-      return (0, _typeUtils.toCartographicFromRadians)([longitude, latitude, height], result);
-    }
-  }, {
-    key: "eastNorthUpToFixedFrame",
-    value: function eastNorthUpToFixedFrame(origin) {
-      var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _core.Matrix4();
-      return (0, _ellipsoidTransform.default)(this, 'east', 'north', 'up', origin, result);
-    }
-  }, {
-    key: "localFrameToFixedFrame",
-    value: function localFrameToFixedFrame(firstAxis, secondAxis, thirdAxis, origin) {
-      var result = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : new _core.Matrix4();
-      return (0, _ellipsoidTransform.default)(this, firstAxis, secondAxis, thirdAxis, origin, result);
-    }
-  }, {
-    key: "geocentricSurfaceNormal",
-    value: function geocentricSurfaceNormal(cartesian) {
-      var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0];
-      return scratchVector.from(cartesian).normalize().to(result);
-    }
-  }, {
-    key: "geodeticSurfaceNormalCartographic",
-    value: function geodeticSurfaceNormalCartographic(cartographic) {
-      var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0];
-      var cartographicVectorRadians = (0, _typeUtils.fromCartographicToRadians)(cartographic);
-      var longitude = cartographicVectorRadians[0];
-      var latitude = cartographicVectorRadians[1];
-      var cosLatitude = Math.cos(latitude);
-      scratchVector.set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude)).normalize();
-      return scratchVector.to(result);
-    }
-  }, {
-    key: "geodeticSurfaceNormal",
-    value: function geodeticSurfaceNormal(cartesian) {
-      var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0];
-      return scratchVector.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);
-    }
-  }, {
-    key: "scaleToGeodeticSurface",
-    value: function scaleToGeodeticSurface(cartesian, result) {
-      return (0, _scaleToGeodeticSurface2.default)(cartesian, this, result);
-    }
-  }, {
-    key: "scaleToGeocentricSurface",
-    value: function scaleToGeocentricSurface(cartesian) {
-      var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0];
-      scratchPosition.from(cartesian);
-      var positionX = scratchPosition.x;
-      var positionY = scratchPosition.y;
-      var positionZ = scratchPosition.z;
-      var oneOverRadiiSquared = this.oneOverRadiiSquared;
-      var beta = 1.0 / Math.sqrt(positionX * positionX * oneOverRadiiSquared.x + positionY * positionY * oneOverRadiiSquared.y + positionZ * positionZ * oneOverRadiiSquared.z);
-      return scratchPosition.multiplyScalar(beta).to(result);
-    }
-  }, {
-    key: "transformPositionToScaledSpace",
-    value: function transformPositionToScaledSpace(position) {
-      var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0];
-      return scratchPosition.from(position).scale(this.oneOverRadii).to(result);
-    }
-  }, {
-    key: "transformPositionFromScaledSpace",
-    value: function transformPositionFromScaledSpace(position) {
-      var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0];
-      return scratchPosition.from(position).scale(this.radii).to(result);
-    }
-  }, {
-    key: "getSurfaceNormalIntersectionWithZAxis",
-    value: function getSurfaceNormalIntersectionWithZAxis(position) {
-      var buffer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-      var result = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [0, 0, 0];
-      (0, _core.assert)((0, _core.equals)(this.radii.x, this.radii.y, _core._MathUtils.EPSILON15));
-      (0, _core.assert)(this.radii.z > 0);
-      scratchPosition.from(position);
-      var z = scratchPosition.z * (1 - this.squaredXOverSquaredZ);
-
-      if (Math.abs(z) >= this.radii.z - buffer) {
-        return undefined;
-      }
-
-      return scratchPosition.set(0.0, 0.0, z).to(result);
-    }
-  }]);
-  return Ellipsoid;
-}();
-
-exports.default = Ellipsoid;
-(0, _defineProperty2.default)(Ellipsoid, "WGS84", new Ellipsoid(_constants.WGS84_RADIUS_X, _constants.WGS84_RADIUS_Y, _constants.WGS84_RADIUS_Z));
-//# sourceMappingURL=ellipsoid.js.map