@luma.gl/core 9.0.0-alpha.9 → 9.0.0-beta.2

package/src/utils/array-equal.ts

@@ -0,0 +1,33 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import {isNumberArray} from './is-array';
+
+/** Test if two arrays are deep equal, with a length limit that defaults to 16 */
+export function arrayEqual(a: unknown, b: unknown, limit: number = 16) {
+  if (a !== b) {
+    return false;
+  }
+  const arrayA = isNumberArray(a);
+  if (!arrayA) {
+    return false;
+  }
+  const arrayB = isNumberArray(b);
+  if (arrayB && arrayA.length === arrayB.length) {
+    for (let i = 0; i < arrayA.length; ++i) {
+      if (arrayB[i] !== arrayA[i]) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+/** Copy a value */
+export function arrayCopy<T>(a: T): T {
+  const numberArray = isNumberArray(a);
+  if (numberArray) {
+    return numberArray.slice() as T;
+  }
+  return a;
+}

package/src/utils/array-utils-flat.ts

@@ -0,0 +1,43 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+import type {TypedArray, NumberArray} from '../types';
+
+let arrayBuffer: ArrayBuffer;
+
+export function getScratchArrayBuffer(byteLength: number): ArrayBuffer {
+  if (!arrayBuffer || arrayBuffer.byteLength < byteLength) {
+    arrayBuffer = new ArrayBuffer(byteLength);
+  }
+  return arrayBuffer;
+}
+
+export function getScratchArray(Type: any, length: number): TypedArray {
+  const scratchArrayBuffer = getScratchArrayBuffer(Type.BYTES_PER_ELEMENT * length);
+  return new Type(scratchArrayBuffer, 0, length); // arrayBuffer, byteOffset, length (in elements)
+}
+
+// Uses copyWithin to significantly speed up typed array value filling
+export function fillArray(options: {target: NumberArray, source: NumberArray, start?: number, count?: number}): NumberArray {
+  const {target, source, start = 0, count = 1} = options;
+  const length = source.length;
+  const total = count * length;
+  let copied = 0;
+  for (let i = start; copied < length; copied++) {
+    target[i++] = source[copied] ;
+  }
+
+  while (copied < total) {
+    // If we have copied less than half, copy everything we got
+    // else copy remaining in one operation
+    if (copied < total - copied) {
+      target.copyWithin(start + copied, start, start + copied);
+      copied *= 2;
+    } else {
+      target.copyWithin(start + copied, start, start + total - copied);
+      copied = total;
+    }
+  }
+
+  return options.target;
+}

package/src/utils/assert.ts

@@ -0,0 +1,7 @@
+// Recommendation is to ignore message but current test suite checks agains the
+// message so keep it for now.
+export function assert(condition: unknown, message?: string): void | never {
+  if (!condition) {
+    throw new Error(message || 'luma.gl: assertion failed.');
+  }
+}

package/src/utils/cast.ts

@@ -0,0 +1,4 @@
+/** Helper for type downcasts, e.g. Buffer -> WebGPUBuffer */
+export function cast<T>(value: any) {
+  return value as T;
+}

package/src/utils/check-props.ts

@@ -0,0 +1,74 @@
+import {log} from './log';
+
+/* Use as
+import {checkProps} from '../util/check-props;'
+
+const PROP_CHECKS = {
+  // Removed props no longer supported, print error and link to upgrade guide
+  removedProps: {
+  },
+  // Deprecated props
+  deprecatedProps: {
+    offset: 'accessor',
+    stride: 'accessor',
+    type: 'accessor',
+    size: 'accessor',
+    divisor: 'accessor',
+    normalized: 'accessor',
+    integer: 'accessor'
+  },
+  // Deprecated props that can be autosubstituted, print warning and return updated props object
+  replacedProps: {
+    bytes: 'byteLength'
+  }
+}
+
+class Buffer {
+  setProps(props) {
+    checkProps('Buffer', props, PROP_CHECKS);
+  }
+}
+*/
+
+export type PropChecks = {
+  removedProps?: Record<string, any>;
+  replacedProps?: Record<string, string>;
+  deprecatedProps?: Record<string, string>;
+};
+
+export function checkProps(className: string, props: Record<string, any>, propChecks: PropChecks): Record<string, unknown> {
+  const {removedProps = {}, deprecatedProps = {}, replacedProps = {}} = propChecks;
+
+  // removedProps: Removed props no longer supported
+  // print error and link to upgrade guide
+  for (const propName in removedProps) {
+    if (propName in props) {
+      const replacementProp = removedProps[propName];
+      const replacement = replacementProp ? `${className}.${removedProps[propName]}` : 'N/A';
+      log.removed(`${className}.${propName}`, replacement)();
+    }
+  }
+
+  // deprecatedProps: Deprecated props that can not be autosubstituted
+  // print warning and rely on caller to substitute
+  for (const propName in deprecatedProps) {
+    if (propName in props) {
+      const replacementProp = deprecatedProps[propName];
+      log.deprecated(`${className}.${propName}`, `${className}.${replacementProp}`)();
+    }
+  }
+
+  // replacedProps: Deprecated props that can be autosubstituted
+  // print warning and return updated props object
+  let newProps = null;
+  for (const [propName, replacementProp] of Object.entries(replacedProps)) {
+    if (propName in props) {
+      log.deprecated(`${className}.${propName}`, `${className}.${replacementProp}`)();
+      newProps = newProps || Object.assign({}, props);
+      newProps[replacementProp] = props[propName];
+      delete newProps[propName];
+    }
+  }
+
+  return newProps || props;
+}

package/src/utils/deep-equal.ts

@@ -0,0 +1,47 @@
+/**
+ * Fast partial deep equal for prop.
+ *
+ * @param a Prop
+ * @param b Prop to compare against `a`
+ * @param depth Depth to which to recurse in nested Objects/Arrays. Use 0 (default) for shallow comparison, -1 for infinite depth
+ */
+/* eslint-disable complexity */
+export function deepEqual(a: any, b: any, depth: number): boolean {
+  if (a === b) {
+    return true;
+  }
+  if (!depth || !a || !b) {
+    return false;
+  }
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) {
+      return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i], depth - 1)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (Array.isArray(b)) {
+    return false;
+  }
+  if (typeof a === 'object' && typeof b === 'object') {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+      return false;
+    }
+    for (const key of aKeys) {
+      if (!b.hasOwnProperty(key)) {
+        return false;
+      }
+      if (!deepEqual(a[key], b[key], depth - 1)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}

package/src/utils/format-value.ts

@@ -0,0 +1,40 @@
+/* eslint-disable no-console */
+import type {NumberArray} from '../types';
+
+/** TODO @deprecated - delete when confident that probe.gl logging implements all opts */
+function formatArrayValue(v: NumberArray, opts: {maxElts?: number, size?: number} = {}): string {
+  const {maxElts = 16, size = 1} = opts;
+  let string = '[';
+  for (let i = 0; i < v.length && i < maxElts; ++i) {
+    if (i > 0) {
+      string += `,${i % size === 0 ? ' ' : ''}`;
+    }
+    string += formatValue(v[i], opts);
+  }
+  const terminator = v.length > maxElts ? '...' : ']';
+  return `${string}${terminator}`;
+}
+
+/** TODO @deprecated - delete when confident that probe.gl logging implements all opts */
+export function formatValue(v: number | NumberArray | unknown, opts: {isInteger?: boolean, size?: number} = {}): string {
+  const EPSILON = 1e-16;
+  const {isInteger = false} = opts;
+  if (Array.isArray(v) || ArrayBuffer.isView(v)) {
+    return formatArrayValue(v as NumberArray, opts);
+  }
+  if (typeof v !== 'number') {
+    return String(v);
+  }
+  if (Math.abs(v) < EPSILON) {
+    return isInteger ? '0' : '0.';
+  }
+  if (isInteger) {
+    return v.toFixed(0);
+  }
+  if (Math.abs(v) > 100 && Math.abs(v) < 10000) {
+    return v.toFixed(0);
+  }
+  const string = v.toPrecision(2);
+  const decimal = string.indexOf('.0');
+  return decimal === string.length - 2 ? string.slice(0, -1) : string;
+}

package/src/utils/is-array.ts

@@ -0,0 +1,24 @@
+import {TypedArray, NumberArray} from '../types';
+
+/**
+ * Check is an array is a typed array
+ * @param value value to be tested
+ * @returns input as TypedArray, or null
+ * @todo this should be provided by @math.gl/types
+ */
+export function isTypedArray(value: unknown): TypedArray | null {
+  return ArrayBuffer.isView(value) && !(value instanceof DataView) ? (value as TypedArray) : null;
+}
+
+/**
+ * Check is an array is a numeric array (typed array or array of numbers)
+ * @param value value to be tested
+ * @returns input as NumberArray, or null
+ * @todo this should be provided by @math.gl/types
+ */
+export function isNumberArray(value: unknown): NumberArray | null {
+  if (Array.isArray(value)) {
+    return value.length === 0 || typeof value[0] === 'number' ? (value as number[]) : null;
+  }
+  return isTypedArray(value);
+}

package/src/utils/load-file.ts

@@ -0,0 +1,89 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+let pathPrefix = '';
+
+/**
+ * Set a relative path prefix
+ */
+export function setPathPrefix(prefix: string) {
+  pathPrefix = prefix;
+}
+
+/**
+ * Reads raw file data. Respects setPathPrefix.
+ */
+export async function loadFile(
+  url: string,
+  options?: {dataType?: 'text' | 'arrayBuffer'} & RequestInit
+): Promise<any> {
+  url = url.startsWith('http') ? url : pathPrefix + url;
+  const dataType = options?.dataType || 'text';
+  const response = await fetch(url, options);
+  return await response[dataType]();
+}
+
+/**
+ * Loads ImageBitmap asynchronously. Respects setPathPrefix.
+ * image.crossOrigin can be set via opts.crossOrigin, default to 'anonymous'
+ * @returns a promise tracking the load
+ */
+export async function loadImageBitmap(
+  url: string,
+  opts?: {crossOrigin?: string}
+): Promise<ImageBitmap> {
+  const image = new Image();
+  image.crossOrigin = opts?.crossOrigin || 'anonymous';
+  image.src = url.startsWith('http') ? url : pathPrefix + url;
+  await image.decode();
+  return await createImageBitmap(image);
+}
+
+/**
+ * Loads image asynchronously. Respects setPathPrefix.
+ * image.crossOrigin can be set via opts.crossOrigin, default to 'anonymous'
+ * @returns a promise tracking the load
+ * @deprecated Use `loadImageBitmap()` unless you are supporting old versions of Safari.
+ */
+export async function loadImage(
+  url: string,
+  opts?: {crossOrigin?: string}
+): Promise<HTMLImageElement> {
+  return new Promise((resolve, reject) => {
+    try {
+      const image = new Image();
+      image.onload = () => resolve(image);
+      image.onerror = () => reject(new Error(`Could not load image ${url}.`));
+      image.crossOrigin = opts?.crossOrigin || 'anonymous';
+      image.src = url.startsWith('http') ? url : pathPrefix + url;
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+
+/**
+ * Load a script (identified by an url). When the url returns, the
+ * content of this file is added into a new script element, attached to the DOM (body element)
+ * @param scriptUrl defines the url of the script to laod
+ * @param scriptId defines the id of the script element
+ */
+export async function loadScript(scriptUrl: string, scriptId?: string): Promise<Event> {
+  const head = document.getElementsByTagName('head')[0];
+  if (!head) {
+    throw new Error('loadScript');
+  }
+
+  const script = document.createElement('script');
+  script.setAttribute('type', 'text/javascript');
+  script.setAttribute('src', scriptUrl);
+  if (scriptId) {
+    script.id = scriptId;
+  }
+
+  return new Promise((resolve, reject) => {
+    script.onload = resolve;
+    script.onerror = (error) => reject(new Error(`Unable to load script '${scriptUrl}': ${error as string}`));
+    head.appendChild(script);
+  });
+}

package/src/utils/log.ts

@@ -0,0 +1,4 @@
+import {Log} from '@probe.gl/log';
+
+/** Global log instance */
+export const log: Log = new Log({id: 'luma.gl'});

package/src/utils/random.ts

@@ -0,0 +1,17 @@
+/** Creates a deterministic pseudorandom number generator */
+export function makeRandomNumberGenerator(): () => number {
+  let s = 1;
+  let c = 1;
+  return () => {
+    s = Math.sin(c * 17.23);
+    c = Math.cos(s * 27.92);
+    return fract(Math.abs(s * c) * 1432.71);
+  };
+}
+
+function fract(n: number): number {
+  return n - Math.floor(n);
+}
+
+/** Generates a deterministic pseudorandom number */
+export const random = makeRandomNumberGenerator();

package/src/utils/request-animation-frame.ts

@@ -0,0 +1,15 @@
+// Node.js polyfills for requestAnimationFrame and cancelAnimationFrame
+/* global window, setTimeout, clearTimeout */
+
+// / <reference types="@types/node" />
+export function requestAnimationFrame(callback: (time?: any) => void): any {
+  return typeof window !== 'undefined' && window.requestAnimationFrame
+    ? window.requestAnimationFrame(callback)
+    : setTimeout(callback, 1000 / 60);
+}
+
+export function cancelAnimationFrame(timerId: any): void {
+  return typeof window !== 'undefined' && window.cancelAnimationFrame
+    ? window.cancelAnimationFrame(timerId)
+    : clearTimeout(timerId);
+}

package/src/utils/stats-manager.ts

@@ -0,0 +1,23 @@
+import {Stats} from '@probe.gl/stats';
+
+/** 
+ * Helper class managing a collection of probe.gl stats objects 
+ */
+export class StatsManager {
+  stats = new Map();
+
+  getStats(name: string): Stats {
+    return this.get(name);
+  }
+
+  get(name: string): Stats {
+    if (!this.stats.has(name)) {
+      this.stats.set(name, new Stats({id: name}));
+    }
+
+    return this.stats.get(name);
+  }
+}
+
+/** Global stats for all luma.gl devices */
+export const lumaStats: StatsManager = new StatsManager();

package/src/utils/stub-methods.ts

@@ -0,0 +1,20 @@
+import {log} from './log';
+
+// Install stubs for removed methods
+export function stubRemovedMethods(instance: any, className: string, version: string, methodNames: string[]) {
+  const upgradeMessage = `See luma.gl ${version} Upgrade Guide at \
+https://luma.gl/docs/upgrade-guide`;
+
+  const prototype = Object.getPrototypeOf(instance);
+
+  methodNames.forEach((methodName: string): void => {
+    if (prototype.methodName) {
+      return;
+    }
+
+    prototype[methodName] = () => {
+      log.removed(`Calling removed method ${className}.${methodName}: `, upgradeMessage)();
+      throw new Error(methodName);
+    };
+  });
+}

package/src/utils/utils.ts

@@ -0,0 +1,36 @@
+// luma.gl, MIT license
+// Copyright (c) vis.gl contributors
+
+const uidCounters: Record<string, number> = {};
+
+/**
+ * Returns a UID.
+ * @param id= - Identifier base name
+ * @return uid
+ **/
+export function uid(id: string = 'id'): string {
+  uidCounters[id] = uidCounters[id] || 1;
+  const count = uidCounters[id]++;
+  return `${id}-${count}`;
+}
+
+/**
+ * Verifies if a given number is power of two or not.
+ * @param n - The number to check.
+ * @return  Returns true if the given number is power of 2, false otherwise.
+ **/
+export function isPowerOfTwo(n: number): boolean {
+  return (n > 0) && (n & (n - 1)) === 0;
+}
+
+/** Returns true if given object is empty, false otherwise. */
+export function isObjectEmpty(obj: object): boolean {
+  let isEmpty = true;
+  // @ts-ignore key is unused
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  for (const key in obj) {
+    isEmpty = false;
+    break;
+  }
+  return isEmpty;
+}

package/dist/bundle.d.ts

@@ -1,2 +0,0 @@
-declare const moduleExports: any;
-//# sourceMappingURL=bundle.d.ts.map

package/dist/bundle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,aAAa,KAAqB,CAAC"}

package/dist/bundle.js

@@ -1,5 +0,0 @@
-const moduleExports = require('./index');
-
-globalThis.luma = globalThis.luma || {};
-module.exports = Object.assign(globalThis.luma, moduleExports);
-//# sourceMappingURL=bundle.js.map

package/dist/bundle.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/bundle.ts"],"names":["moduleExports","require","globalThis","luma","module","exports","Object","assign"],"mappings":"AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,IAAX,GAAkBD,UAAU,CAACC,IAAX,IAAmB,EAArC;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,IAAzB,EAA+BH,aAA/B,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.luma = globalThis.luma || {};\nmodule.exports = Object.assign(globalThis.luma, moduleExports);\n"],"file":"bundle.js"}

package/src/bundle.ts

@@ -1,4 +0,0 @@
-// @ts-nocheck
-const moduleExports = require('./index');
-globalThis.luma = globalThis.luma || {};
-module.exports = Object.assign(globalThis.luma, moduleExports);