@math.gl/geospatial 3.5.6 → 3.6.0-alpha.2

package/src/type-utils.ts

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

package/dist/es5/ellipsoid/ellipsoid.d.ts

@@ -1,95 +0,0 @@
-import {Vector3, Matrix4} from '@math.gl/core';
-
-/** 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 {
-  /** An Ellipsoid instance initialized to the WGS84 standard. */
-  static readonly WGS84: Ellipsoid;
-
-  readonly radii: Vector3;
-  readonly radiiSquared: Vector3;
-  readonly radiiToTheFourth: Vector3;
-  readonly oneOverRadii: Vector3;
-  readonly oneOverRadiiSquared: Vector3;
-  readonly minimumRadius: number;
-  readonly maximumRadius: number;
-  readonly centerToleranceSquared: number;
-  readonly squaredXOverSquaredZ: number;
-
-  /** Creates an Ellipsoid from a Cartesian specifying the radii in x, y, and z directions. */
-  constructor(x: number, y: number, z: number);
-  constructor();
-
-  /** Compares this Ellipsoid against the provided Ellipsoid componentwise */
-  equals(right: Ellipsoid): boolean;
-  /** Creates a string representing this Ellipsoid in the format '(radii.x, radii.y, radii.z)'. */
-  toString(): string;
-
-  /** Converts the provided cartographic to Cartesian representation. */
-  cartographicToCartesian(cartographic: number[], result?: Vector3): Vector3;
-  cartographicToCartesian(cartographic: number[], result?: number[]): number[];
-
-  /** 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[];
-
-  /** 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[];
-
-  /** Computes a 4x4 transformation matrix from a reference frame centered at
-   * the provided origin to the ellipsoid's fixed reference frame.
-   */
-  localFrameToFixedFrame(
-    firstAxis: string,
-    secondAxis: string,
-    thirdAxis: string,
-    origin: number[],
-    result?: Matrix4
-  ): Matrix4;
-  localFrameToFixedFrame(
-    firstAxis: string,
-    secondAxis: string,
-    thirdAxis: string,
-    origin: number[],
-    result?: number[]
-  ): number[];
-
-  /** Computes the unit vector directed from the center of this ellipsoid toward
-   * the provided Cartesian position. */
-  geocentricSurfaceNormal(cartesian: number[], result?: number[]): number[];
-
-  /** Computes the normal of the plane tangent to the surface of the ellipsoid at provided position. */
-  geodeticSurfaceNormalCartographic(cartographic: number[], result?: number[]): number[];
-
-  /** Computes the normal of the plane tangent to the surface of the ellipsoid at the provided position. */
-  geodeticSurfaceNormal(cartesian: number[], result?: number[]): number[];
-
-  /** 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. */
-  scaleToGeodeticSurface(cartesian: number[], result?: number[]): number[];
-
-  /** Scales the provided Cartesian position along the geocentric surface normal
-   * so that it is on the surface of this ellipsoid. */
-  scaleToGeocentricSurface(cartesian: number[], result?: number[]): number[];
-
-  /** Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying
-   * its components by the result of `Ellipsoid#oneOverRadii` */
-  transformPositionToScaledSpace(position: number[], result?: number[]): number[];
-
-  /** Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying
-   * its components by the result of `Ellipsoid#radii`. */
-  transformPositionFromScaledSpace(position: number[], result?: number[]): number[];
-
-  /** Computes a point which is the intersection of the surface normal with the z-axis. */
-  getSurfaceNormalIntersectionWithZAxis(
-    position: number[],
-    buffer?: number,
-    result?: number[]
-  ): number[];
-}

package/dist/es5/index.d.ts

@@ -1 +0,0 @@
-export {default as Ellipsoid} from './ellipsoid/ellipsoid';

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

@@ -1,55 +0,0 @@
-// This file is derived from the Cesium math library under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-
-// import {Vector3} from '@math.gl/core';
-
-type TypedArray =
-  | Int8Array
-  | Uint8Array
-  | Int16Array
-  | Uint16Array
-  | Int32Array
-  | Uint32Array
-  | Uint8ClampedArray
-  | Float32Array
-  | Float64Array;
-
-type LngLatHeightObject = {
-  longitude: number;
-  latitude: number;
-  height: number;
-};
-
-type XYZObject = {
-  x: number;
-  y: number;
-  z: number;
-};
-
-type Cartographic = LngLatHeightObject | XYZObject | number[] | TypedArray;
-
-export function fromCartographic(cartographic: Cartographic, result?: number[]): number[];
-export function fromCartographic(cartographic: Cartographic, result: TypedArray): TypedArray;
-export function fromCartographicToRadians(cartographic: Cartographic, result?: number[]): number[];
-export function fromCartographicToRadians(
-  cartographic: Cartographic,
-  result: TypedArray
-): TypedArray;
-export function fromCartographicToDegrees(cartographic: Cartographic, result?: number[]): number[];
-export function fromCartographicToDegrees(
-  cartographic: Cartographic,
-  result: TypedArray
-): TypedArray;
-
-export function toCartographic(vector: number[] | TypedArray, result: Cartographic): number[];
-export function toCartographicFromRadians(
-  vector: number[] | TypedArray,
-  result: Cartographic
-): number[];
-export function toCartographicFromDegrees(
-  vector: number[] | TypedArray,
-  result: Cartographic
-): number[];
-
-// Estimates if a vector is close to the surface of the WGS84 Ellipsoid
-export function isWGS84(vector: number[] | TypedArray): boolean;

package/dist/esm/ellipsoid/ellipsoid.d.ts

@@ -1,95 +0,0 @@
-import {Vector3, Matrix4} from '@math.gl/core';
-
-/** 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 {
-  /** An Ellipsoid instance initialized to the WGS84 standard. */
-  static readonly WGS84: Ellipsoid;
-
-  readonly radii: Vector3;
-  readonly radiiSquared: Vector3;
-  readonly radiiToTheFourth: Vector3;
-  readonly oneOverRadii: Vector3;
-  readonly oneOverRadiiSquared: Vector3;
-  readonly minimumRadius: number;
-  readonly maximumRadius: number;
-  readonly centerToleranceSquared: number;
-  readonly squaredXOverSquaredZ: number;
-
-  /** Creates an Ellipsoid from a Cartesian specifying the radii in x, y, and z directions. */
-  constructor(x: number, y: number, z: number);
-  constructor();
-
-  /** Compares this Ellipsoid against the provided Ellipsoid componentwise */
-  equals(right: Ellipsoid): boolean;
-  /** Creates a string representing this Ellipsoid in the format '(radii.x, radii.y, radii.z)'. */
-  toString(): string;
-
-  /** Converts the provided cartographic to Cartesian representation. */
-  cartographicToCartesian(cartographic: number[], result?: Vector3): Vector3;
-  cartographicToCartesian(cartographic: number[], result?: number[]): number[];
-
-  /** 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[];
-
-  /** 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[];
-
-  /** Computes a 4x4 transformation matrix from a reference frame centered at
-   * the provided origin to the ellipsoid's fixed reference frame.
-   */
-  localFrameToFixedFrame(
-    firstAxis: string,
-    secondAxis: string,
-    thirdAxis: string,
-    origin: number[],
-    result?: Matrix4
-  ): Matrix4;
-  localFrameToFixedFrame(
-    firstAxis: string,
-    secondAxis: string,
-    thirdAxis: string,
-    origin: number[],
-    result?: number[]
-  ): number[];
-
-  /** Computes the unit vector directed from the center of this ellipsoid toward
-   * the provided Cartesian position. */
-  geocentricSurfaceNormal(cartesian: number[], result?: number[]): number[];
-
-  /** Computes the normal of the plane tangent to the surface of the ellipsoid at provided position. */
-  geodeticSurfaceNormalCartographic(cartographic: number[], result?: number[]): number[];
-
-  /** Computes the normal of the plane tangent to the surface of the ellipsoid at the provided position. */
-  geodeticSurfaceNormal(cartesian: number[], result?: number[]): number[];
-
-  /** 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. */
-  scaleToGeodeticSurface(cartesian: number[], result?: number[]): number[];
-
-  /** Scales the provided Cartesian position along the geocentric surface normal
-   * so that it is on the surface of this ellipsoid. */
-  scaleToGeocentricSurface(cartesian: number[], result?: number[]): number[];
-
-  /** Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying
-   * its components by the result of `Ellipsoid#oneOverRadii` */
-  transformPositionToScaledSpace(position: number[], result?: number[]): number[];
-
-  /** Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying
-   * its components by the result of `Ellipsoid#radii`. */
-  transformPositionFromScaledSpace(position: number[], result?: number[]): number[];
-
-  /** Computes a point which is the intersection of the surface normal with the z-axis. */
-  getSurfaceNormalIntersectionWithZAxis(
-    position: number[],
-    buffer?: number,
-    result?: number[]
-  ): number[];
-}

package/dist/esm/index.d.ts

@@ -1 +0,0 @@
-export {default as Ellipsoid} from './ellipsoid/ellipsoid';

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

@@ -1,55 +0,0 @@
-// This file is derived from the Cesium math library under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-
-// import {Vector3} from '@math.gl/core';
-
-type TypedArray =
-  | Int8Array
-  | Uint8Array
-  | Int16Array
-  | Uint16Array
-  | Int32Array
-  | Uint32Array
-  | Uint8ClampedArray
-  | Float32Array
-  | Float64Array;
-
-type LngLatHeightObject = {
-  longitude: number;
-  latitude: number;
-  height: number;
-};
-
-type XYZObject = {
-  x: number;
-  y: number;
-  z: number;
-};
-
-type Cartographic = LngLatHeightObject | XYZObject | number[] | TypedArray;
-
-export function fromCartographic(cartographic: Cartographic, result?: number[]): number[];
-export function fromCartographic(cartographic: Cartographic, result: TypedArray): TypedArray;
-export function fromCartographicToRadians(cartographic: Cartographic, result?: number[]): number[];
-export function fromCartographicToRadians(
-  cartographic: Cartographic,
-  result: TypedArray
-): TypedArray;
-export function fromCartographicToDegrees(cartographic: Cartographic, result?: number[]): number[];
-export function fromCartographicToDegrees(
-  cartographic: Cartographic,
-  result: TypedArray
-): TypedArray;
-
-export function toCartographic(vector: number[] | TypedArray, result: Cartographic): number[];
-export function toCartographicFromRadians(
-  vector: number[] | TypedArray,
-  result: Cartographic
-): number[];
-export function toCartographicFromDegrees(
-  vector: number[] | TypedArray,
-  result: Cartographic
-): number[];
-
-// Estimates if a vector is close to the surface of the WGS84 Ellipsoid
-export function isWGS84(vector: number[] | TypedArray): boolean;

package/src/ellipsoid/ellipsoid.d.ts

@@ -1,95 +0,0 @@
-import {Vector3, Matrix4} from '@math.gl/core';
-
-/** 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 {
-  /** An Ellipsoid instance initialized to the WGS84 standard. */
-  static readonly WGS84: Ellipsoid;
-
-  readonly radii: Vector3;
-  readonly radiiSquared: Vector3;
-  readonly radiiToTheFourth: Vector3;
-  readonly oneOverRadii: Vector3;
-  readonly oneOverRadiiSquared: Vector3;
-  readonly minimumRadius: number;
-  readonly maximumRadius: number;
-  readonly centerToleranceSquared: number;
-  readonly squaredXOverSquaredZ: number;
-
-  /** Creates an Ellipsoid from a Cartesian specifying the radii in x, y, and z directions. */
-  constructor(x: number, y: number, z: number);
-  constructor();
-
-  /** Compares this Ellipsoid against the provided Ellipsoid componentwise */
-  equals(right: Ellipsoid): boolean;
-  /** Creates a string representing this Ellipsoid in the format '(radii.x, radii.y, radii.z)'. */
-  toString(): string;
-
-  /** Converts the provided cartographic to Cartesian representation. */
-  cartographicToCartesian(cartographic: number[], result?: Vector3): Vector3;
-  cartographicToCartesian(cartographic: number[], result?: number[]): number[];
-
-  /** 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[];
-
-  /** 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[];
-
-  /** Computes a 4x4 transformation matrix from a reference frame centered at
-   * the provided origin to the ellipsoid's fixed reference frame.
-   */
-  localFrameToFixedFrame(
-    firstAxis: string,
-    secondAxis: string,
-    thirdAxis: string,
-    origin: number[],
-    result?: Matrix4
-  ): Matrix4;
-  localFrameToFixedFrame(
-    firstAxis: string,
-    secondAxis: string,
-    thirdAxis: string,
-    origin: number[],
-    result?: number[]
-  ): number[];
-
-  /** Computes the unit vector directed from the center of this ellipsoid toward
-   * the provided Cartesian position. */
-  geocentricSurfaceNormal(cartesian: number[], result?: number[]): number[];
-
-  /** Computes the normal of the plane tangent to the surface of the ellipsoid at provided position. */
-  geodeticSurfaceNormalCartographic(cartographic: number[], result?: number[]): number[];
-
-  /** Computes the normal of the plane tangent to the surface of the ellipsoid at the provided position. */
-  geodeticSurfaceNormal(cartesian: number[], result?: number[]): number[];
-
-  /** 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. */
-  scaleToGeodeticSurface(cartesian: number[], result?: number[]): number[];
-
-  /** Scales the provided Cartesian position along the geocentric surface normal
-   * so that it is on the surface of this ellipsoid. */
-  scaleToGeocentricSurface(cartesian: number[], result?: number[]): number[];
-
-  /** Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying
-   * its components by the result of `Ellipsoid#oneOverRadii` */
-  transformPositionToScaledSpace(position: number[], result?: number[]): number[];
-
-  /** Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying
-   * its components by the result of `Ellipsoid#radii`. */
-  transformPositionFromScaledSpace(position: number[], result?: number[]): number[];
-
-  /** Computes a point which is the intersection of the surface normal with the z-axis. */
-  getSurfaceNormalIntersectionWithZAxis(
-    position: number[],
-    buffer?: number,
-    result?: number[]
-  ): number[];
-}

package/src/index.d.ts

@@ -1 +0,0 @@
-export {default as Ellipsoid} from './ellipsoid/ellipsoid';

package/src/type-utils.d.ts

@@ -1,55 +0,0 @@
-// This file is derived from the Cesium math library under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-
-// import {Vector3} from '@math.gl/core';
-
-type TypedArray =
-  | Int8Array
-  | Uint8Array
-  | Int16Array
-  | Uint16Array
-  | Int32Array
-  | Uint32Array
-  | Uint8ClampedArray
-  | Float32Array
-  | Float64Array;
-
-type LngLatHeightObject = {
-  longitude: number;
-  latitude: number;
-  height: number;
-};
-
-type XYZObject = {
-  x: number;
-  y: number;
-  z: number;
-};
-
-type Cartographic = LngLatHeightObject | XYZObject | number[] | TypedArray;
-
-export function fromCartographic(cartographic: Cartographic, result?: number[]): number[];
-export function fromCartographic(cartographic: Cartographic, result: TypedArray): TypedArray;
-export function fromCartographicToRadians(cartographic: Cartographic, result?: number[]): number[];
-export function fromCartographicToRadians(
-  cartographic: Cartographic,
-  result: TypedArray
-): TypedArray;
-export function fromCartographicToDegrees(cartographic: Cartographic, result?: number[]): number[];
-export function fromCartographicToDegrees(
-  cartographic: Cartographic,
-  result: TypedArray
-): TypedArray;
-
-export function toCartographic(vector: number[] | TypedArray, result: Cartographic): number[];
-export function toCartographicFromRadians(
-  vector: number[] | TypedArray,
-  result: Cartographic
-): number[];
-export function toCartographicFromDegrees(
-  vector: number[] | TypedArray,
-  result: Cartographic
-): number[];
-
-// Estimates if a vector is close to the surface of the WGS84 Ellipsoid
-export function isWGS84(vector: number[] | TypedArray): boolean;

package/src/type-utils.js

@@ -1,71 +0,0 @@
-// This file is derived from the Cesium math library under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-
-import {Vector3, isArray, toRadians, toDegrees, config} from '@math.gl/core';
-import {WGS84_CONSTANTS} from './constants';
-
-const noop = (x) => x;
-
-const scratchVector = new Vector3();
-
-export function fromCartographic(cartographic, result, map = noop) {
-  if (isArray(cartographic)) {
-    result[0] = map(cartographic[0]);
-    result[1] = map(cartographic[1]);
-    result[2] = cartographic[2];
-  } else if ('longitude' in cartographic) {
-    result[0] = map(cartographic.longitude);
-    result[1] = map(cartographic.latitude);
-    result[2] = cartographic.height;
-  } else {
-    result[0] = map(cartographic.x);
-    result[1] = map(cartographic.y);
-    result[2] = cartographic.z;
-  }
-  return result;
-}
-
-export function fromCartographicToRadians(cartographic, vector = scratchVector) {
-  return fromCartographic(cartographic, vector, config._cartographicRadians ? noop : toRadians);
-}
-
-export function fromCartographicToDegrees(cartographic, vector = scratchVector) {
-  return fromCartographic(cartographic, vector, config._cartographicRadians ? toDegrees : noop);
-}
-
-export function toCartographic(vector, cartographic, map = noop) {
-  if (isArray(cartographic)) {
-    cartographic[0] = map(vector[0]);
-    cartographic[1] = map(vector[1]);
-    cartographic[2] = vector[2];
-  } else if ('longitude' in cartographic) {
-    cartographic.longitude = map(vector[0]);
-    cartographic.latitude = map(vector[1]);
-    cartographic.height = vector[2];
-  } else {
-    cartographic.x = map(vector[0]);
-    cartographic.y = map(vector[1]);
-    cartographic.z = vector[2];
-  }
-  return cartographic;
-}
-
-export function toCartographicFromRadians(vector, cartographic) {
-  return toCartographic(vector, cartographic, config._cartographicRadians ? noop : toDegrees);
-}
-
-export function toCartographicFromDegrees(vector, cartographic) {
-  return toCartographic(vector, cartographic, config._cartographicRadians ? toRadians : noop);
-}
-
-export function isWGS84(vector) {
-  if (!vector) {
-    return false;
-  }
-  scratchVector.from(vector);
-  const {oneOverRadiiSquared, centerToleranceSquared} = WGS84_CONSTANTS;
-  const x2 = vector[0] * vector[0] * oneOverRadiiSquared[0];
-  const y2 = vector[1] * vector[1] * oneOverRadiiSquared[1];
-  const z2 = vector[2] * vector[2] * oneOverRadiiSquared[2];
-  return Math.abs(x2 + y2 + z2 - 1) < centerToleranceSquared;
-}