@luma.gl/test-utils 9.0.0-beta.5 → 9.0.0-beta.7

package/dist/index.cjs

@@ -2,6 +2,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,10 +16,15 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 
 // dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
+  NullDevice: () => NullDevice,
   PerformanceTestRunner: () => PerformanceTestRunner,
   SnapshotTestRunner: () => SnapshotTestRunner,
   checkType: () => checkType,
@@ -28,7 +34,6 @@ __export(dist_exports, {
   getLeakedResources: () => getLeakedResources,
   getResourceCounts: () => getResourceCounts,
   getTestDevices: () => getTestDevices,
-  getWebGLTestDevices: () => getWebGLTestDevices,
   webglDevice: () => webglDevice,
   webgpuDevice: () => webgpuDevice
 });
@@ -61,27 +66,31 @@ function createTestDevice(props = {}) {
     return null;
   }
 }
-var webglDevice = createTestDevice({ id: "webgl2-test-device" });
+var webglDevice = createTestDevice();
+var webglDeviceAsync;
 var webgpuDevice;
-var webgpuCreated = false;
-function getWebGLTestDevices() {
-  const devices = [];
-  devices.push(webglDevice);
-  return devices;
-}
-async function getTestDevices() {
-  if (!webgpuCreated) {
-    webgpuCreated = true;
+var devicesCreated = false;
+async function getTestDevices(type) {
+  if (!devicesCreated) {
+    devicesCreated = true;
     try {
-      webgpuDevice = await import_core2.luma.createDevice({ id: "webgpu-test-device", type: "webgpu" });
-    } catch {
+      webgpuDevice = await import_core2.luma.createDevice({
+        id: "webgpu-test-device",
+        type: "webgpu"
+      });
+    } catch (error) {
+      import_core2.log.error(String(error))();
+    }
+    try {
+      webglDeviceAsync = await import_core2.luma.createDevice({
+        id: "webgl-test-device",
+        type: "webgl"
+      });
+    } catch (error) {
+      import_core2.log.error(String(error))();
     }
   }
-  const devices = getWebGLTestDevices();
-  if (webgpuDevice) {
-    devices.unshift(webgpuDevice);
-  }
-  return devices;
+  return [webglDeviceAsync, webgpuDevice].filter(Boolean).filter((device) => !type || type === device.type);
 }
 
 // dist/engine/classic-animation-loop.js
@@ -588,8 +597,8 @@ var TestRunner = class {
     return this;
   }
   /**
-    * Returns a promise that resolves when all the test cases are done
-    */
+   * Returns a promise that resolves when all the test cases are done
+   */
   run(options = {}) {
     this.testOptions = { ...this.testOptions, ...options };
     return new Promise((resolve, reject) => {
@@ -803,6 +812,531 @@ var PerformanceTestRunner = class extends TestRunner {
   }
 };
 
+// dist/null-device/null-device.js
+var import_core18 = require("@luma.gl/core");
+
+// dist/null-device/null-device-info.js
+var NullDeviceInfo = {
+  type: "webgl",
+  gpu: "software",
+  gpuType: "unknown",
+  gpuBackend: "unknown",
+  vendor: "",
+  renderer: "none",
+  version: "1.0",
+  shadingLanguage: "glsl",
+  shadingLanguageVersion: 300
+};
+
+// dist/null-device/null-device-features.js
+var import_core4 = require("@luma.gl/core");
+var NullDeviceLimits = class extends import_core4.DeviceLimits {
+  maxTextureDimension1D = 0;
+  maxTextureDimension2D = 2048;
+  maxTextureDimension3D = 256;
+  maxTextureArrayLayers = 256;
+  maxBindGroups = 0;
+  maxDynamicUniformBuffersPerPipelineLayout = 0;
+  maxDynamicStorageBuffersPerPipelineLayout = 0;
+  maxSampledTexturesPerShaderStage = 8;
+  maxSamplersPerShaderStage = 16;
+  maxStorageBuffersPerShaderStage = 0;
+  maxStorageTexturesPerShaderStage = 0;
+  maxUniformBuffersPerShaderStage = 20;
+  maxUniformBufferBindingSize = 16384;
+  maxStorageBufferBindingSize = 0;
+  minUniformBufferOffsetAlignment = 0;
+  minStorageBufferOffsetAlignment = 0;
+  maxVertexBuffers = 16;
+  maxVertexAttributes = 16;
+  maxVertexBufferArrayStride = 2048;
+  maxInterStageShaderComponents = 60;
+  maxComputeWorkgroupStorageSize = 0;
+  maxComputeInvocationsPerWorkgroup = 0;
+  maxComputeWorkgroupSizeX = 0;
+  maxComputeWorkgroupSizeY = 0;
+  maxComputeWorkgroupSizeZ = 0;
+  maxComputeWorkgroupsPerDimension = 0;
+};
+
+// dist/null-device/null-canvas-context.js
+var import_core6 = require("@luma.gl/core");
+
+// dist/null-device/resources/null-framebuffer.js
+var import_core5 = require("@luma.gl/core");
+var NullFramebuffer = class extends import_core5.Framebuffer {
+  device;
+  constructor(device, props) {
+    super(device, props);
+    this.device = device;
+  }
+};
+
+// dist/null-device/null-canvas-context.js
+var NullCanvasContext = class extends import_core6.CanvasContext {
+  device;
+  presentationSize;
+  _framebuffer = null;
+  constructor(device, props) {
+    super(props);
+    this.device = device;
+    this.presentationSize = [-1, -1];
+    this._setAutoCreatedCanvasId(`${this.device.id}-canvas`);
+    this.update();
+  }
+  getCurrentFramebuffer() {
+    this.update();
+    this._framebuffer = this._framebuffer || new NullFramebuffer(this.device, { handle: null });
+    return this._framebuffer;
+  }
+  /** Resizes and updates render targets if necessary */
+  update() {
+    const size = this.getPixelSize();
+    const sizeChanged = size[0] !== this.presentationSize[0] || size[1] !== this.presentationSize[1];
+    if (sizeChanged) {
+      this.presentationSize = size;
+      this.resize();
+    }
+  }
+  resize(options) {
+    if (this.canvas) {
+      const devicePixelRatio = this.getDevicePixelRatio(options == null ? void 0 : options.useDevicePixels);
+      this.setDevicePixelRatio(devicePixelRatio, options);
+      return;
+    }
+  }
+  getDrawingBufferSize() {
+    return [this.width, this.height];
+  }
+  commit() {
+  }
+};
+
+// dist/null-device/resources/null-buffer.js
+var import_core7 = require("@luma.gl/core");
+var NullBuffer = class extends import_core7.Buffer {
+  device;
+  byteLength;
+  constructor(device, props = {}) {
+    super(device, props);
+    this.device = device;
+    const byteOffset = props.byteOffset || 0;
+    const byteLength = props.byteLength ?? (props.data ? props.data.byteLength + byteOffset : 0);
+    (0, import_core7.assert)(byteLength >= 0);
+    this.byteLength = byteLength;
+    this.trackAllocatedMemory(byteLength);
+  }
+  destroy() {
+    if (!this.destroyed) {
+      super.destroy();
+      this.trackDeallocatedMemory();
+    }
+  }
+  async readAsync(byteOffset = 0, byteLength) {
+    byteLength = byteLength ?? this.byteLength - byteOffset;
+    return new Uint8Array(byteLength);
+  }
+  write(data, byteOffset = 0) {
+    (0, import_core7.assert)(data.byteLength + byteOffset <= this.byteLength);
+  }
+};
+
+// dist/null-device/resources/null-shader.js
+var import_core8 = require("@luma.gl/core");
+var NullShader = class extends import_core8.Shader {
+  device;
+  constructor(device, props) {
+    super(device, props);
+    this.device = device;
+  }
+  async getCompilationInfo() {
+    return [];
+  }
+};
+
+// dist/null-device/resources/null-command-buffer.js
+var import_core9 = require("@luma.gl/core");
+var NullCommandEncoder = class extends import_core9.CommandEncoder {
+  device;
+  constructor(device, props) {
+    super(device, props);
+    this.device = device;
+  }
+  finish() {
+  }
+  copyBufferToBuffer(options) {
+  }
+  copyBufferToTexture(options) {
+  }
+  copyTextureToBuffer(options) {
+  }
+  copyTextureToTexture(options) {
+  }
+  pushDebugGroup(groupLabel) {
+  }
+  popDebugGroup() {
+  }
+  insertDebugMarker(markerLabel) {
+  }
+  resolveQuerySet(querySet) {
+  }
+};
+
+// dist/null-device/resources/null-sampler.js
+var import_core10 = require("@luma.gl/core");
+var NullSampler = class extends import_core10.Sampler {
+  device;
+  constructor(device, props) {
+    super(device, props);
+    this.device = device;
+  }
+};
+
+// dist/null-device/resources/null-texture.js
+var import_core12 = require("@luma.gl/core");
+
+// dist/null-device/resources/null-texture-view.js
+var import_core11 = require("@luma.gl/core");
+var NullTextureView = class extends import_core11.TextureView {
+  device;
+  texture;
+  constructor(device, props) {
+    super(device, { ...import_core11.Texture.defaultProps, ...props });
+    this.device = device;
+    this.texture = props.texture;
+  }
+};
+
+// dist/null-device/resources/null-texture.js
+var NullTexture = class extends import_core12.Texture {
+  device;
+  sampler;
+  view;
+  constructor(device, props) {
+    var _a;
+    super(device, props);
+    this.device = device;
+    if (typeof ((_a = this.props) == null ? void 0 : _a.data) === "string") {
+      Object.assign(this.props, { data: (0, import_core12.loadImage)(this.props.data) });
+    }
+    this.initialize(this.props);
+    Object.seal(this);
+  }
+  destroy() {
+    if (!this.destroyed) {
+      super.destroy();
+      this.trackDeallocatedMemory("Texture");
+    }
+  }
+  createView(props) {
+    return new NullTextureView(this.device, { ...props, texture: this });
+  }
+  initialize(props = {}) {
+    const data = props.data;
+    if (data instanceof Promise) {
+      data.then((resolvedImageData) => this.initialize(Object.assign({}, props, {
+        pixels: resolvedImageData,
+        data: resolvedImageData
+      })));
+      return this;
+    }
+    this.setImageData(props);
+    this.setSampler(props.sampler);
+    this.view = new NullTextureView(this.device, {
+      ...props,
+      texture: this,
+      mipLevelCount: 1,
+      arrayLayerCount: 1
+    });
+    return this;
+  }
+  setSampler(sampler = {}) {
+    if (sampler instanceof NullSampler) {
+      this.sampler = sampler;
+    } else {
+      this.sampler = new NullSampler(this.device, sampler);
+    }
+    return this;
+  }
+  resize(options) {
+    const { height, width, mipmaps = false } = options;
+    if (width !== this.width || height !== this.height) {
+      return this.initialize({
+        width,
+        height,
+        mipmaps
+      });
+    }
+    return this;
+  }
+  setImageData(options) {
+    this.trackDeallocatedMemory("Texture");
+    const { data } = options;
+    if (data && data.byteLength) {
+      this.trackAllocatedMemory(data.byteLength, "Texture");
+    } else {
+      const bytesPerPixel = 4;
+      this.trackAllocatedMemory(this.width * this.height * bytesPerPixel, "Texture");
+    }
+    const width = options.width ?? data.width;
+    const height = options.height ?? data.height;
+    this.width = width;
+    this.height = height;
+    return this;
+  }
+  setSubImageData(options) {
+    const { data, x = 0, y = 0 } = options;
+    const width = options.width ?? data.width;
+    const height = options.height ?? data.height;
+    (0, import_core12.assert)(width + x <= this.width && height + y <= this.height);
+  }
+};
+
+// dist/null-device/resources/null-render-pass.js
+var import_core13 = require("@luma.gl/core");
+var NullRenderPass = class extends import_core13.RenderPass {
+  device;
+  constructor(device, props) {
+    super(device, props);
+    this.device = device;
+  }
+  end() {
+  }
+  pushDebugGroup(groupLabel) {
+  }
+  popDebugGroup() {
+  }
+  insertDebugMarker(markerLabel) {
+  }
+  setParameters(parameters = {}) {
+  }
+  beginOcclusionQuery(queryIndex) {
+  }
+  endOcclusionQuery() {
+  }
+};
+
+// dist/null-device/resources/null-render-pipeline.js
+var import_core14 = require("@luma.gl/core");
+var NullRenderPipeline = class extends import_core14.RenderPipeline {
+  device;
+  vs;
+  fs;
+  uniforms = {};
+  bindings = {};
+  constructor(device, props) {
+    super(device, props);
+    this.device = device;
+    this.vs = (0, import_core14.cast)(props.vs);
+    this.fs = (0, import_core14.cast)(props.fs);
+    this.shaderLayout = props.shaderLayout || {
+      attributes: [],
+      bindings: [],
+      uniforms: []
+    };
+  }
+  setBindings(bindings) {
+    Object.assign(this.bindings, bindings);
+  }
+  setUniformsWebGL(uniforms) {
+    Object.assign(this.uniforms, uniforms);
+  }
+  draw(options) {
+    const { renderPass, vertexArray } = options;
+    vertexArray.bindBeforeRender(renderPass);
+    vertexArray.unbindAfterRender(renderPass);
+    return true;
+  }
+};
+
+// dist/null-device/resources/null-vertex-array.js
+var import_core15 = require("@luma.gl/core");
+var NullVertexArray = class extends import_core15.VertexArray {
+  device;
+  // Create a VertexArray
+  constructor(device, props) {
+    super(device, props);
+    this.device = device;
+  }
+  setIndexBuffer(indexBuffer) {
+    this.indexBuffer = indexBuffer;
+  }
+  /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
+  setBuffer(location, attributeBuffer) {
+    const attributeInfo = this.attributeInfos[location];
+    if (!attributeInfo) {
+      throw new Error(`Unknown attribute location ${location}`);
+    }
+    this.attributes[location] = attributeBuffer;
+  }
+  bindBeforeRender() {
+  }
+  unbindAfterRender() {
+  }
+  setConstantWebGL(location, value) {
+  }
+};
+
+// dist/null-device/resources/null-transform-feedback.js
+var import_core16 = require("@luma.gl/core");
+var NullTransformFeedback = class extends import_core16.TransformFeedback {
+  device;
+  layout;
+  buffers = {};
+  constructor(device, props) {
+    super(device, props);
+    this.device = device;
+    this.layout = this.props.layout;
+    if (props.buffers) {
+      this.setBuffers(props.buffers);
+    }
+    Object.seal(this);
+  }
+  begin(topology = "point-list") {
+  }
+  end() {
+  }
+  setBuffers(buffers) {
+    this.buffers = {};
+    for (const bufferName in buffers) {
+      this.setBuffer(bufferName, buffers[bufferName]);
+    }
+  }
+  setBuffer(locationOrName, bufferOrRange) {
+    this.buffers[locationOrName] = bufferOrRange;
+  }
+  getBuffer(locationOrName) {
+    return this.buffers[locationOrName] || null;
+  }
+};
+
+// dist/null-device/resources/null-query-set.js
+var import_core17 = require("@luma.gl/core");
+var NullQuerySet = class extends import_core17.QuerySet {
+  device;
+  constructor(device, props) {
+    super(device, props);
+    this.device = device;
+  }
+};
+
+// dist/null-device/null-device.js
+var _NullDevice = class extends import_core18.Device {
+  static isSupported() {
+    return true;
+  }
+  type = "unknown";
+  features = new import_core18.DeviceFeatures([], this.props.disabledFeatures);
+  limits = new NullDeviceLimits();
+  info = NullDeviceInfo;
+  canvasContext;
+  lost;
+  static async create(props = {}) {
+    if (typeof props.canvas === "string") {
+      await import_core18.CanvasContext.pageLoaded;
+    }
+    return new _NullDevice(props);
+  }
+  constructor(props) {
+    super({ ...props, id: props.id || (0, import_core18.uid)("dummy-device") });
+    this.canvasContext = new NullCanvasContext(this, props);
+    this.lost = new Promise((resolve) => {
+    });
+    this.canvasContext.resize();
+  }
+  /**
+   * Destroys the context
+   * @note Has no effect for WebGL browser contexts, there is no browser API for destroying contexts
+   */
+  destroy() {
+  }
+  get isLost() {
+    return false;
+  }
+  getSize() {
+    return [this.canvasContext.width, this.canvasContext.height];
+  }
+  isTextureFormatSupported(format) {
+    return true;
+  }
+  isTextureFormatFilterable(format) {
+    return true;
+  }
+  isTextureFormatRenderable(format) {
+    return true;
+  }
+  // IMPLEMENTATION OF ABSTRACT DEVICE
+  createCanvasContext(props) {
+    return new NullCanvasContext(this, props);
+  }
+  createBuffer(props) {
+    const newProps = this._getBufferProps(props);
+    return new NullBuffer(this, newProps);
+  }
+  getDefaultRenderPass() {
+    return new NullRenderPass(this, {});
+  }
+  _createTexture(props) {
+    return new NullTexture(this, props);
+  }
+  createExternalTexture(props) {
+    throw new Error("createExternalTexture() not implemented");
+  }
+  createSampler(props) {
+    return new NullSampler(this, props);
+  }
+  createShader(props) {
+    return new NullShader(this, props);
+  }
+  createFramebuffer(props) {
+    return new NullFramebuffer(this, props);
+  }
+  createVertexArray(props) {
+    return new NullVertexArray(this, props);
+  }
+  createTransformFeedback(props) {
+    return new NullTransformFeedback(this, props);
+  }
+  createQuerySet(props) {
+    return new NullQuerySet(this, props);
+  }
+  createRenderPipeline(props) {
+    return new NullRenderPipeline(this, props);
+  }
+  beginRenderPass(props) {
+    return new NullRenderPass(this, props);
+  }
+  createComputePipeline(props) {
+    throw new Error("ComputePipeline not supported in WebGL");
+  }
+  beginComputePass(props) {
+    throw new Error("ComputePass not supported in WebGL");
+  }
+  createCommandEncoder(props = {}) {
+    return new NullCommandEncoder(this, props);
+  }
+  submit() {
+  }
+  setParametersWebGL(parameters) {
+  }
+  getParametersWebGL(parameters) {
+  }
+  withParametersWebGL(parameters, func) {
+    const { nocatch = true } = parameters;
+    let value;
+    if (nocatch) {
+      return func();
+    }
+    try {
+      value = func();
+    } catch {
+    }
+    return value;
+  }
+};
+var NullDevice = _NullDevice;
+__publicField(NullDevice, "type", "unknown");
+
 // dist/utils/check-type.js
 function checkType(value) {
 }