@math.gl/core 5.0.0-alpha.17 → 5.0.0-alpha.19

package/src/expressions/vendor/jsep/types.ts

@@ -0,0 +1,179 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) 2013 Stephen Oney
+
+declare namespace jsep {
+		export type baseTypes = string | number | boolean | RegExp | null | undefined | object;
+		export interface Expression {
+			type: string;
+			[key: string]: baseTypes | Expression | Array<baseTypes | Expression>;
+		}
+
+		export interface ArrayExpression extends Expression {
+			type: 'ArrayExpression';
+			/** The expression can be null in the case of array holes ([ , , ]) */
+			elements: Array<null | Expression>;
+		}
+
+		export interface BinaryExpression extends Expression {
+			type: 'BinaryExpression';
+			operator: string;
+			left: Expression;
+			right: Expression;
+		}
+
+		export interface CallExpression extends Expression {
+			type: 'CallExpression';
+			arguments: Expression[];
+			callee: Expression;
+		}
+
+		export interface Compound extends Expression {
+			type: 'Compound';
+			body: Expression[];
+		}
+
+		export interface SequenceExpression extends Expression {
+			type: 'SequenceExpression';
+			expressions: Expression[];
+		}
+
+		export interface ConditionalExpression extends Expression {
+			type: 'ConditionalExpression';
+			test: Expression;
+			consequent: Expression;
+			alternate: Expression;
+		}
+
+		export interface Identifier extends Expression {
+			type: 'Identifier';
+			name: string;
+		}
+
+		export interface Literal extends Expression {
+			type: 'Literal';
+			value: boolean | number | string | RegExp | null;
+			raw: string;
+		}
+
+		export interface MemberExpression extends Expression {
+			type: 'MemberExpression';
+			computed: boolean;
+			object: Expression;
+			property: Expression;
+			optional?: boolean;
+		}
+
+		export interface ThisExpression extends Expression {
+			type: 'ThisExpression';
+		}
+
+		export interface UnaryExpression extends Expression {
+			type: 'UnaryExpression';
+			operator: string;
+			argument: Expression;
+			prefix: boolean;
+		}
+
+		export type ExpressionType =
+			'Compound'
+			| 'SequenceExpression'
+			| 'Identifier'
+			| 'MemberExpression'
+			| 'Literal'
+			| 'ThisExpression'
+			| 'CallExpression'
+			| 'UnaryExpression'
+			| 'BinaryExpression'
+			| 'ConditionalExpression'
+			| 'ArrayExpression';
+
+		export type CoreExpression =
+			ArrayExpression
+			| BinaryExpression
+			| CallExpression
+			| Compound
+			| SequenceExpression
+			| ConditionalExpression
+			| Identifier
+			| Literal
+			| MemberExpression
+			| ThisExpression
+			| UnaryExpression;
+
+		export type PossibleExpression = Expression | undefined;
+		export interface HookScope {
+			index: number;
+			readonly expr: string;
+			readonly char: string; // current character of the expression
+			readonly code: number; // current character code of the expression
+			gobbleSpaces: () => void;
+			gobbleExpressions: (untilICode?: number) => Expression[];
+			gobbleExpression: () => Expression;
+			gobbleBinaryOp: () => PossibleExpression;
+			gobbleBinaryExpression: () => PossibleExpression;
+			gobbleToken: () => PossibleExpression;
+			gobbleTokenProperty: (node: Expression) => Expression
+			gobbleNumericLiteral: () => PossibleExpression;
+			gobbleStringLiteral: () => PossibleExpression;
+			gobbleIdentifier: () => PossibleExpression;
+			gobbleArguments: (untilICode: number) => PossibleExpression;
+			gobbleGroup: () => Expression;
+			gobbleArray: () => PossibleExpression;
+			throwError: (msg: string) => never;
+		}
+
+		export type HookType = 'gobble-expression' | 'after-expression' | 'gobble-token' | 'after-token' | 'gobble-spaces';
+		export type HookCallback = (this: HookScope, env: { node?: Expression }) => void;
+		type HookTypeObj = Partial<{ [key in HookType]: HookCallback}>
+
+		export interface IHooks extends HookTypeObj {
+			add(name: HookType, cb: HookCallback, first?: boolean): void;
+			add(obj: { [name in HookType]: HookCallback }, first?: boolean): void;
+			run(name: string, env: { context?: typeof jsep, node?: Expression }): void;
+		}
+		let hooks: IHooks;
+
+		export interface IPlugin {
+			name: string;
+			init: (this: typeof jsep) => void;
+		}
+		export interface IPlugins {
+			registered: { [name: string]: IPlugin };
+			register: (...plugins: IPlugin[]) => void;
+		}
+		let plugins: IPlugins;
+
+		let unary_ops: { [op: string]: any };
+		let binary_ops: { [op: string]: number };
+		let right_associative: Set<string>;
+		let additional_identifier_chars: Set<string>;
+		let literals: { [literal: string]: any };
+		let this_str: string;
+
+		function addBinaryOp(operatorName: string, precedence: number, rightToLeft?: boolean): void;
+
+		function addUnaryOp(operatorName: string): void;
+
+		function addLiteral(literalName: string, literalValue: any): void;
+
+		function addIdentifierChar(identifierName: string): void;
+
+		function removeBinaryOp(operatorName: string): void;
+
+		function removeUnaryOp(operatorName: string): void;
+
+		function removeLiteral(literalName: string): void;
+
+		function removeIdentifierChar(identifierName: string): void;
+
+		function removeAllBinaryOps(): void;
+
+		function removeAllUnaryOps(): void;
+
+		function removeAllLiterals(): void;
+
+		const version: string;
+	}
+
+declare function jsep(val: string | jsep.Expression): jsep.Expression;
+export type {jsep as Jsep};

package/src/gl-matrix/vec2.ts

@@ -6,7 +6,7 @@
 // @eslint-disable
 // @ts-nocheck
 
-import type {NumericArray} from '@math.gl/types';
+import type {NumericArray} from '../types';
 import * as glMatrix from './common.js';
 
 /**

package/src/index.ts

@@ -16,9 +16,9 @@ export type {
   NumberArray9,
   NumberArray12,
   NumberArray16
-} from '@math.gl/types';
+} from './types';
 
-export type {isTypedArray, isNumberArray, isNumericArray} from '@math.gl/types';
+export type {isTypedArray, isNumberArray, isNumericArray} from './types';
 
 // classes
 export {MathArray as _MathArray} from './classes/base/math-array';
@@ -69,4 +69,4 @@ export {
   withEpsilon
 } from './lib/common';
 
-export type {SpheroidParameters} from '@math.gl/types';
+export type {SpheroidParameters} from './types';

package/src/lib/common.ts

@@ -4,7 +4,7 @@
 
 /* eslint-disable no-shadow */ // radians and degrees are common variable names
 
-import type {NumericArray} from '@math.gl/types';
+import type {NumericArray} from '../types';
 
 import type {MathArray} from '../classes/base/math-array';
 import {EPSILON14, TWO_PI, PI} from './math-utils';

package/src/lib/gl-matrix-extras.ts

@@ -3,7 +3,7 @@
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
 /* eslint-disable camelcase */
-import {NumericArray} from '@math.gl/types';
+import {NumericArray} from '../types';
 // vec2 additions
 
 export function vec2_transformMat4AsVector<T extends NumericArray>(

package/src/lib/validators.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
-import {NumericArray} from '@math.gl/types';
+import {NumericArray} from '../types';
 import {config} from './common';
 
 export function validateVector(v: NumericArray, length: number): boolean {

package/src/local-frame.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 // SPDX-FileComment: Original factored ENU/NED basis, rotations and matrix commits. No CesiumJS or PROJ source is copied.
-import type {NumericArray} from '@math.gl/types';
+import type {NumericArray} from './types';
 
 export type LocalFramePoint = {x: number; y: number; z: number};
 export type LocalFrameAxis = 'east' | 'north' | 'up' | 'west' | 'south' | 'down';

package/src/spheroid.ts

@@ -5,7 +5,7 @@
 // SPDX-FileComment: Forward geocentric equations and Hannover inverse moved/adapted from math.gl projection's proj4js 2.22.0 datumUtils.js port. See ../PROJ4-LICENSE.md. Safeguarded nearest-footpoint inverse and numeric output commit are original math.gl code.
 
 /** Numeric leaf: angles in radians, distances in axis units; no CRS, global config or scratch. */
-import type {SpheroidParameters} from '@math.gl/types';
+import type {SpheroidParameters} from './types';
 export type SpheroidGeometry = SpheroidParameters & {readonly eccentricitySquared: number};
 export type SpheroidPoint = {x: number; y: number; z: number};
 

package/src/types/array-types.ts

@@ -0,0 +1,148 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+// Float16Array is declared in a separate TypeScript library. Preserve this reference so
+// published declarations remain self-contained without changing the target or emitting runtime code.
+// eslint-disable-next-line spaced-comment
+/// <reference lib="es2025.float16" preserve="true" />
+
+/**
+ * Type covering all non-big JavaScript typed arrays, including `Float16Array`.
+ *
+ * @remarks Including `Float16Array` does not guarantee that `globalThis.Float16Array` exists.
+ */
+export type TypedArray =
+  | Int8Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Float16Array
+  | Float32Array
+  | Float64Array;
+
+/**
+ * Type covering constructors for all non-big JavaScript typed arrays, including
+ * `Float16ArrayConstructor`.
+ *
+ * @remarks Including `Float16ArrayConstructor` does not install `globalThis.Float16Array`.
+ */
+export type TypedArrayConstructor =
+  | Int8ArrayConstructor
+  | Uint8ArrayConstructor
+  | Uint8ClampedArrayConstructor
+  | Int16ArrayConstructor
+  | Uint16ArrayConstructor
+  | Int32ArrayConstructor
+  | Uint32ArrayConstructor
+  | Float16ArrayConstructor
+  | Float32ArrayConstructor
+  | Float64ArrayConstructor;
+
+/**
+ * Type covering all big typed arrays
+ */
+export type BigTypedArray = BigInt64Array | BigUint64Array;
+
+/**
+ * Type covering constructors for all big typed arrays
+ */
+export type BigTypedArrayConstructor = BigInt64ArrayConstructor | BigUint64ArrayConstructor;
+
+/**
+ * Type for classic arrays consisting of numbers
+ * @note Included for completeness / orthogonality, prefer `number[]` in actual use
+ */
+export type NumberArray = number[];
+
+/** Array with exactly 1 number */
+export type NumberArray1 = [number];
+
+/** Array with exactly 2 numbers */
+export type NumberArray2 = [number, number];
+
+/** Array with exactly 3 numbers */
+export type NumberArray3 = [number, number, number];
+
+/** Array with exactly 4 numbers */
+export type NumberArray4 = [number, number, number, number];
+
+/** Array with exactly 6 numbers */
+export type NumberArray6 = [number, number, number, number, number, number];
+
+/** Array with exactly 8 numbers */
+export type NumberArray8 = [number, number, number, number, number, number, number, number];
+
+/** Array with exactly 9 numbers */
+export type NumberArray9 = [number, number, number, number, number, number, number, number, number];
+
+/** Array with exactly 12 numbers */
+export type NumberArray12 = [
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number
+];
+
+/** Array with exactly 16 numbers */
+export type NumberArray16 = [
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number
+];
+
+/**
+ * Type covering classic arrays consisting of numbers as well as typed arrays
+ */
+export type NumericArray = TypedArray | number[];
+
+/** Array with exactly 1 number, or a typed array */
+export type NumericArray1 = NumberArray1 | TypedArray;
+
+/** Array with exactly 2 numbers, or a typed array */
+export type NumericArray2 = NumberArray2 | TypedArray;
+
+/** Array with exactly 3 numbers, or a typed array */
+export type NumericArray3 = NumberArray3 | TypedArray;
+
+/** Array with exactly 4 numbers, or a typed array */
+export type NumericArray4 = NumberArray4 | TypedArray;
+
+/** Array with exactly 6 numbers, or a typed array */
+export type NumericArray6 = NumberArray6 | TypedArray;
+
+/** Array with exactly 8 numbers, or a typed array */
+export type NumericArray8 = NumberArray8 | TypedArray;
+
+/** Array with exactly 9 numbers, or a typed array */
+export type NumericArray9 = NumberArray9 | TypedArray;
+
+/** Array with exactly 12 numbers, or a typed array */
+export type NumericArray12 = NumberArray12 | TypedArray;
+
+/** Array with exactly 16 numbers, or a typed array */
+export type NumericArray16 = NumberArray16 | TypedArray;

package/src/types/bigint.ts

@@ -0,0 +1,56 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+// BigInt compatibility layer
+// Inspired by ArrowJS (under Apache2 license)
+// https://github.com/apache/arrow/blob/master/js/src/util/compat.ts
+// Requires tsconfig.json: target=esnext or (lib: esnext.bigint)
+// Requires eslint: env: {es2020: true}
+
+const ERR_BIGINT_UNAVAILABLE = 'BigInt is not available in this environment';
+
+function BigIntUnavailable() {
+  throw new Error(ERR_BIGINT_UNAVAILABLE);
+}
+BigIntUnavailable.asIntN = () => {
+  throw new Error(ERR_BIGINT_UNAVAILABLE);
+};
+BigIntUnavailable.asUintN = () => {
+  throw new Error(ERR_BIGINT_UNAVAILABLE);
+};
+
+class BigInt64ArrayUnavailable {
+  static get BYTES_PER_ELEMENT() {
+    return 8;
+  }
+  static of() {
+    throw new Error(ERR_BIGINT_UNAVAILABLE);
+  }
+  static from() {
+    throw new Error(ERR_BIGINT_UNAVAILABLE);
+  }
+  constructor() {
+    throw new Error(ERR_BIGINT_UNAVAILABLE);
+  }
+}
+
+export const BigIntAvailable = typeof BigInt !== 'undefined';
+export const BigInt64ArrayAvailable = typeof BigInt64Array !== 'undefined';
+export const BigUint64ArrayAvailable = typeof BigUint64Array !== 'undefined';
+
+const BigIntCtor = (() => {
+  return BigIntAvailable ? BigInt : BigIntUnavailable;
+})();
+
+const BigInt64ArrayCtor = (() => {
+  return BigInt64ArrayAvailable ? BigInt64Array : BigInt64ArrayUnavailable;
+})();
+
+const BigUint64ArrayCtor = (() => {
+  return BigUint64ArrayAvailable ? [BigUint64Array] : [BigInt64ArrayUnavailable];
+})();
+
+export {BigIntCtor as BigInt};
+export {BigInt64ArrayCtor as BigInt64Array};
+export {BigUint64ArrayCtor as BigUint64Array};

package/src/types/bounds-types.ts

@@ -0,0 +1,29 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+/** 2 dimensional bounds [[minX, minY], [maxX, maxY]] */
+export type Bounds2D = [[number, number], [number, number]];
+
+/** 3 dimensional bounds [[minX, minY, minZ], [maxX, maxY, maxZ]] */
+export type Bounds3D = [[number, number, number], [number, number, number]];
+
+/** 2 or 3 dimensional bounds [[minX, minY], [maxX, maxY]] or [[minX, minY, minZ], [maxX, maxY, maxZ]] */
+export type Bounds =
+  | [[number, number], [number, number]]
+  | [[number, number, number], [number, number, number]];
+
+/** Checks if a `Bounds` is a `Bounds2D` */
+export function isBounds2D(bounds: Bounds): bounds is Bounds2D {
+  return bounds.length === 2;
+}
+
+/** Accepts 2D and 3D bounds and returns a 2D bound, truncating 3D dimension if necessary */
+export function getBounds2D(bounds: Bounds): Bounds2D {
+  return isBounds2D(bounds)
+    ? bounds
+    : [
+        [bounds[0][0], bounds[0][1]],
+        [bounds[1][0], bounds[1][1]]
+      ];
+}

package/src/types/float16.ts

@@ -0,0 +1,47 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {TypedArrayConstructor} from './array-types';
+import {getTypedArrayName} from './typed-array-brand';
+
+/**
+ * Checks for native Float16Array values, including arrays from other realms.
+ * Does not identify Uint16Array binary16 storage as a decoded Float16Array.
+ * Does not require a Float16Array constructor in the current realm.
+ */
+export function isFloat16Array(value: unknown): value is Float16Array {
+  return getTypedArrayName(value) === 'Float16Array';
+}
+
+/**
+ * The native `Float16Array` constructor exposed by the current JavaScript runtime.
+ *
+ * @remarks This is `undefined` when the runtime does not provide `Float16Array`. The value is
+ * captured when this module is evaluated, so a polyfill must be installed before importing
+ * `@math.gl/core/types`.
+ */
+export const NativeFloat16ArrayConstructor: TypedArrayConstructor | undefined =
+  globalThis.Float16Array;
+
+/**
+ * Returns the typed array constructor used for half-precision storage.
+ *
+ * @returns The native `Float16Array` constructor when available, otherwise `Uint16Array`.
+ * @remarks The `Uint16Array` fallback stores encoded IEEE 754 binary16 bit patterns. Unlike a
+ * native `Float16Array`, it does not encode numeric assignments or decode values when read.
+ */
+export function getFloat16ArrayConstructor(): TypedArrayConstructor {
+  return NativeFloat16ArrayConstructor ?? Uint16Array;
+}
+
+/**
+ * Checks whether a value is the native `Float16Array` constructor for the current runtime.
+ *
+ * @param value The value to test.
+ * @returns `true` when `value` matches `NativeFloat16ArrayConstructor`. Returns `false` for the
+ * `Uint16Array` fallback.
+ */
+export function isFloat16ArrayConstructor(value: unknown): boolean {
+  return Boolean(NativeFloat16ArrayConstructor && value === NativeFloat16ArrayConstructor);
+}

package/src/types/index.ts

@@ -0,0 +1,45 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export type {
+  // typed arrays
+  TypedArray,
+  TypedArrayConstructor,
+  BigTypedArray,
+  BigTypedArrayConstructor,
+  // numeric arrays (sized number arrays)
+  NumberArray,
+  NumberArray1,
+  NumberArray2,
+  NumberArray3,
+  NumberArray4,
+  NumberArray6,
+  NumberArray8,
+  NumberArray9,
+  NumberArray12,
+  NumberArray16,
+  // numeric arrays (sized number arrays or typed arrays)
+  NumericArray,
+  NumericArray1,
+  NumericArray2,
+  NumericArray3,
+  NumericArray4,
+  NumericArray6,
+  NumericArray8,
+  NumericArray9,
+  NumericArray12,
+  NumericArray16
+} from './array-types';
+
+export {isTypedArray, isUint16Array, isNumberArray, isNumericArray} from './is-array';
+export {
+  NativeFloat16ArrayConstructor,
+  getFloat16ArrayConstructor,
+  isFloat16ArrayConstructor,
+  isFloat16Array
+} from './float16';
+
+export type {Bounds, Bounds2D, Bounds3D} from './bounds-types';
+
+export type {SpheroidParameters} from './spheroid';

package/src/types/is-array.ts

@@ -0,0 +1,41 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {TypedArray, NumericArray, NumberArray} from './array-types';
+import {getTypedArrayName} from './typed-array-brand';
+
+/** Checks for unsigned 16-bit samples, including typed arrays from other realms. */
+export function isUint16Array(value: unknown): value is Uint16Array {
+  return getTypedArrayName(value) === 'Uint16Array';
+}
+
+/**
+ * Check is an array is a typed array
+ * @param value value to be tested
+ * @returns input with type narrowed to TypedArray, or null
+ */
+export function isTypedArray(value: unknown): value is TypedArray {
+  return ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+
+/**
+ * Check is an array is an array of numbers)
+ * @param value value to be tested
+ * @returns input with type narrowed to NumberArray, or null
+ */
+export function isNumberArray(value: unknown): value is NumberArray {
+  if (Array.isArray(value)) {
+    return value.length === 0 || typeof value[0] === 'number';
+  }
+  return false;
+}
+
+/**
+ * Check is an array is a numeric array (typed array or array of numbers)
+ * @param value value to be tested
+ * @returns input with type narrowed to NumericArray, or null
+ */
+export function isNumericArray(value: unknown): value is NumericArray {
+  return isTypedArray(value) || isNumberArray(value);
+}

package/src/types/spheroid.ts

@@ -0,0 +1,11 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+/** Geometry of a sphere or oblate spheroid, in metres. No datum, axes or epoch metadata.
+ * Both axes must be finite and positive, with semiMinorAxis <= semiMajorAxis.
+ */
+export type SpheroidParameters = {
+  readonly semiMajorAxis: number;
+  readonly semiMinorAxis: number;
+};

package/src/types/typed-array-brand.ts

@@ -0,0 +1,14 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+// Use the intrinsic getter so constructor and Symbol.toStringTag overrides cannot
+// disguise a typed array's element type. It also works for arrays from other realms.
+const typedArrayTagGetter = Object.getOwnPropertyDescriptor(
+  Object.getPrototypeOf(Uint8Array.prototype),
+  Symbol.toStringTag
+)!.get!;
+
+export function getTypedArrayName(value: unknown): string | undefined {
+  return ArrayBuffer.isView(value) ? typedArrayTagGetter.call(value) : undefined;
+}

package/src/types.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export * from './types/index';