@luma.gl/test-utils 9.0.0-alpha.2 → 9.0.0-alpha.20

package/dist/check-type.js

@@ -1,3 +1,2 @@
 export function checkType(value) {}
-;
 //# sourceMappingURL=check-type.js.map

package/dist/check-type.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/check-type.ts"],"names":["checkType","value"],"mappings":"AAKA,OAAO,SAASA,SAAT,CAAsBC,KAAtB,EAAsC,CAAE;AAAA","sourcesContent":["\n/**\n * Tests that an argument matches the type.\n * @note fails during typescript type check, not during runtime.\n */\nexport function checkType<T>(value: T): void {};\n"],"file":"check-type.js"}
+{"version":3,"file":"check-type.js","names":["checkType","value"],"sources":["../src/check-type.ts"],"sourcesContent":["\n/**\n * Tests that an argument matches the type.\n * @note fails during typescript type check, not during runtime.\n */\nexport function checkType<T>(value: T): void {}\n"],"mappings":"AAKA,OAAO,SAASA,SAASA,CAAIC,KAAQ,EAAQ,CAAC"}

package/dist/create-test-device.d.ts

@@ -1,11 +1,18 @@
 import type { Device, DeviceProps } from '@luma.gl/api';
 import { WebGLDevice } from '@luma.gl/webgl';
 import { WebGPUDevice } from '@luma.gl/webgpu';
+/** Create a test WebGL context */
+export declare function createTestContext(opts?: Record<string, any>): WebGLRenderingContext | null;
+/** Create a test WebGLDevice */
 export declare function createTestDevice(props?: DeviceProps): WebGLDevice | null;
-export declare const webgl1TestDevice: WebGLDevice;
-export declare const webgl2TestDevice: WebGLDevice;
+/** A WebGL 1 Device intended for testing */
+export declare const webgl1Device: WebGLDevice;
+/** A WebGL 2 Device intended for testing. Can be null */
+export declare const webgl2Device: WebGLDevice;
+/** A WebGL 2 or WebGL 1 Device intended for testing. Best available. */
+export declare const webglDevice: WebGLDevice;
 /** Only available after getTestDevices() has completed */
-export declare let webgpuTestDevice: WebGPUDevice;
+export declare let webgpuDevice: WebGPUDevice;
 /** Synchronously get test devices (only WebGLDevices) */
 export declare function getWebGLTestDevices(): WebGLDevice[];
 /** Includes WebGPU device if available */

package/dist/create-test-device.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-test-device.d.ts","sourceRoot":"","sources":["../src/create-test-device.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,MAAM,EAAE,WAAW,EAAC,MAAM,cAAc,CAAC;AAEtD,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAiB7C,wBAAgB,gBAAgB,CAAC,KAAK,GAAE,WAAgB,GAAG,WAAW,GAAG,IAAI,CAU5E;AAED,eAAO,MAAM,gBAAgB,EAAE,WAAuF,CAAC;AACvH,eAAO,MAAM,gBAAgB,EAAE,WAAuF,CAAC;AACvH,0DAA0D;AAC1D,eAAO,IAAI,gBAAgB,EAAE,YAAY,CAAC;AAI1C,yDAAyD;AACzD,wBAAgB,mBAAmB,IAAI,WAAW,EAAE,CAEnD;AAED,0CAA0C;AAC1C,wBAAsB,cAAc,IAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAUzD"}
+{"version":3,"file":"create-test-device.d.ts","sourceRoot":"","sources":["../src/create-test-device.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAE,WAAW,EAAC,MAAM,cAAc,CAAC;AAEtD,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAC,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAQ7C,kCAAkC;AAClC,wBAAgB,iBAAiB,CAAC,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GAAG,qBAAqB,GAAG,IAAI,CAG9F;AAED,gCAAgC;AAChC,wBAAgB,gBAAgB,CAAC,KAAK,GAAE,WAAgB,GAAG,WAAW,GAAG,IAAI,CAU5E;AAED,4CAA4C;AAC5C,eAAO,MAAM,YAAY,EAAE,WAAuF,CAAE;AACpH,yDAAyD;AACzD,eAAO,MAAM,YAAY,EAAE,WAAuF,CAAE;AACpH,wEAAwE;AACxE,eAAO,MAAM,WAAW,EAAE,WAA0C,CAAC;AAErE,0DAA0D;AAC1D,eAAO,IAAI,YAAY,EAAE,YAAY,CAAC;AAItC,yDAAyD;AACzD,wBAAgB,mBAAmB,IAAI,WAAW,EAAE,CASnD;AAED,0CAA0C;AAC1C,wBAAsB,cAAc,IAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAezD"}

package/dist/create-test-device.js

@@ -1,20 +1,21 @@
-import { isBrowser } from 'probe.gl/env';
 import { luma } from '@luma.gl/api';
 import { WebGLDevice } from '@luma.gl/webgl';
-import { createHeadlessContext } from './create-headless-context';
-const ERR_HEADLESSGL_FAILED = 'Failed to create WebGL context in Node.js, headless gl returned null';
-const ERR_HEADLESSGL_LOAD = "  luma.gl: loaded under Node.js without headless gl installed, meaning that WebGL   contexts can not be created. This may not be an error. For example, this is a   typical configuration for isorender applications running on the server.";
 const CONTEXT_DEFAULTS = {
   width: 1,
   height: 1,
   debug: true
 };
-export function createTestDevice(props = {}) {
+export function createTestContext() {
+  let opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  const device = createTestDevice(opts);
+  return device && device.gl;
+}
+export function createTestDevice() {
+  let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   try {
-    const gl = !isBrowser() ? createHeadlessContext(props) : undefined;
-    props = { ...CONTEXT_DEFAULTS,
+    props = {
+      ...CONTEXT_DEFAULTS,
       ...props,
-      gl,
       debug: true
     };
     return new WebGLDevice(props);
@@ -23,33 +24,43 @@ export function createTestDevice(props = {}) {
     return null;
   }
 }
-export const webgl1TestDevice = createTestDevice({
+export const webgl1Device = createTestDevice({
   id: 'webgl1-test-device',
   webgl1: true,
   webgl2: false
 });
-export const webgl2TestDevice = createTestDevice({
+export const webgl2Device = createTestDevice({
   id: 'webgl2-test-device',
   webgl1: false,
   webgl2: true
 });
-export let webgpuTestDevice;
+export const webglDevice = webgl2Device || webgl1Device;
+export let webgpuDevice;
 let webgpuCreated = false;
 export function getWebGLTestDevices() {
-  return [webgl2TestDevice, webgl1TestDevice].filter(Boolean);
+  const devices = [];
+  if (webgl2Device) {
+    devices.push(webgl2Device);
+  }
+  if (webgl1Device) {
+    devices.push(webgl1Device);
+  }
+  return devices;
 }
 export async function getTestDevices() {
   if (!webgpuCreated) {
     webgpuCreated = true;
-
     try {
-      webgpuTestDevice = await luma.createDevice({
+      webgpuDevice = await luma.createDevice({
         id: 'webgpu-test-device',
         type: 'webgpu'
       });
     } catch {}
   }
-
-  return [webgpuTestDevice, webgl2TestDevice, webgl1TestDevice].filter(Boolean);
+  const devices = getWebGLTestDevices();
+  if (webgpuDevice) {
+    devices.unshift(webgpuDevice);
+  }
+  return devices;
 }
 //# sourceMappingURL=create-test-device.js.map

package/dist/create-test-device.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/create-test-device.ts"],"names":["isBrowser","luma","WebGLDevice","createHeadlessContext","ERR_HEADLESSGL_FAILED","ERR_HEADLESSGL_LOAD","CONTEXT_DEFAULTS","width","height","debug","createTestDevice","props","gl","undefined","error","console","id","message","webgl1TestDevice","webgl1","webgl2","webgl2TestDevice","webgpuTestDevice","webgpuCreated","getWebGLTestDevices","filter","Boolean","getTestDevices","createDevice","type"],"mappings":"AAAA,SAAQA,SAAR,QAAwB,cAAxB;AAEA,SAAQC,IAAR,QAAmB,cAAnB;AACA,SAAQC,WAAR,QAA0B,gBAA1B;AAEA,SAAQC,qBAAR,QAAoC,2BAApC;AAEA,MAAMC,qBAAqB,GACzB,sEADF;AAGA,MAAMC,mBAAmB,gPAAzB;AAKA,MAAMC,gBAAsC,GAAG;AAC7CC,EAAAA,KAAK,EAAE,CADsC;AAE7CC,EAAAA,MAAM,EAAE,CAFqC;AAG7CC,EAAAA,KAAK,EAAE;AAHsC,CAA/C;AAMA,OAAO,SAASC,gBAAT,CAA0BC,KAAkB,GAAG,EAA/C,EAAuE;AAC5E,MAAI;AACF,UAAMC,EAAE,GAAG,CAACZ,SAAS,EAAV,GAAeG,qBAAqB,CAACQ,KAAD,CAApC,GAA8CE,SAAzD;AACAF,IAAAA,KAAK,GAAG,EAAC,GAAGL,gBAAJ;AAAsB,SAAGK,KAAzB;AAAgCC,MAAAA,EAAhC;AAAoCH,MAAAA,KAAK,EAAE;AAA3C,KAAR;AAEA,WAAO,IAAIP,WAAJ,CAAgBS,KAAhB,CAAP;AACD,GALD,CAKE,OAAOG,KAAP,EAAc;AACdC,IAAAA,OAAO,CAACD,KAAR,qCAA2CH,KAAK,CAACK,EAAjD,gBAAyDF,KAAK,CAACG,OAA/D;AACA,WAAO,IAAP;AACD;AACF;AAED,OAAO,MAAMC,gBAA6B,GAAGR,gBAAgB,CAAC;AAACM,EAAAA,EAAE,EAAE,oBAAL;AAA2BG,EAAAA,MAAM,EAAE,IAAnC;AAAyCC,EAAAA,MAAM,EAAE;AAAjD,CAAD,CAAtD;AACP,OAAO,MAAMC,gBAA6B,GAAGX,gBAAgB,CAAC;AAACM,EAAAA,EAAE,EAAE,oBAAL;AAA2BG,EAAAA,MAAM,EAAE,KAAnC;AAA0CC,EAAAA,MAAM,EAAE;AAAlD,CAAD,CAAtD;AAEP,OAAO,IAAIE,gBAAJ;AAEP,IAAIC,aAAa,GAAG,KAApB;AAGA,OAAO,SAASC,mBAAT,GAA8C;AACnD,SAAO,CAACH,gBAAD,EAAmBH,gBAAnB,EAAqCO,MAArC,CAA4CC,OAA5C,CAAP;AACD;AAGD,OAAO,eAAeC,cAAf,GAAoD;AACzD,MAAI,CAACJ,aAAL,EAAoB;AAClBA,IAAAA,aAAa,GAAG,IAAhB;;AACA,QAAI;AACFD,MAAAA,gBAAgB,GAAG,MAAMrB,IAAI,CAAC2B,YAAL,CAAkB;AAACZ,QAAAA,EAAE,EAAE,oBAAL;AAA2Ba,QAAAA,IAAI,EAAE;AAAjC,OAAlB,CAAzB;AACD,KAFD,CAEE,MAAM,CAEP;AACF;;AACD,SAAO,CAACP,gBAAD,EAAmBD,gBAAnB,EAAqCH,gBAArC,EAAuDO,MAAvD,CAA8DC,OAA9D,CAAP;AACD","sourcesContent":["import {isBrowser} from 'probe.gl/env';\nimport type {Device, DeviceProps} from '@luma.gl/api';\nimport {luma} from '@luma.gl/api';\nimport {WebGLDevice} from '@luma.gl/webgl';\nimport {WebGPUDevice} from '@luma.gl/webgpu';\nimport {createHeadlessContext} from './create-headless-context';\n\nconst ERR_HEADLESSGL_FAILED =\n  'Failed to create WebGL context in Node.js, headless gl returned null';\n\nconst ERR_HEADLESSGL_LOAD = `\\\n  luma.gl: loaded under Node.js without headless gl installed, meaning that WebGL \\\n  contexts can not be created. This may not be an error. For example, this is a \\\n  typical configuration for isorender applications running on the server.`;\n\nconst CONTEXT_DEFAULTS: Partial<DeviceProps> = {\n  width: 1,\n  height: 1,\n  debug: true\n};\n\nexport function createTestDevice(props: DeviceProps = {}): WebGLDevice | null {\n  try {\n    const gl = !isBrowser() ? createHeadlessContext(props) : undefined;\n    props = {...CONTEXT_DEFAULTS, ...props, gl, debug: true};\n    // We dont use luma.createDevice since this tests current expect this context to be created synchronously\n    return new WebGLDevice(props);\n  } catch (error) {\n    console.error(`Failed to created device '${props.id}': ${error.message}`);\n    return null;\n  }\n}\n\nexport const webgl1TestDevice: WebGLDevice = createTestDevice({id: 'webgl1-test-device', webgl1: true, webgl2: false});\nexport const webgl2TestDevice: WebGLDevice = createTestDevice({id: 'webgl2-test-device', webgl1: false, webgl2: true});\n/** Only available after getTestDevices() has completed */\nexport let webgpuTestDevice: WebGPUDevice;\n\nlet webgpuCreated = false;\n\n/** Synchronously get test devices (only WebGLDevices) */\nexport function getWebGLTestDevices(): WebGLDevice[] {\n  return [webgl2TestDevice, webgl1TestDevice].filter(Boolean);\n}\n\n/** Includes WebGPU device if available */\nexport async function getTestDevices() : Promise<Device[]> {\n  if (!webgpuCreated) {\n    webgpuCreated = true;\n    try {\n      webgpuTestDevice = await luma.createDevice({id: 'webgpu-test-device', type: 'webgpu'}) as WebGPUDevice;\n    } catch {\n      // ignore (assume WebGPU was not available)\n    }\n  }\n  return [webgpuTestDevice, webgl2TestDevice, webgl1TestDevice].filter(Boolean);\n}\n"],"file":"create-test-device.js"}
+{"version":3,"file":"create-test-device.js","names":["luma","WebGLDevice","CONTEXT_DEFAULTS","width","height","debug","createTestContext","opts","arguments","length","undefined","device","createTestDevice","gl","props","error","console","concat","id","message","webgl1Device","webgl1","webgl2","webgl2Device","webglDevice","webgpuDevice","webgpuCreated","getWebGLTestDevices","devices","push","getTestDevices","createDevice","type","unshift"],"sources":["../src/create-test-device.ts"],"sourcesContent":["// luma.gl, MIT license\n\nimport type {Device, DeviceProps} from '@luma.gl/api';\nimport {luma} from '@luma.gl/api';\nimport {WebGLDevice} from '@luma.gl/webgl';\nimport {WebGPUDevice} from '@luma.gl/webgpu';\n\nconst CONTEXT_DEFAULTS: Partial<DeviceProps> = {\n  width: 1,\n  height: 1,\n  debug: true\n};\n\n/** Create a test WebGL context */\nexport function createTestContext(opts: Record<string, any> = {}): WebGLRenderingContext | null {\n  const device = createTestDevice(opts);\n  return device && device.gl;\n}\n\n/** Create a test WebGLDevice */\nexport function createTestDevice(props: DeviceProps = {}): WebGLDevice | null {\n  try {\n    props = {...CONTEXT_DEFAULTS, ...props, debug: true};\n    // We dont use luma.createDevice since this tests current expect this context to be created synchronously\n    return new WebGLDevice(props);\n  } catch (error) {\n    // eslint-disable-next-line no-console\n    console.error(`Failed to created device '${props.id}': ${(error as Error).message}`);\n    return null;\n  }\n}\n\n/** A WebGL 1 Device intended for testing */\nexport const webgl1Device: WebGLDevice = createTestDevice({id: 'webgl1-test-device', webgl1: true, webgl2: false}) ;\n/** A WebGL 2 Device intended for testing. Can be null */\nexport const webgl2Device: WebGLDevice = createTestDevice({id: 'webgl2-test-device', webgl1: false, webgl2: true}) ;\n/** A WebGL 2 or WebGL 1 Device intended for testing. Best available. */\nexport const webglDevice: WebGLDevice = webgl2Device || webgl1Device;\n\n/** Only available after getTestDevices() has completed */\nexport let webgpuDevice: WebGPUDevice;\n\nlet webgpuCreated = false;\n\n/** Synchronously get test devices (only WebGLDevices) */\nexport function getWebGLTestDevices(): WebGLDevice[] {\n  const devices: WebGLDevice[] = [];\n  if (webgl2Device) {\n    devices.push(webgl2Device);\n  }\n  if (webgl1Device) {\n    devices.push(webgl1Device);\n  }\n  return devices;\n}\n\n/** Includes WebGPU device if available */\nexport async function getTestDevices() : Promise<Device[]> {\n  if (!webgpuCreated) {\n    webgpuCreated = true;\n    try {\n      webgpuDevice = await luma.createDevice({id: 'webgpu-test-device', type: 'webgpu'}) as WebGPUDevice;\n    } catch {\n      // ignore (assume WebGPU was not available)\n    }\n  }\n\n  const devices: Device[] = getWebGLTestDevices();\n  if (webgpuDevice) {\n    devices.unshift(webgpuDevice);\n  }\n  return devices;\n}\n"],"mappings":"AAGA,SAAQA,IAAI,QAAO,cAAc;AACjC,SAAQC,WAAW,QAAO,gBAAgB;AAG1C,MAAMC,gBAAsC,GAAG;EAC7CC,KAAK,EAAE,CAAC;EACRC,MAAM,EAAE,CAAC;EACTC,KAAK,EAAE;AACT,CAAC;AAGD,OAAO,SAASC,iBAAiBA,CAAA,EAA+D;EAAA,IAA9DC,IAAyB,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EAC9D,MAAMG,MAAM,GAAGC,gBAAgB,CAACL,IAAI,CAAC;EACrC,OAAOI,MAAM,IAAIA,MAAM,CAACE,EAAE;AAC5B;AAGA,OAAO,SAASD,gBAAgBA,CAAA,EAA8C;EAAA,IAA7CE,KAAkB,GAAAN,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,CAAC,CAAC;EACtD,IAAI;IACFM,KAAK,GAAG;MAAC,GAAGZ,gBAAgB;MAAE,GAAGY,KAAK;MAAET,KAAK,EAAE;IAAI,CAAC;IAEpD,OAAO,IAAIJ,WAAW,CAACa,KAAK,CAAC;EAC/B,CAAC,CAAC,OAAOC,KAAK,EAAE;IAEdC,OAAO,CAACD,KAAK,8BAAAE,MAAA,CAA8BH,KAAK,CAACI,EAAE,SAAAD,MAAA,CAAOF,KAAK,CAAWI,OAAO,EAAG;IACpF,OAAO,IAAI;EACb;AACF;AAGA,OAAO,MAAMC,YAAyB,GAAGR,gBAAgB,CAAC;EAACM,EAAE,EAAE,oBAAoB;EAAEG,MAAM,EAAE,IAAI;EAAEC,MAAM,EAAE;AAAK,CAAC,CAAC;AAElH,OAAO,MAAMC,YAAyB,GAAGX,gBAAgB,CAAC;EAACM,EAAE,EAAE,oBAAoB;EAAEG,MAAM,EAAE,KAAK;EAAEC,MAAM,EAAE;AAAI,CAAC,CAAC;AAElH,OAAO,MAAME,WAAwB,GAAGD,YAAY,IAAIH,YAAY;AAGpE,OAAO,IAAIK,YAA0B;AAErC,IAAIC,aAAa,GAAG,KAAK;AAGzB,OAAO,SAASC,mBAAmBA,CAAA,EAAkB;EACnD,MAAMC,OAAsB,GAAG,EAAE;EACjC,IAAIL,YAAY,EAAE;IAChBK,OAAO,CAACC,IAAI,CAACN,YAAY,CAAC;EAC5B;EACA,IAAIH,YAAY,EAAE;IAChBQ,OAAO,CAACC,IAAI,CAACT,YAAY,CAAC;EAC5B;EACA,OAAOQ,OAAO;AAChB;AAGA,OAAO,eAAeE,cAAcA,CAAA,EAAuB;EACzD,IAAI,CAACJ,aAAa,EAAE;IAClBA,aAAa,GAAG,IAAI;IACpB,IAAI;MACFD,YAAY,GAAG,MAAMzB,IAAI,CAAC+B,YAAY,CAAC;QAACb,EAAE,EAAE,oBAAoB;QAAEc,IAAI,EAAE;MAAQ,CAAC,CAAiB;IACpG,CAAC,CAAC,MAAM,CAER;EACF;EAEA,MAAMJ,OAAiB,GAAGD,mBAAmB,EAAE;EAC/C,IAAIF,YAAY,EAAE;IAChBG,OAAO,CAACK,OAAO,CAACR,YAAY,CAAC;EAC/B;EACA,OAAOG,OAAO;AAChB"}

package/dist/index.cjs

@@ -0,0 +1,404 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  PerformanceTestRunner: () => PerformanceTestRunner,
+  SnapshotTestRunner: () => SnapshotTestRunner,
+  checkType: () => checkType,
+  createTestContext: () => createTestContext,
+  createTestDevice: () => createTestDevice,
+  getTestDevices: () => getTestDevices,
+  getWebGLTestDevices: () => getWebGLTestDevices,
+  webgl1Device: () => webgl1Device,
+  webgl2Device: () => webgl2Device,
+  webgpuDevice: () => webgpuDevice
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/register-devices.ts
+var import_api = require("@luma.gl/api");
+var import_webgl = require("@luma.gl/webgl");
+var import_webgpu = require("@luma.gl/webgpu");
+var import_gl = __toESM(require("gl"), 1);
+(0, import_webgl.registerHeadlessGL)(import_gl.default);
+import_api.luma.registerDevices([import_webgl.WebGLDevice, import_webgpu.WebGPUDevice]);
+
+// src/test-runner.ts
+var import_webgl_legacy = require("@luma.gl/webgl-legacy");
+
+// src/create-test-device.ts
+var import_api2 = require("@luma.gl/api");
+var import_webgl2 = require("@luma.gl/webgl");
+var CONTEXT_DEFAULTS = {
+  width: 1,
+  height: 1,
+  debug: true
+};
+function createTestContext(opts = {}) {
+  const device = createTestDevice(opts);
+  return device && device.gl;
+}
+function createTestDevice(props = {}) {
+  try {
+    props = __spreadProps(__spreadValues(__spreadValues({}, CONTEXT_DEFAULTS), props), { debug: true });
+    return new import_webgl2.WebGLDevice(props);
+  } catch (error) {
+    console.error(`Failed to created device '${props.id}': ${error.message}`);
+    return null;
+  }
+}
+var webgl1Device = createTestDevice({ id: "webgl1-test-device", webgl1: true, webgl2: false });
+var webgl2Device = createTestDevice({ id: "webgl2-test-device", webgl1: false, webgl2: true });
+var webglDevice = webgl2Device || webgl1Device;
+var webgpuDevice;
+var webgpuCreated = false;
+function getWebGLTestDevices() {
+  const devices = [];
+  if (webgl2Device) {
+    devices.push(webgl2Device);
+  }
+  if (webgl1Device) {
+    devices.push(webgl1Device);
+  }
+  return devices;
+}
+function getTestDevices() {
+  return __async(this, null, function* () {
+    if (!webgpuCreated) {
+      webgpuCreated = true;
+      try {
+        webgpuDevice = yield import_api2.luma.createDevice({ id: "webgpu-test-device", type: "webgpu" });
+      } catch (e) {
+      }
+    }
+    const devices = getWebGLTestDevices();
+    if (webgpuDevice) {
+      devices.unshift(webgpuDevice);
+    }
+    return devices;
+  });
+}
+
+// src/test-runner.ts
+function noop() {
+}
+var DEFAULT_TEST_CASE = {
+  name: "Unnamed test",
+  onInitialize: noop,
+  onRender: ({ done }) => done(),
+  onFinalize: noop
+};
+var DEFAULT_TEST_PROPS = {
+  // test lifecycle callback
+  onTestStart: (testCase) => console.log(`# ${testCase.name}`),
+  onTestPass: (testCase) => console.log(`ok ${testCase.name} passed`),
+  onTestFail: (testCase) => console.log(`not ok ${testCase.name} failed`),
+  // milliseconds to wait for each test case before aborting
+  timeout: 2e3
+};
+var TestRunner = class {
+  /**
+   * props
+   *   AnimationLoop props
+   */
+  constructor(props = {}) {
+    this.device = webglDevice;
+    this.isRunning = false;
+    this.testOptions = __spreadValues({}, DEFAULT_TEST_PROPS);
+    this._animationProps = {};
+    this._testCases = [];
+    this._testCaseData = null;
+    // @ts-expect-error
+    this.isHeadless = Boolean(window.browserTestDriver_isHeadless);
+    this.props = props;
+  }
+  /**
+   * Add testCase(s)
+   */
+  add(testCases) {
+    if (!Array.isArray(testCases)) {
+      testCases = [testCases];
+    }
+    for (const testCase of testCases) {
+      this._testCases.push(testCase);
+    }
+    return this;
+  }
+  /**
+    * Returns a promise that resolves when all the test cases are done
+    */
+  run(options = {}) {
+    this.testOptions = __spreadValues(__spreadValues({}, this.testOptions), options);
+    return new Promise((resolve, reject) => {
+      this._animationLoop = new import_webgl_legacy.AnimationLoop(__spreadProps(__spreadValues({}, this.props), {
+        device: this.device,
+        onRender: this._onRender.bind(this),
+        onFinalize: () => {
+          this.isRunning = false;
+          resolve();
+        }
+      }));
+      this._animationLoop.start(this.props);
+      this.isRunning = true;
+      this.isDiffing = false;
+      this._currentTestCase = null;
+    }).catch((error) => {
+      this._fail({ error: error.message });
+    });
+  }
+  /* Lifecycle methods for subclassing */
+  initTestCase(testCase) {
+    const { animationLoop } = testCase;
+    if (animationLoop) {
+      testCase.onInitialize = animationLoop.props.onInitialize.bind(animationLoop);
+      testCase.onRender = animationLoop.props.onRender.bind(animationLoop);
+      testCase.onFinalize = animationLoop.props.onFinalize.bind(animationLoop);
+    }
+    for (const key in DEFAULT_TEST_CASE) {
+      testCase[key] = testCase[key] || DEFAULT_TEST_CASE[key];
+    }
+  }
+  shouldRender(animationProps) {
+    return true;
+  }
+  assert(testCase) {
+    this._pass(testCase);
+    this._next();
+  }
+  /* Utilities */
+  _pass(result) {
+    this.testOptions.onTestPass(this._currentTestCase, result);
+  }
+  _fail(result) {
+    this.testOptions.onTestFail(this._currentTestCase, result);
+  }
+  _next() {
+    this._nextTestCase();
+  }
+  /* Private methods */
+  _onRender(animationProps) {
+    this._animationProps = animationProps;
+    const testCase = this._currentTestCase || this._nextTestCase();
+    if (!testCase) {
+      this._animationLoop.stop();
+      return;
+    }
+    let isDone = false;
+    const testCaseAnimationProps = __spreadProps(__spreadValues(__spreadValues({}, animationProps), this._testCaseData), {
+      // tick/time starts from 0 for each test case
+      startTime: this._currentTestCaseStartTime,
+      time: animationProps.time - this._currentTestCaseStartTime,
+      tick: animationProps.tick - this._currentTestCaseStartTick,
+      // called by the test case when it is done rendering and ready for capture and diff
+      done: () => {
+        isDone = true;
+      }
+    });
+    if (this._testCaseData && this.shouldRender(testCaseAnimationProps)) {
+      testCase.onRender(testCaseAnimationProps);
+    }
+    const timeout = testCase.timeout || this.testOptions.timeout;
+    if (timeout && testCaseAnimationProps.time > timeout) {
+      isDone = true;
+    }
+    if (isDone) {
+      this.assert(testCase);
+    }
+  }
+  _nextTestCase() {
+    const animationProps = this._animationProps;
+    if (this._testCaseData) {
+      for (const key in this._testCaseData) {
+        const value = this._testCaseData[key];
+        if (value && value.delete) {
+          value.delete();
+        }
+      }
+      this._currentTestCase.onFinalize(Object.assign({}, animationProps, this._testCaseData));
+      this.device.popState();
+      this._currentTestCase = null;
+      this._testCaseData = null;
+    }
+    const testCase = this._testCases.shift();
+    if (testCase) {
+      this._currentTestCase = testCase;
+      this._currentTestCaseStartTime = animationProps.time;
+      this._currentTestCaseStartTick = animationProps.tick;
+      this.initTestCase(testCase);
+      this.device.pushState();
+      const initProps = __spreadProps(__spreadValues({}, animationProps), {
+        // tick/time starts from 0 for each test case
+        startTime: animationProps.time,
+        time: 0,
+        tick: 0
+      });
+      Promise.resolve(testCase.onInitialize(initProps)).then((userData) => {
+        this._testCaseData = userData || {};
+      });
+      this.testOptions.onTestStart(testCase);
+    }
+    return testCase;
+  }
+};
+
+// src/utils.ts
+function getBoundingBoxInPage(domElement) {
+  const bbox = domElement.getBoundingClientRect();
+  return {
+    x: window.scrollX + bbox.x,
+    y: window.scrollY + bbox.y,
+    width: bbox.width,
+    height: bbox.height
+  };
+}
+
+// src/snapshot-test-runner.ts
+var SnapshotTestRunner = class extends TestRunner {
+  constructor(props) {
+    super(props);
+    this.isDiffing = false;
+    this.testOptions.imageDiffOptions = {};
+  }
+  initTestCase(testCase) {
+    super.initTestCase(testCase);
+    if (!testCase.goldenImage) {
+      throw new Error(`Test case ${testCase.name} does not have golden image`);
+    }
+  }
+  shouldRender() {
+    return !this.isDiffing;
+  }
+  assert(testCase) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDiffing) {
+        return;
+      }
+      this.isDiffing = true;
+      const canvas = (_a = this._animationProps) == null ? void 0 : _a.canvas;
+      if (!(canvas instanceof HTMLCanvasElement)) {
+        throw new Error("canvas");
+      }
+      const diffOptions = __spreadProps(__spreadValues(__spreadValues({}, this.testOptions.imageDiffOptions), testCase.imageDiffOptions), {
+        goldenImage: testCase.goldenImage,
+        region: getBoundingBoxInPage(canvas)
+      });
+      const result = yield globalThis.browserTestDriver_captureAndDiffScreen(diffOptions);
+      if (result.success) {
+        this._pass(result);
+      } else {
+        this._fail(result);
+      }
+      this.isDiffing = false;
+      this._next();
+    });
+  }
+};
+
+// src/performance-test-runner.ts
+var import_stats = require("@probe.gl/stats");
+var PerformanceTestRunner = class extends TestRunner {
+  constructor(props) {
+    super(props);
+    this._stats = null;
+    this._fps = null;
+    Object.assign(this.testOptions, {
+      maxFramesToRender: 60,
+      targetFPS: 50
+    });
+  }
+  initTestCase(testCase) {
+    super.initTestCase(testCase);
+    this._stats = new import_stats.Stats({ id: testCase.name });
+    this._fps = this._stats.get("fps");
+  }
+  shouldRender(animationProps) {
+    var _a, _b;
+    (_a = this._fps) == null ? void 0 : _a.timeEnd();
+    (_b = this._fps) == null ? void 0 : _b.timeStart();
+    if (this._fps.count > this.testOptions.maxFramesToRender) {
+      animationProps.done();
+    }
+    return true;
+  }
+  assert(testCase) {
+    var _a, _b;
+    const targetFPS = testCase.targetFPS || this.testOptions.targetFPS;
+    const count = (_a = this._fps) == null ? void 0 : _a.count;
+    const fps = ((_b = this._fps) == null ? void 0 : _b.getHz()) || 0;
+    if (fps >= targetFPS) {
+      this._pass({ fps, framesRendered: count });
+    } else {
+      this._fail({ fps, framesRendered: count });
+    }
+    this._next();
+  }
+};
+
+// src/check-type.ts
+function checkType(value) {
+}

package/dist/index.d.ts

@@ -1,10 +1,9 @@
+import './register-devices';
 export type { TestRunnerTestCase } from './test-runner';
 export type { SnapshotTestRunnerTestCase } from './snapshot-test-runner';
 export { default as SnapshotTestRunner } from './snapshot-test-runner';
 export { default as PerformanceTestRunner } from './performance-test-runner';
-export { createHeadlessContext } from './create-headless-context';
-export { createTestContext } from './create-test-context';
-export { createTestDevice, webgl1TestDevice, webgl2TestDevice, webgpuTestDevice } from './create-test-device';
+export { createTestDevice, createTestContext, webgl1Device, webgl2Device, webgpuDevice } from './create-test-device';
 export { getTestDevices, getWebGLTestDevices } from './create-test-device';
 export { checkType } from './check-type';
 //# 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,YAAY,EAAC,kBAAkB,EAAC,MAAM,eAAe,CAAC;AACtD,YAAY,EAAC,0BAA0B,EAAC,MAAM,wBAAwB,CAAC;AAEvE,OAAO,EAAC,OAAO,IAAI,kBAAkB,EAAC,MAAM,wBAAwB,CAAC;AACrE,OAAO,EAAC,OAAO,IAAI,qBAAqB,EAAC,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAC,qBAAqB,EAAC,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAC,iBAAiB,EAAC,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAC,gBAAgB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,gBAAgB,EAAC,MAAM,sBAAsB,CAAC;AAC5G,OAAO,EAAC,cAAc,EAAE,mBAAmB,EAAC,MAAM,sBAAsB,CAAC;AAEzE,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,oBAAoB,CAAC;AAE5B,YAAY,EAAC,kBAAkB,EAAC,MAAM,eAAe,CAAC;AACtD,YAAY,EAAC,0BAA0B,EAAC,MAAM,wBAAwB,CAAC;AAEvE,OAAO,EAAC,OAAO,IAAI,kBAAkB,EAAC,MAAM,wBAAwB,CAAC;AACrE,OAAO,EAAC,OAAO,IAAI,qBAAqB,EAAC,MAAM,2BAA2B,CAAC;AAC3E,OAAO,EAAC,gBAAgB,EAAE,iBAAiB,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAC,MAAM,sBAAsB,CAAC;AACnH,OAAO,EAAC,cAAc,EAAE,mBAAmB,EAAC,MAAM,sBAAsB,CAAC;AAEzE,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -1,8 +1,7 @@
-export { default as SnapshotTestRunner } from './snapshot-test-runner';
-export { default as PerformanceTestRunner } from './performance-test-runner';
-export { createHeadlessContext } from './create-headless-context';
-export { createTestContext } from './create-test-context';
-export { createTestDevice, webgl1TestDevice, webgl2TestDevice, webgpuTestDevice } from './create-test-device';
-export { getTestDevices, getWebGLTestDevices } from './create-test-device';
-export { checkType } from './check-type';
+import "./register-devices.js";
+export { default as SnapshotTestRunner } from "./snapshot-test-runner.js";
+export { default as PerformanceTestRunner } from "./performance-test-runner.js";
+export { createTestDevice, createTestContext, webgl1Device, webgl2Device, webgpuDevice } from "./create-test-device.js";
+export { getTestDevices, getWebGLTestDevices } from "./create-test-device.js";
+export { checkType } from "./check-type.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"names":["default","SnapshotTestRunner","PerformanceTestRunner","createHeadlessContext","createTestContext","createTestDevice","webgl1TestDevice","webgl2TestDevice","webgpuTestDevice","getTestDevices","getWebGLTestDevices","checkType"],"mappings":"AAGA,SAAQA,OAAO,IAAIC,kBAAnB,QAA4C,wBAA5C;AACA,SAAQD,OAAO,IAAIE,qBAAnB,QAA+C,2BAA/C;AACA,SAAQC,qBAAR,QAAoC,2BAApC;AACA,SAAQC,iBAAR,QAAgC,uBAAhC;AACA,SAAQC,gBAAR,EAA0BC,gBAA1B,EAA4CC,gBAA5C,EAA8DC,gBAA9D,QAAqF,sBAArF;AACA,SAAQC,cAAR,EAAwBC,mBAAxB,QAAkD,sBAAlD;AAEA,SAAQC,SAAR,QAAwB,cAAxB","sourcesContent":["export type {TestRunnerTestCase} from './test-runner';\nexport type {SnapshotTestRunnerTestCase} from './snapshot-test-runner';\n\nexport {default as SnapshotTestRunner} from './snapshot-test-runner';\nexport {default as PerformanceTestRunner} from './performance-test-runner';\nexport {createHeadlessContext} from './create-headless-context';\nexport {createTestContext} from './create-test-context';\nexport {createTestDevice, webgl1TestDevice, webgl2TestDevice, webgpuTestDevice} from './create-test-device';\nexport {getTestDevices, getWebGLTestDevices} from './create-test-device';\n\nexport {checkType} from './check-type';\n"],"file":"index.js"}
+{"version":3,"file":"index.js","names":["default","SnapshotTestRunner","PerformanceTestRunner","createTestDevice","createTestContext","webgl1Device","webgl2Device","webgpuDevice","getTestDevices","getWebGLTestDevices","checkType"],"sources":["../src/index.ts"],"sourcesContent":["import './register-devices';\n\nexport type {TestRunnerTestCase} from './test-runner';\nexport type {SnapshotTestRunnerTestCase} from './snapshot-test-runner';\n\nexport {default as SnapshotTestRunner} from './snapshot-test-runner';\nexport {default as PerformanceTestRunner} from './performance-test-runner';\nexport {createTestDevice, createTestContext, webgl1Device, webgl2Device, webgpuDevice} from './create-test-device';\nexport {getTestDevices, getWebGLTestDevices} from './create-test-device';\n\nexport {checkType} from './check-type';\n"],"mappings":";SAKQA,OAAO,IAAIC,kBAAkB;AAAA,SAC7BD,OAAO,IAAIE,qBAAqB;AAAA,SAChCC,gBAAgB,EAAEC,iBAAiB,EAAEC,YAAY,EAAEC,YAAY,EAAEC,YAAY;AAAA,SAC7EC,cAAc,EAAEC,mBAAmB;AAAA,SAEnCC,SAAS"}

package/dist/performance-test-runner.d.ts

@@ -1,10 +1,11 @@
-import TestRunner, { TestRunnerOptions } from './test-runner';
+import TestRunner, { TestRunnerProps, TestRunnerTestCase } from './test-runner';
+export declare type PerformanceTestRunnerProps = TestRunnerProps;
 export default class PerformanceTestRunner extends TestRunner {
     private _stats;
     private _fps;
-    constructor(props: TestRunnerOptions);
-    initTestCase(testCase: any): void;
-    shouldRender(animationProps: any): boolean;
-    assert(testCase: any): void;
+    constructor(props: PerformanceTestRunnerProps);
+    initTestCase(testCase: TestRunnerTestCase): void;
+    shouldRender(animationProps: Record<string, any>): boolean;
+    assert(testCase: TestRunnerTestCase): void;
 }
 //# sourceMappingURL=performance-test-runner.d.ts.map

package/dist/performance-test-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"performance-test-runner.d.ts","sourceRoot":"","sources":["../src/performance-test-runner.ts"],"names":[],"mappings":"AACA,OAAO,UAAU,EAAE,EAAC,iBAAiB,EAAC,MAAM,eAAe,CAAC;AAE5D,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,UAAU;IAC3D,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,IAAI,CAAO;gBAEP,KAAK,EAAE,iBAAiB;IASpC,YAAY,CAAC,QAAQ,KAAA;IAMrB,YAAY,CAAC,cAAc,KAAA;IAY3B,MAAM,CAAC,QAAQ,KAAA;CAahB"}
+{"version":3,"file":"performance-test-runner.d.ts","sourceRoot":"","sources":["../src/performance-test-runner.ts"],"names":[],"mappings":"AAGA,OAAO,UAAU,EAAE,EAAC,eAAe,EAAE,kBAAkB,EAAC,MAAM,eAAe,CAAC;AAE9E,oBAAY,0BAA0B,GAAG,eAAe,CAAC;AAEzD,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,UAAU;IAC3D,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,IAAI,CAAqB;gBAErB,KAAK,EAAE,0BAA0B;IASpC,YAAY,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI;IAMhD,YAAY,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO;IAW1D,MAAM,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI;CAapD"}