@tangram.gl/tangram-layers 0.0.0-stage → 0.0.0

package/dist/index.js

@@ -0,0 +1,756 @@
+// src/index.ts
+import { Layer } from "@deck.gl/core";
+import { Renderer as ClassicWebGLRenderer } from "@tangram.gl/tangram-renderer/core";
+
+// src/web_mercator_view_adapter.ts
+import { PROJECTION_CONSTANTS } from "@tangram.gl/tangram-renderer/core";
+var DECK_TO_TANGRAM_ZOOM_OFFSET = 1;
+var DECK_WORLD_SIZE = 512;
+var TANGRAM_HALF_WORLD_METERS = Math.PI * PROJECTION_CONSTANTS.mercatorRadius;
+var WebMercatorViewAdapter = class _WebMercatorViewAdapter {
+  /**
+   * Checks that a deck viewport provides the public Web Mercator contract used
+   * by TangramLayer.
+   * @param viewport deck.gl viewport.
+   * @returns Validation error, or null when supported.
+   */
+  static validateViewport(viewport) {
+    if (viewport?.isGeospatial === false) {
+      return new Error("a Web Mercator viewport is required");
+    }
+    if (_WebMercatorViewAdapter.validateGeographicAnchor(viewport, "Web Mercator viewport")) {
+      return new Error("a Web Mercator viewport is required");
+    }
+    return null;
+  }
+  /**
+   * Validates the geographic anchor shared by all deck.gl view adapters.
+   * @param viewport deck.gl viewport.
+   * @param viewportName View name used in the error message.
+   * @returns Validation error, or null when the anchor is finite.
+   */
+  static validateGeographicAnchor(viewport, viewportName = "viewport") {
+    if (!Number.isFinite(viewport?.longitude) || !Number.isFinite(viewport?.latitude) || !Number.isFinite(viewport?.zoom)) {
+      return new Error(`${viewportName} requires finite longitude, latitude, and zoom`);
+    }
+    return null;
+  }
+  /**
+   * Converts deck.gl camera matrices to Tangram camera matrices.
+   *
+   * Tangram tile models use absolute EPSG:3857 meters while deck matrices
+   * consume zoom-zero common coordinates. Altitude uses deck's
+   * latitude-dependent distance scale.
+   * @param viewport deck.gl WebMercatorViewport.
+   * @returns Tangram camera matrices and eye position.
+   */
+  static getCameraFrame(viewport) {
+    const distanceScales = typeof viewport.getDistanceScales === "function" ? viewport.getDistanceScales() : viewport.distanceScales;
+    const unitsPerMeter = distanceScales && distanceScales.unitsPerMeter;
+    const viewMatrix = viewport.viewMatrix;
+    const projectionMatrix = viewport.projectionMatrix;
+    if (!viewMatrix || viewMatrix.length !== 16 || !projectionMatrix || projectionMatrix.length !== 16 || !unitsPerMeter || !Number.isFinite(unitsPerMeter[2])) {
+      throw new Error("deck viewport camera matrices and distance scales are required");
+    }
+    const xyScale = DECK_WORLD_SIZE / (TANGRAM_HALF_WORLD_METERS * 2);
+    const metersToCommon = new Float64Array(16);
+    metersToCommon[0] = xyScale;
+    metersToCommon[5] = xyScale;
+    metersToCommon[10] = unitsPerMeter[2];
+    metersToCommon[12] = DECK_WORLD_SIZE / 2;
+    metersToCommon[13] = DECK_WORLD_SIZE / 2;
+    metersToCommon[15] = 1;
+    return {
+      view: multiplyMatrices(viewMatrix, metersToCommon),
+      projection: new Float32Array(projectionMatrix),
+      // The view matrix places the camera at the origin in eye coordinates.
+      position: [0, 0, 0]
+    };
+  }
+  /**
+   * Builds Tangram's external-camera frame for a deck.gl MapView.
+   * @param viewport deck.gl WebMercatorViewport.
+   * @param dimensions Render-target size.
+   * @returns Tangram HostFrame legacy shape.
+   */
+  static getFrame(viewport, { width, height }) {
+    const longitude = viewport.longitude;
+    const latitude = viewport.latitude;
+    const zoom = viewport.zoom;
+    if (typeof longitude !== "number" || !Number.isFinite(longitude) || typeof latitude !== "number" || !Number.isFinite(latitude) || typeof zoom !== "number" || !Number.isFinite(zoom)) {
+      throw new Error("a Web Mercator viewport is required");
+    }
+    const pitch = Math.abs(viewport.pitch || 0) * Math.PI / 180;
+    return {
+      viewport: { width, height },
+      view: {
+        longitude,
+        latitude,
+        zoom: zoom + DECK_TO_TANGRAM_ZOOM_OFFSET
+      },
+      projection: { type: "web-mercator" },
+      camera: _WebMercatorViewAdapter.getCameraFrame(viewport),
+      tileBuffer: Math.min(4, Math.ceil(Math.tan(pitch) * (viewport.height || height) / 256))
+    };
+  }
+};
+function multiplyMatrices(left, right) {
+  const result = new Float64Array(16);
+  for (let column = 0; column < 4; column++) {
+    for (let row = 0; row < 4; row++) {
+      let value = 0;
+      for (let index = 0; index < 4; index++) {
+        value += left[index * 4 + row] * right[column * 4 + index];
+      }
+      result[column * 4 + row] = value;
+    }
+  }
+  return result;
+}
+
+// src/first_person_view_adapter.ts
+import { Matrix4 } from "@math.gl/core";
+import { calculatePlanarVolumeBounds } from "@tangram.gl/tangram-renderer/core";
+var DECK_WORLD_SIZE2 = 512;
+var HALF_WORLD_METERS = 20037508342789244e-9;
+var TILE_SIZE = 256;
+var MAX_MERCATOR_LATITUDE = 85.05112878;
+var DEFAULT_GROUND_EXTENT = 2e4;
+var FirstPersonViewAdapter = class {
+  /** Converts the finite frustum/ground intersection without changing camera matrices. */
+  static getFrame = getFrame;
+};
+function getFrame(viewport, options = {}) {
+  return getFirstPersonFrameForCamera(viewport, WebMercatorViewAdapter.getCameraFrame(viewport), options);
+}
+function getFirstPersonFrameForCamera(viewport, camera, options = {}) {
+  const width = options.width ?? viewport.width;
+  const height = options.height ?? viewport.height;
+  const maxGroundExtent = options.maxGroundExtent ?? DEFAULT_GROUND_EXTENT;
+  if (!Number.isFinite(width) || width <= 0 || !Number.isFinite(height) || height <= 0) {
+    throw new Error("FirstPersonViewport requires positive width and height");
+  }
+  if (!Number.isFinite(maxGroundExtent) || maxGroundExtent <= 0) {
+    throw new Error("FirstPersonViewport maxGroundExtent must be finite and positive");
+  }
+  const { longitude, latitude } = viewport;
+  const unprojectFlat = viewport.unprojectFlat;
+  if (typeof longitude !== "number" || !Number.isFinite(longitude) || typeof latitude !== "number" || !Number.isFinite(latitude) || typeof unprojectFlat !== "function") {
+    throw new Error("FirstPersonViewport geographic center and ground projection method are required");
+  }
+  const inverseView = new Matrix4().copy(camera.view);
+  if (!Number.isFinite(inverseView.determinant()) || inverseView.determinant() === 0) {
+    throw new Error("FirstPersonViewport camera is singular");
+  }
+  const eye = inverseView.invert().transformAsPoint([0, 0, 0]);
+  if (!eye.every(Number.isFinite)) throw new Error("FirstPersonViewport eye position is invalid");
+  const latitudeScale = Math.cos(Math.max(
+    -MAX_MERCATOR_LATITUDE,
+    Math.min(MAX_MERCATOR_LATITUDE, latitude)
+  ) * Math.PI / 180);
+  const extent = maxGroundExtent / latitudeScale;
+  const bounds = calculatePlanarVolumeBounds(camera, options.elevationRange ?? [0, 0], {
+    sw: { x: eye[0] - extent, y: eye[1] - extent },
+    ne: { x: eye[0] + extent, y: eye[1] + extent }
+  });
+  const xyScale = DECK_WORLD_SIZE2 / (HALF_WORLD_METERS * 2);
+  const toGeographic = (x, y) => unprojectFlat.call(viewport, [
+    x * xyScale + DECK_WORLD_SIZE2 / 2,
+    y * xyScale + DECK_WORLD_SIZE2 / 2
+  ]);
+  const center = bounds ? toGeographic(
+    (bounds.sw.x + bounds.ne.x) / 2,
+    (bounds.sw.y + bounds.ne.y) / 2
+  ) : [longitude, latitude];
+  const metersPerPixel = bounds ? Math.max(
+    (bounds.ne.x - bounds.sw.x) / width,
+    (bounds.ne.y - bounds.sw.y) / height
+  ) : extent * 2 / Math.min(width, height);
+  let visibleBounds = null;
+  if (bounds) {
+    const southwest = toGeographic(bounds.sw.x, bounds.sw.y);
+    const northeast = toGeographic(bounds.ne.x, bounds.ne.y);
+    visibleBounds = [southwest[0], southwest[1], northeast[0], northeast[1]];
+  }
+  if (!center.every(Number.isFinite) || !Number.isFinite(metersPerPixel) || metersPerPixel <= 0 || visibleBounds && !visibleBounds.every(Number.isFinite)) {
+    throw new Error("FirstPersonViewport ground footprint is invalid");
+  }
+  return {
+    viewport: { width, height },
+    view: {
+      longitude: center[0],
+      latitude: center[1],
+      altitude: eye[2],
+      zoom: Math.max(0, Math.log2(HALF_WORLD_METERS * 2 / (TILE_SIZE * metersPerPixel)))
+    },
+    projection: { type: "web-mercator", visibleBounds },
+    camera,
+    tileBuffer: 1
+  };
+}
+
+// src/globe_view_adapter.ts
+var DECK_TO_TANGRAM_ZOOM_OFFSET2 = 1;
+var GlobeViewAdapter = class {
+  /** Converts globe common-space matrices and visible geographic bounds. */
+  static getFrame = getFrame2;
+};
+function getFrame2(viewport, options = {}) {
+  if (options.maxElevation !== void 0 && (!Number.isFinite(options.maxElevation) || options.maxElevation < 0)) {
+    throw new Error("GlobeView maxElevation must be a finite non-negative number");
+  }
+  if (!viewport || !Number.isFinite(viewport.width) || !Number.isFinite(viewport.height) || !viewport.viewMatrix || viewport.viewMatrix.length !== 16 || !viewport.projectionMatrix || viewport.projectionMatrix.length !== 16 || !viewport.cameraPosition || viewport.cameraPosition.length !== 3 || !Array.from(viewport.cameraPosition).every(Number.isFinite) || typeof viewport.getBounds !== "function") {
+    throw new Error("deck GlobeViewport matrices, camera position, size, and visible bounds are required");
+  }
+  const visibleBounds = options.visibleBounds ?? viewport.getBounds({ z: 0 });
+  if (!Array.isArray(visibleBounds) || visibleBounds.length !== 4 || visibleBounds.some((value) => !Number.isFinite(value))) {
+    throw new Error("deck GlobeViewport must provide finite geographic bounds");
+  }
+  return {
+    viewport: { width: viewport.width, height: viewport.height },
+    view: {
+      longitude: viewport.longitude,
+      latitude: viewport.latitude,
+      zoom: Math.max(0, viewport.zoom + DECK_TO_TANGRAM_ZOOM_OFFSET2)
+    },
+    projection: {
+      type: "globe",
+      visibleBounds: [visibleBounds[0], visibleBounds[1], visibleBounds[2], visibleBounds[3]],
+      ...options.maxElevation === void 0 ? {} : { maxElevation: options.maxElevation }
+    },
+    camera: {
+      view: new Float64Array(viewport.viewMatrix),
+      projection: new Float32Array(
+        multiplyMatrices2(viewport.projectionMatrix, viewport.viewMatrix)
+      ),
+      position: [viewport.cameraPosition[0], viewport.cameraPosition[1], viewport.cameraPosition[2]]
+    },
+    tileBuffer: 0,
+    globePreloadZoom: options.preloadZoom
+  };
+}
+function multiplyMatrices2(left, right) {
+  const result = new Float64Array(16);
+  for (let column = 0; column < 4; column++) {
+    for (let row = 0; row < 4; row++) {
+      let value = 0;
+      for (let index = 0; index < 4; index++) {
+        value += left[index * 4 + row] * right[column * 4 + index];
+      }
+      result[column * 4 + row] = value;
+    }
+  }
+  return result;
+}
+
+// src/tangram-layer.ts
+var VIEW_EPSILON = 1e-7;
+function injectNextzenApiKey(config, apiKey) {
+  if (!apiKey || !config || !config.sources) {
+    return false;
+  }
+  let updated = false;
+  for (const source of Object.values(config.sources)) {
+    if (source && typeof source.url === "string" && source.url.includes("nextzen.org")) {
+      source.url_params = source.url_params || {};
+      source.url_params.api_key = apiKey;
+      updated = true;
+    }
+  }
+  return updated;
+}
+function getExternalCameraFrame(viewport) {
+  return WebMercatorViewAdapter.getCameraFrame(viewport);
+}
+function getFirstPersonViewFrame(viewport, options = {}) {
+  return FirstPersonViewAdapter.getFrame(viewport, options);
+}
+function getGlobeViewFrame(viewport, options = {}) {
+  return GlobeViewAdapter.getFrame(viewport, options);
+}
+function createTangramLayerClass({ Layer: Layer2, ClassicWebGLRenderer: ClassicWebGLRenderer2, Renderer }, viewAdapter) {
+  const rendererClass = ClassicWebGLRenderer2 || Renderer;
+  if (!Layer2 || !rendererClass) {
+    throw new Error("createTangramLayerClass requires Layer and ClassicWebGLRenderer");
+  }
+  class TangramLayer2 extends Layer2 {
+    /** Forward deck.gl's property objects without changing its constructor semantics. */
+    constructor(...properties) {
+      super(...properties);
+    }
+    initializeState(_context) {
+      this.setState({ tangramRecord: null });
+    }
+    updateState({ props }) {
+      let record = this.state.tangramRecord;
+      const shouldCreateScene = !record || record.sceneSource !== props.scene || record.sceneBasePath !== props.sceneBasePath || record.apiKey !== props.apiKey || record.projectionEngine !== (props.projectionEngine ?? void 0) || record.projectionEngineExecution !== (props.projectionEngineExecution ?? void 0) || Boolean(record.terrain) !== Boolean(props.terrain) || record.terrainResourceBudget !== (props.terrainResourceBudget ?? void 0) || record.maxConcurrentTileLoadsPerWorker !== (props.maxConcurrentTileLoadsPerWorker ?? void 0);
+      if (shouldCreateScene) {
+        this._disposeTangramRecord(record);
+        record = this._createTangramRecord(props);
+        this.setState({ tangramRecord: record });
+      }
+      if (record) {
+        record.owner = this;
+        if (record.terrain !== props.terrain) {
+          record.terrain = props.terrain;
+          const terrain = props.terrain;
+          const revision = record.terrainRevision = (record.terrainRevision || 0) + 1;
+          record.terrainPendingRevision = revision;
+          Promise.resolve(record.loadPromise).then(async () => {
+            try {
+              if (!record.disposed && revision === record.terrainRevision && terrain) {
+                await record.renderer.setTerrain(terrain);
+                if (!record.disposed && revision === record.terrainRevision) {
+                  record.terrainPendingRevision = 0;
+                  record.renderer.setTerrainExaggeration(record.owner.props.terrainExaggeration ?? 1);
+                }
+              }
+            } finally {
+              if (record.terrainPendingRevision === revision) record.terrainPendingRevision = 0;
+            }
+          }).catch((error) => {
+            if (!record.disposed && revision === record.terrainRevision) this._raiseBridgeError(normalizeError(error));
+          });
+        }
+        if (props.terrain && !record.terrainPendingRevision) {
+          try {
+            record.renderer.setTerrainExaggeration(props.terrainExaggeration ?? 1);
+          } catch (error) {
+            this._raiseBridgeError(normalizeError(error));
+          }
+        }
+      }
+    }
+    draw({ renderPass } = {}) {
+      const record = this.state.tangramRecord;
+      if (!record || record.disposed) {
+        return;
+      }
+      record.owner = this;
+      this._synchronizeTangramScene(record);
+      if (!this._canRender(record, this.props)) {
+        return;
+      }
+      const renderTangram = () => {
+        const update_options = { force: true };
+        renderPass = renderPass || this.context.renderPass;
+        if (renderPass) {
+          update_options.renderPass = renderPass;
+        }
+        const rendered = record.renderer.render(update_options);
+        if (record.scene.config && record.scene.config.scene && record.scene.config.scene.animated === true) {
+          this.setNeedsRedraw();
+        }
+        if (rendered && record.gl) {
+          record.gl.depthMask(true);
+          record.gl.clear(record.gl.DEPTH_BUFFER_BIT | record.gl.STENCIL_BUFFER_BIT);
+        }
+      };
+      if (record.device.type === "webgl") {
+        record.scene.withWebGLContext(renderTangram);
+      } else {
+        renderTangram();
+      }
+    }
+    finalizeState(_context) {
+      this._disposeTangramRecord(this.state && this.state.tangramRecord);
+    }
+    /** Asynchronously query a view-local or canvas CSS pixel; the host must keep drawing. */
+    getFeatureAt(pixel, options = {}) {
+      const record = this.state.tangramRecord;
+      if (!record || record.disposed || record.loadFailed) return Promise.resolve(void 0);
+      const pending = record.renderer.getFeatureAt(pixel, options);
+      record.owner.setNeedsRedraw();
+      return pending;
+    }
+    /** Intersect the actual rendered eye with a host-owned terrain mesh in content coordinates. */
+    getTerrainAt(pixel, surface, options = {}) {
+      const record = this.state && this.state.tangramRecord;
+      if (!record || record.disposed || record.loadFailed || !record.loaded) return null;
+      return record.renderer.getTerrainAt(pixel, surface, options);
+    }
+    /** Exact admitted ground triangles at the last frame, including temporal relief and globe projection. */
+    getDrapedTerrainSurface() {
+      const record = this.state?.tangramRecord;
+      return record && !record.disposed && record.loaded && !record.loadFailed ? record.renderer.getDrapedTerrainSurface() : null;
+    }
+    /** Resident worker preparation costs; GPU, source and scratch allocations are separate. */
+    getTerrainDrapingStatistics() {
+      const record = this.state?.tangramRecord;
+      return record && !record.disposed ? record.renderer.getTerrainDrapingStatistics() : void 0;
+    }
+    get isLoaded() {
+      const record = this.state && this.state.tangramRecord;
+      return Boolean(record && record.loaded && !record.loadFailed && !record.disposed);
+    }
+    _createTangramRecord(props) {
+      if (!props.scene) {
+        this._raiseBridgeError(new Error("scene is required"));
+        return null;
+      }
+      const deckCanvas = this.context.deck && this.context.deck.getCanvas();
+      const device = this.context.device;
+      if (!deckCanvas) {
+        this._raiseBridgeError(new Error("deck canvas is required"));
+        return null;
+      }
+      if (!device || device.type !== "webgl" && device.type !== "webgpu" || typeof device.createBuffer !== "function" || typeof device.createShader !== "function" || typeof device.createTexture !== "function" || typeof device.createRenderPipeline !== "function" || typeof device.createVertexArray !== "function") {
+        this._raiseBridgeError(new Error("a deck.gl luma.gl Device is required"));
+        return null;
+      }
+      let gl = null;
+      if (device.type === "webgl") {
+        gl = device.handle;
+        if (!gl || typeof device.pushState !== "function" || typeof device.popState !== "function") {
+          this._raiseBridgeError(new Error("a deck.gl WebGLDevice is required"));
+          return null;
+        }
+        if (gl.canvas !== deckCanvas) {
+          this._raiseBridgeError(
+            new Error("deck canvas and WebGLDevice handle must share a context")
+          );
+          return null;
+        }
+      }
+      const record = {
+        owner: this,
+        renderer: null,
+        scene: null,
+        device,
+        gl,
+        deckCanvas,
+        sceneSource: props.scene,
+        sceneBasePath: props.sceneBasePath,
+        apiKey: props.apiKey,
+        projectionEngine: props.projectionEngine ?? void 0,
+        terrain: props.terrain,
+        terrainResourceBudget: props.terrainResourceBudget ?? void 0,
+        terrainPendingRevision: 0,
+        projectionEngineExecution: props.projectionEngineExecution ?? void 0,
+        maxConcurrentTileLoadsPerWorker: props.maxConcurrentTileLoadsPerWorker ?? void 0,
+        canvasWidth: null,
+        canvasHeight: null,
+        disposed: false,
+        destroyed: false,
+        loadSettled: false,
+        loadFailed: false,
+        loaded: false,
+        lastSceneError: null,
+        lastViewportError: null,
+        reportedViewportError: null,
+        loadPromise: null,
+        webglScopeDepth: 0
+      };
+      let renderer;
+      try {
+        const renderer_options = {
+          device,
+          canvas: deckCanvas,
+          projectionEngine: record.projectionEngine,
+          terrain: record.terrain,
+          terrainResourceBudget: record.terrainResourceBudget,
+          projectionEngineExecution: record.projectionEngineExecution,
+          maxConcurrentTileLoadsPerWorker: record.maxConcurrentTileLoadsPerWorker,
+          requestRedraw: () => {
+            if (!record.disposed && record.owner.setNeedsRedraw) {
+              record.owner.setNeedsRedraw();
+            }
+          },
+          continuousZoom: true,
+          highDensityDisplay: true,
+          logLevel: "warn"
+        };
+        if (gl) {
+          renderer_options.webGLContext = gl;
+          renderer_options.webGLContextScope = (callback) => this._withDeviceState(record, callback);
+        }
+        renderer = rendererClass.create(props.scene, renderer_options);
+      } catch (error) {
+        this._raiseBridgeError(normalizeError(error));
+        return null;
+      }
+      record.renderer = renderer;
+      record.scene = renderer.scene;
+      const liveRecord = record;
+      renderer.subscribe({
+        load: (message) => {
+          injectNextzenApiKey(message.config, record.apiKey);
+        },
+        update: () => this._updateAttributions(liveRecord),
+        error: (message) => this._reportSceneError(liveRecord, normalizeError(message), message.type !== "scene_import")
+      });
+      this._synchronizeTangramScene(liveRecord);
+      record.loadPromise = Promise.resolve().then(() => {
+        if (record.disposed) {
+          return null;
+        }
+        return renderer.load(props.scene, {
+          // Creation already rejected missing scene input; this closure preserves that identity.
+          base_path: props.sceneBasePath,
+          blocking: false
+        });
+      }).then((result) => {
+        if (!record.disposed) {
+          record.loaded = true;
+          record.owner.setNeedsRedraw && record.owner.setNeedsRedraw();
+          record.owner.props.onSceneLoad(liveRecord.scene);
+          this._updateAttributions(liveRecord);
+        }
+        return result;
+      }).catch((error) => {
+        if (!record.disposed) {
+          record.loadFailed = true;
+          this._reportSceneError(liveRecord, normalizeError(error));
+        }
+      }).finally(() => {
+        record.loadSettled = true;
+        if (record.disposed) {
+          this._destroyTangramRecord(liveRecord);
+        }
+      });
+      return liveRecord;
+    }
+    /** Refresh credits after source recreation; ignore stale metadata and disposed layers. */
+    _updateAttributions(record) {
+      if (record.disposed || typeof record.renderer.getAttributions !== "function") return;
+      const generation = record.attributionGeneration = (record.attributionGeneration || 0) + 1;
+      Promise.resolve().then(() => record.disposed ? void 0 : record.renderer.getAttributions()).then((credits) => {
+        if (credits && !record.disposed && generation === record.attributionGeneration) {
+          record.owner.props.onAttributionChange?.(credits, record.scene);
+        }
+      }).catch((error) => {
+        if (!record.disposed && generation === record.attributionGeneration) {
+          this._reportSceneError(record, normalizeError(error), false);
+        }
+      });
+    }
+    _synchronizeTangramScene(record) {
+      const viewport = this.context.viewport;
+      const viewports = this.context.deck.getViewports ? this.context.deck.getViewports() : [viewport];
+      if (viewAdapter) {
+        try {
+          if (viewports.length !== 1) throw new Error("only one deck.gl viewport is supported");
+          const width2 = record.deckCanvas.clientWidth || viewport.width;
+          const height2 = record.deckCanvas.clientHeight || viewport.height;
+          const frame2 = viewAdapter.getFrame(viewport, this.props, { width: width2, height: height2 });
+          record.renderer.setFrame({ ...frame2, tileResources: this.props.tileResources ?? void 0 });
+          record.lastViewportError = null;
+          record.reportedViewportError = null;
+        } catch (error) {
+          record.lastViewportError = error.message;
+          this._raiseViewportError(record, normalizeError(error));
+        }
+        return;
+      }
+      const globeOptions = {
+        maxElevation: this.props.globeMaxElevation ?? void 0,
+        visibleBounds: this.props.globeVisibleBounds ?? void 0,
+        preloadZoom: this.props.globePreloadZoom ?? void 0
+      };
+      const firstPersonOptions = {
+        maxGroundExtent: this.props.firstPersonMaxGroundExtent ?? void 0,
+        elevationRange: this.props.firstPersonElevationRange ?? void 0
+      };
+      const viewportError = validateViewport(viewport, viewports, globeOptions, firstPersonOptions);
+      if (viewportError) {
+        record.lastViewportError = viewportError.message;
+        this._raiseViewportError(record, viewportError);
+        return;
+      }
+      record.lastViewportError = null;
+      record.reportedViewportError = null;
+      const width = record.deckCanvas.clientWidth || viewport.width;
+      const height = record.deckCanvas.clientHeight || viewport.height;
+      record.canvasWidth = width;
+      record.canvasHeight = height;
+      const frame = isGlobeViewport(viewport) ? { ...getGlobeViewFrame(viewport, globeOptions), viewport: { width, height } } : isFirstPersonViewport(viewport) ? getFirstPersonViewFrame(viewport, { width, height, ...firstPersonOptions }) : getMapViewFrame(viewport, { width, height });
+      record.renderer.setFrame({ ...frame, tileResources: this.props.tileResources ?? void 0 });
+    }
+    _canRender(record, props) {
+      return props.visible !== false && props.opacity !== 0 && record.loaded && !record.loadFailed && !record.lastViewportError;
+    }
+    _raiseViewportError(record, error) {
+      if (record.reportedViewportError === error.message) {
+        return;
+      }
+      record.reportedViewportError = error.message;
+      this._raiseBridgeError(error);
+    }
+    _reportSceneError(record, error, isFatal = true) {
+      if (record.disposed || record.lastSceneError === error.message) {
+        return;
+      }
+      record.lastSceneError = error.message;
+      if (isFatal) {
+        record.loadFailed = true;
+      }
+      record.owner.props.onSceneError(error, record.scene);
+      record.owner.raiseError(error, "TangramLayer scene");
+    }
+    _raiseBridgeError(error) {
+      this.raiseError(error, "TangramLayer bridge");
+    }
+    _disposeTangramRecord(record) {
+      if (!record || record.disposed) {
+        return;
+      }
+      record.disposed = true;
+      if (!record.loadPromise || record.loadSettled) {
+        this._destroyTangramRecord(record);
+      }
+    }
+    _destroyTangramRecord(record) {
+      if (!record.destroyed) {
+        record.destroyed = true;
+        record.renderer.destroy();
+      }
+    }
+    _withDeviceState(record, callback) {
+      if (record.webglScopeDepth > 0) {
+        return callback();
+      }
+      const { device, gl } = record;
+      const lumaState = gl.lumaState;
+      const hasTrackedProgram = Boolean(lumaState && "program" in lumaState);
+      const previousProgram = hasTrackedProgram ? lumaState.program : gl.getParameter(gl.CURRENT_PROGRAM);
+      record.webglScopeDepth++;
+      device.pushState();
+      try {
+        return callback();
+      } finally {
+        try {
+          device.popState();
+          gl.useProgram(previousProgram);
+        } finally {
+          record.webglScopeDepth--;
+        }
+      }
+    }
+  }
+  TangramLayer2.layerName = "TangramLayer";
+  TangramLayer2.defaultProps = {
+    projectionEngine: null,
+    projectionEngineExecution: null,
+    scene: null,
+    sceneBasePath: null,
+    apiKey: null,
+    globeMaxElevation: null,
+    globeVisibleBounds: null,
+    globePreloadZoom: null,
+    tileResources: null,
+    maxConcurrentTileLoadsPerWorker: null,
+    firstPersonMaxGroundExtent: 2e4,
+    terrain: { type: "object", value: null, compare: false },
+    terrainResourceBudget: { type: "object", value: null, compare: false },
+    terrainExaggeration: { type: "number", value: 1, min: 0, max: 1e3 },
+    firstPersonElevationRange: { type: "array", value: [0, 0], compare: true },
+    onSceneLoad: () => {
+    },
+    onAttributionChange: () => {
+    },
+    onSceneError: () => {
+    }
+  };
+  return TangramLayer2;
+}
+function validateViewport(viewport, viewports, globeOptions = {}, firstPersonOptions = {}) {
+  if (viewports.length !== 1) {
+    return new Error("only one deck.gl viewport is supported");
+  }
+  const globe = isGlobeViewport(viewport);
+  const firstPerson = isFirstPersonViewport(viewport);
+  const geographicAnchorError = WebMercatorViewAdapter.validateGeographicAnchor(
+    viewport,
+    globe ? "GlobeViewport" : "Web Mercator viewport"
+  );
+  if (geographicAnchorError) {
+    return globe ? geographicAnchorError : new Error("a Web Mercator viewport is required");
+  }
+  if (!globe) {
+    const webMercatorError = WebMercatorViewAdapter.validateViewport(viewport);
+    if (webMercatorError) {
+      return webMercatorError;
+    }
+  }
+  if (!Number.isFinite(viewport.bearing || 0) || !Number.isFinite(viewport.pitch || 0) || (viewport.pitch || 0) < (firstPerson ? -90 : -VIEW_EPSILON) || (firstPerson ? (viewport.pitch || 0) > 90 : (viewport.pitch || 0) >= 90)) {
+    return new Error("bearing and pitch must describe a finite deck.gl camera");
+  }
+  try {
+    if (globe) {
+      getGlobeViewFrame(viewport, globeOptions);
+    } else if (isFirstPersonViewport(viewport)) {
+      getFirstPersonViewFrame(viewport, firstPersonOptions);
+    } else {
+      WebMercatorViewAdapter.getCameraFrame(viewport);
+    }
+  } catch (error) {
+    return error;
+  }
+  return null;
+}
+function getMapViewFrame(viewport, { width, height }) {
+  return WebMercatorViewAdapter.getFrame(viewport, { width, height });
+}
+function isFirstPersonViewport(viewport) {
+  return Boolean(
+    viewport && viewport.constructor && viewport.constructor.displayName === "FirstPersonViewport"
+  );
+}
+function isGlobeViewport(viewport) {
+  return Boolean(
+    viewport && (viewport.constructor?.displayName === "GlobeViewport" || viewport.constructor?.name === "GlobeViewport")
+  );
+}
+function normalizeError(value) {
+  const fields = value;
+  if (value instanceof Error) {
+    return value;
+  }
+  if (value && fields.error instanceof Error) {
+    return fields.error;
+  }
+  if (value && fields.message) {
+    return new Error(fields.message);
+  }
+  return new Error(String(value));
+}
+var tangram_layer_default = createTangramLayerClass;
+
+// src/index.ts
+var BaseTangramLayer = tangram_layer_default({ Layer, ClassicWebGLRenderer, Renderer: void 0 });
+var TangramLayer = class extends BaseTangramLayer {
+  /** Stable deck.gl metadata for the typed public subclass. */
+  static componentName = "TangramLayer";
+  /** Compatibility name for integrations using deck.gl's historical metadata. */
+  static layerName = "TangramLayer";
+  /** Preserve deck.gl's public initialization signature through the injected superclass. */
+  initializeState(_context) {
+    super.initializeState();
+  }
+  /** Forward the standard deck.gl property/state change contract. */
+  updateState(parameters) {
+    super.updateState(parameters);
+  }
+  /** Release the scene using the standard deck.gl finalization signature. */
+  finalizeState(_context) {
+    super.finalizeState();
+  }
+  /** Forward deck's complete draw options to the existing render-pass bridge. */
+  draw(options) {
+    super.draw(options);
+  }
+};
+var src_default = TangramLayer;
+export {
+  FirstPersonViewAdapter,
+  GlobeViewAdapter,
+  TangramLayer,
+  WebMercatorViewAdapter,
+  tangram_layer_default as createTangramLayerClass,
+  src_default as default,
+  getExternalCameraFrame,
+  getFirstPersonViewFrame,
+  getGlobeViewFrame,
+  injectNextzenApiKey
+};
+//# sourceMappingURL=index.js.map