@luma.gl/core 9.0.17 → 9.1.0-alpha.10

package/dist/utils/request-animation-frame.js

@@ -1,16 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-// Node.js polyfills for requestAnimationFrame and cancelAnimationFrame
-/* global window, setTimeout, clearTimeout */
-// / <reference types="@types/node" />
-export function requestAnimationFrame(callback) {
-    return typeof window !== 'undefined' && window.requestAnimationFrame
-        ? window.requestAnimationFrame(callback)
-        : setTimeout(callback, 1000 / 60);
-}
-export function cancelAnimationFrame(timerId) {
-    return typeof window !== 'undefined' && window.cancelAnimationFrame
-        ? window.cancelAnimationFrame(timerId)
-        : clearTimeout(timerId);
-}

package/dist/utils/stub-methods.d.ts

@@ -1,2 +0,0 @@
-export declare function stubRemovedMethods(instance: any, className: string, version: string, methodNames: string[]): void;
-//# sourceMappingURL=stub-methods.d.ts.map

package/dist/utils/stub-methods.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stub-methods.d.ts","sourceRoot":"","sources":["../../src/utils/stub-methods.ts"],"names":[],"mappings":"AAOA,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,GAAG,EACb,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,QAiBtB"}

package/dist/utils/stub-methods.js

@@ -1,19 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-import { log } from "./log.js";
-// Install stubs for removed methods
-export function stubRemovedMethods(instance, className, version, methodNames) {
-    const upgradeMessage = `See luma.gl ${version} Upgrade Guide at \
-https://luma.gl/docs/upgrade-guide`;
-    const prototype = Object.getPrototypeOf(instance);
-    methodNames.forEach((methodName) => {
-        if (prototype.methodName) {
-            return;
-        }
-        prototype[methodName] = () => {
-            log.removed(`Calling removed method ${className}.${methodName}: `, upgradeMessage)();
-            throw new Error(methodName);
-        };
-    });
-}

package/dist/utils/utils.d.ts

@@ -1,9 +0,0 @@
-/**
- * Returns a UID.
- * @param id= - Identifier base name
- * @return uid
- **/
-export declare function uid(id?: string): string;
-/** Returns true if given object is empty, false otherwise. */
-export declare function isObjectEmpty(obj: object): boolean;
-//# sourceMappingURL=utils.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils/utils.ts"],"names":[],"mappings":"AAMA;;;;IAII;AACJ,wBAAgB,GAAG,CAAC,EAAE,GAAE,MAAa,GAAG,MAAM,CAI7C;AAED,8DAA8D;AAC9D,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CASlD"}

package/src/adapter/types/accessor.ts

@@ -1,37 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {Buffer} from '../resources/buffer';
-// import type {VertexFormat} from './data-formats';
-
-// ACCESSORS
-
-/**
- * Attribute descriptor object
- * @deprecated Use ShaderLayout
- */
-export interface AccessorObject {
-  buffer?: Buffer;
-  // format: VertexFormat;
-  offset?: number;
-  // can now be described with single WebGPU-style `format` string
-
-  //
-  stride?: number;
-
-  /** @deprecated - Use accessor.stepMode */
-  divisor?: number;
-
-  /** @deprecated - Infer from format */
-  type?: number;
-  /** @deprecated - Infer from format */
-  size?: number;
-  /** @deprecated - Infer from format */
-  normalized?: boolean;
-  /** @deprecated - Infer from format */
-  integer?: boolean;
-
-  /** @deprecated */
-  index?: number;
-}

package/src/init.ts

@@ -1,53 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {isBrowser} from '@probe.gl/env';
-import {log} from './utils/log';
-import {lumaStats} from './utils/stats-manager';
-
-declare global {
-  // eslint-disable-next-line no-var
-  var luma: any;
-}
-
-/**
- * By adding the result of init() to Device.VERSION we guarantee it will be called
- * @returns version
- */
-function initializeLuma(): string {
-  // Version detection using babel plugin
-  // @ts-expect-error
-  const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'running from source';
-
-  const STARTUP_MESSAGE = 'set luma.log.level=1 (or higher) to trace rendering';
-  // Assign luma.log.level in console to control logging: \
-  // 0: none, 1: minimal, 2: verbose, 3: attribute/uniforms, 4: gl logs
-  // luma.log.break[], set to gl funcs, luma.log.profile[] set to model names`;
-
-  if (globalThis.luma && globalThis.luma.VERSION !== VERSION) {
-    throw new Error(
-      `luma.gl - multiple VERSIONs detected: ${globalThis.luma.VERSION} vs ${VERSION}`
-    );
-  }
-
-  if (!globalThis.luma) {
-    if (isBrowser()) {
-      log.log(1, `${VERSION} - ${STARTUP_MESSAGE}`)();
-    }
-
-    globalThis.luma = globalThis.luma || {
-      VERSION,
-      version: VERSION,
-      log,
-
-      // A global stats object that various components can add information to
-      // E.g. see webgl/resource.js
-      stats: lumaStats
-    };
-  }
-
-  return VERSION;
-}
-
-export const VERSION = initializeLuma();

package/src/lib/compiler-log/get-shader-info.ts

@@ -1,42 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-// Note: This was the only dependency that made @luma.gl/webgl depend on @luma.gl/shadertools
-// This file was coped from shadertools to avoid the dependency
-
-/** Information extracted from shader source code */
-export type ShaderInfo = {
-  name: string;
-  language: 'glsl' | 'wgsl';
-  version: number;
-};
-
-/** Extracts information from shader source code */
-export function getShaderInfo(source: string, defaultName?: string): ShaderInfo {
-  return {
-    name: getShaderName(source, defaultName),
-    language: 'glsl',
-    version: getShaderVersion(source)
-  };
-}
-
-/** Extracts GLSLIFY style naming of shaders: `#define SHADER_NAME ...` */
-function getShaderName(shader: string, defaultName: string = 'unnamed'): string {
-  const SHADER_NAME_REGEXP = /#define[\s*]SHADER_NAME[\s*]([A-Za-z0-9_-]+)[\s*]/;
-  const match = SHADER_NAME_REGEXP.exec(shader);
-  return match ? match[1] : defaultName;
-}
-
-/** returns GLSL shader version of given shader string */
-function getShaderVersion(source: string): number {
-  let version = 100;
-  const words = source.match(/[^\s]+/g);
-  if (words && words.length >= 2 && words[0] === '#version') {
-    const v = parseInt(words[1], 10);
-    if (Number.isFinite(v)) {
-      version = v;
-    }
-  }
-  return version;
-}

package/src/lib/luma.ts

@@ -1,190 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {Log} from '@probe.gl/log';
-import type {DeviceProps} from '../adapter/device';
-import {Device} from '../adapter/device';
-import {StatsManager} from '../utils/stats-manager';
-import {lumaStats} from '../utils/stats-manager';
-import {log} from '../utils/log';
-import {assert} from '../utils/assert';
-
-const deviceMap = new Map<string, typeof Device>();
-
-/** Properties for creating a new device */
-export type CreateDeviceProps = DeviceProps & {
-  /** Selects the type of device. `best-available` uses webgpu if available, then webgl. */
-  type?: 'webgl' | 'webgpu' | 'unknown' | 'best-available';
-  devices?: any[];
-};
-
-/** Properties for attaching an existing WebGL context or WebGPU device to a new luma Device */
-export type AttachDeviceProps = DeviceProps & {
-  /** Externally created WebGL context or WebGPU device */
-  handle: WebGL2RenderingContext; // | GPUDevice;
-  devices?: any[];
-};
-
-/**
- * Entry point to the luma.gl GPU abstraction
- * Register WebGPU and/or WebGL devices (controls application bundle size)
- * Run-time selection of the first available Device
- */
-export class luma {
-  static defaultProps: Required<CreateDeviceProps> = {
-    ...Device.defaultProps,
-    type: 'best-available',
-    devices: undefined!
-  };
-
-  /** Global stats for all devices */
-  static stats: StatsManager = lumaStats;
-
-  /** Global log */
-  static log: Log = log;
-
-  static registerDevices(deviceClasses: any[] /* : typeof Device */): void {
-    for (const deviceClass of deviceClasses) {
-      assert(deviceClass.type && deviceClass.isSupported && deviceClass.create);
-      deviceMap.set(deviceClass.type, deviceClass);
-    }
-  }
-
-  static getAvailableDevices(): string[] {
-    // @ts-expect-error
-    return Array.from(deviceMap).map(Device => Device.type);
-  }
-
-  static getSupportedDevices(): string[] {
-    return (
-      Array.from(deviceMap)
-        // @ts-expect-error
-        .filter(Device => Device.isSupported())
-        // @ts-expect-error
-        .map(Device => Device.type)
-    );
-  }
-
-  static setDefaultDeviceProps(props: CreateDeviceProps): void {
-    Object.assign(Device.defaultProps, props);
-  }
-
-  /** Attach to an existing GPU API handle (WebGL2RenderingContext or GPUDevice). */
-  static async attachDevice(props: AttachDeviceProps): Promise<Device> {
-    const devices = getDeviceMap(props.devices) || deviceMap;
-
-    // WebGL
-    if (props.handle instanceof WebGL2RenderingContext) {
-      const WebGLDevice = devices.get('webgl') as any;
-      if (WebGLDevice) {
-        return (await WebGLDevice.attach(props.handle)) as Device;
-      }
-    }
-
-    // TODO - WebGPU does not yet have a stable API
-    // if (props.handle instanceof GPUDevice) {
-    //   const WebGPUDevice = devices.get('webgpu') as any;
-    //   if (WebGPUDevice) {
-    //     return (await WebGPUDevice.attach(props.handle)) as Device;
-    //   }
-    // }
-
-    // null
-    if (props.handle === null) {
-      const UnknownDevice = devices.get('unknown') as any;
-      if (UnknownDevice) {
-        return (await UnknownDevice.attach(null)) as Device;
-      }
-    }
-
-    throw new Error(
-      'Failed to attach device. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported.'
-    );
-  }
-
-  /** Creates a device. Asynchronously. */
-  static async createDevice(props: CreateDeviceProps = {}): Promise<Device> {
-    props = {...luma.defaultProps, ...props};
-    if (props.gl) {
-      props.type = 'webgl';
-    }
-
-    const devices = getDeviceMap(props.devices) || deviceMap;
-
-    switch (props.type) {
-      case 'webgpu':
-        let WebGPUDevice = devices.get('webgpu') as any;
-        if (WebGPUDevice) {
-          return await WebGPUDevice.create(props);
-        }
-        break;
-
-      case 'webgl':
-        let WebGLDevice = devices.get('webgl') as any;
-        if (WebGLDevice) {
-          return await WebGLDevice.create(props);
-        }
-        break;
-
-      case 'unknown':
-        const UnknownDevice = devices.get('unknown') as any;
-        if (UnknownDevice) {
-          return await UnknownDevice.create(props);
-        }
-        break;
-
-      case 'best-available':
-        WebGPUDevice = devices.get('webgpu') as any;
-        if (WebGPUDevice?.isSupported?.()) {
-          return await WebGPUDevice.create(props);
-        }
-        WebGLDevice = devices.get('webgl');
-        if (WebGLDevice?.isSupported?.()) {
-          return await WebGLDevice.create(props);
-        }
-        break;
-    }
-    throw new Error(
-      'No matching device found. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported.'
-    );
-  }
-
-  static enforceWebGL2(enforce: boolean = true): void {
-    const prototype = HTMLCanvasElement.prototype as any;
-    if (!enforce && prototype.originalGetContext) {
-      // Reset the original getContext function
-      prototype.getContext = prototype.originalGetContext;
-      prototype.originalGetContext = undefined;
-      return;
-    }
-
-    // Store the original getContext function
-    prototype.originalGetContext = prototype.getContext;
-
-    // Override the getContext function
-    prototype.getContext = function (contextId: string, options?: WebGLContextAttributes) {
-      // Attempt to force WebGL2 for all WebGL1 contexts
-      if (contextId === 'webgl' || contextId === 'experimental-webgl') {
-        return this.originalGetContext('webgl2', options);
-      }
-      // For any other type, return the original context
-      return this.originalGetContext(contextId, options);
-    };
-  }
-}
-
-/** Convert a list of devices to a map */
-function getDeviceMap(
-  deviceClasses?: any[] /* : typeof Device */
-): Map<string, typeof Device> | null {
-  if (!deviceClasses || deviceClasses?.length === 0) {
-    return null;
-  }
-  const map = new Map<string, typeof Device>();
-  for (const deviceClass of deviceClasses) {
-    // assert(deviceClass.type && deviceClass.isSupported && deviceClass.create);
-    map.set(deviceClass.type, deviceClass);
-  }
-  return map;
-}

package/src/lib/uniforms/uniform.ts

@@ -1,31 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {UniformValue} from '../../adapter/types/types';
-import type {Binding} from '../../adapter/types/shader-layout';
-import {isNumberArray} from '../../utils/is-array';
-
-export function isUniformValue(value: unknown): boolean {
-  return isNumberArray(value) !== null || typeof value === 'number' || typeof value === 'boolean';
-}
-
-type UniformsAndBindings = {
-  bindings: Record<string, Binding>;
-  uniforms: Record<string, UniformValue>;
-};
-export function splitUniformsAndBindings(
-  uniforms: Record<string, Binding | UniformValue>
-): UniformsAndBindings {
-  const result: UniformsAndBindings = {bindings: {}, uniforms: {}};
-  Object.keys(uniforms).forEach(name => {
-    const uniform = uniforms[name];
-    if (isUniformValue(uniform)) {
-      result.uniforms[name] = uniform as UniformValue;
-    } else {
-      result.bindings[name] = uniform as Binding;
-    }
-  });
-
-  return result;
-}

package/src/utils/assert.ts

@@ -1,11 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-// 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

@@ -1,8 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-/** Helper for type downcasts, e.g. Buffer -> WebGPUBuffer */
-export function cast<T>(value: any) {
-  return value as T;
-}

package/src/utils/check-props.ts

@@ -1,82 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-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

@@ -1,51 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-/**
- * 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

@@ -1,47 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-/* 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;
-}