@kepler.gl/deckgl-layers 3.3.0-alpha.4 → 3.3.0-alpha.6

package/dist/esm/wms/wms-layer.js

@@ -0,0 +1,619 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _get from "@babel/runtime/helpers/esm/get";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _superPropGet(t, o, e, r) { var p = _get(_getPrototypeOf(1 & r ? t.prototype : t), o, e); return 2 & r && "function" == typeof p ? function (t) { return p.apply(e, t); } : p; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { lngLatToWorld } from '@math.gl/web-mercator';
+import { CompositeLayer, COORDINATE_SYSTEM, _deepEqual as deepEqual } from '@deck.gl/core';
+import { BitmapLayer } from '@deck.gl/layers';
+import { ImageSource, WMSImageSource } from '@loaders.gl/wms';
+
+// TODO: This is a modified copy of WMSLayer from deck.gl. Remove this once we upgrade deck.gl and loaders.gl.
+
+/** All props supported by the TileLayer */
+
+/** Props added by the TileLayer */
+
+/**
+ * How much the user may zoom in (shrinking the visible span) before a view that
+ * is still contained in the last requested extent triggers a fresh, higher
+ * resolution request. `2` means the cached image may be stretched up to ~2x
+ * before refetching; higher values mean fewer requests but blurrier zoom-ins.
+ */
+var COVERAGE_REFETCH_ZOOM_FACTOR = 2;
+var defaultProps = {
+  id: 'imagery-layer',
+  data: '',
+  serviceType: 'auto',
+  srs: 'auto',
+  layers: {
+    type: 'array',
+    compare: true,
+    value: []
+  },
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  onMetadataLoad: {
+    type: 'function',
+    value: function value() {}
+  },
+  // eslint-disable-next-line
+  onMetadataLoadError: {
+    type: 'function',
+    value: console.error
+  },
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  onImageLoadStart: {
+    type: 'function',
+    value: function value() {}
+  },
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  onImageLoad: {
+    type: 'function',
+    value: function value() {}
+  },
+  onImageLoadError: {
+    type: 'function',
+    compare: false,
+    // eslint-disable-next-line
+    value: function value(requestId, error) {
+      return console.error(error, requestId);
+    }
+  }
+};
+var WMSLayer = /*#__PURE__*/function (_CompositeLayer) {
+  function WMSLayer() {
+    _classCallCheck(this, WMSLayer);
+    return _callSuper(this, WMSLayer, arguments);
+  }
+  _inherits(WMSLayer, _CompositeLayer);
+  return _createClass(WMSLayer, [{
+    key: "isLoaded",
+    get: /** Returns true if all async resources are loaded */
+    function get() {
+      // Track the explicit loading done by this layer
+      return Boolean(this.state) && this.state.loadCounter === 0 && _superPropGet(WMSLayer, "isLoaded", this, 1);
+    }
+
+    /** Lets deck.gl know that we want viewport change events */
+  }, {
+    key: "shouldUpdateState",
+    value: function shouldUpdateState() {
+      return true;
+    }
+  }, {
+    key: "initializeState",
+    value: function initializeState() {
+      // intentionally empty, initialization is done in updateState
+      this.state._nextRequestId = 0;
+      this.state.lastRequestId = -1;
+      this.state.loadCounter = 0;
+      this.state._lastRequestZoom = -1;
+    }
+  }, {
+    key: "updateState",
+    value: function updateState(_ref) {
+      var _this = this;
+      var changeFlags = _ref.changeFlags,
+        props = _ref.props,
+        oldProps = _ref.oldProps;
+      var viewport = this.context.viewport;
+
+      // Check if data source has changed
+      if (changeFlags.dataChanged || props.serviceType !== oldProps.serviceType) {
+        this.state.imageSource = this._createImageSource(props);
+        this._loadMetadata();
+        this.debounce(function () {
+          return _this.loadImage(viewport, 'image source changed');
+        }, 0);
+      } else if (!deepEqual(props.layers, oldProps.layers, 1)) {
+        this.debounce(function () {
+          return _this.loadImage(viewport, 'layers changed');
+        }, 0);
+      } else if (changeFlags.viewportChanged) {
+        var _gl$getContextAttribu;
+        // Check if preserveDrawingBuffer is enabled (indicates video recording or image export)
+        // Use minimal debounce (10ms) during export for responsive frame capture
+        // Request deduplication in loadImage prevents spam from redundant viewport updates
+        var gl = this.context.gl;
+        var isPreservingBuffer = gl === null || gl === void 0 || (_gl$getContextAttribu = gl.getContextAttributes) === null || _gl$getContextAttribu === void 0 || (_gl$getContextAttribu = _gl$getContextAttribu.call(gl)) === null || _gl$getContextAttribu === void 0 ? void 0 : _gl$getContextAttribu.preserveDrawingBuffer;
+        var debounceDelay = isPreservingBuffer ? 10 : undefined;
+        this.debounce(function () {
+          return _this.loadImage(viewport, 'viewport changed');
+        }, debounceDelay);
+      }
+    }
+  }, {
+    key: "renderLayers",
+    value: function renderLayers() {
+      var _this$state = this.state,
+        bounds = _this$state.bounds,
+        image = _this$state.image,
+        lastRequestParameters = _this$state.lastRequestParameters;
+      return image && new BitmapLayer(_objectSpread(_objectSpread({}, this.getSubLayerProps({
+        id: 'bitmap'
+      })), {}, {
+        _imageCoordinateSystem: lastRequestParameters.srs === 'EPSG:4326' ? COORDINATE_SYSTEM.LNGLAT : COORDINATE_SYSTEM.CARTESIAN,
+        bounds: bounds,
+        image: image,
+        pickable: this.props.pickable
+      }));
+    }
+  }, {
+    key: "getFeatureInfoText",
+    value: function () {
+      var _getFeatureInfoText = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(x, y) {
+        var lastRequestParameters, _this$state$imageSour, _this$state$imageSour2, featureInfo;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              lastRequestParameters = this.state.lastRequestParameters;
+              if (!lastRequestParameters) {
+                _context.next = 6;
+                break;
+              }
+              _context.next = 4;
+              return (_this$state$imageSour = (_this$state$imageSour2 = this.state.imageSource).getFeatureInfoText) === null || _this$state$imageSour === void 0 ? void 0 : _this$state$imageSour.call(_this$state$imageSour2, _objectSpread(_objectSpread({}, lastRequestParameters), {}, {
+                query_layers: lastRequestParameters.layers,
+                x: x,
+                y: y,
+                info_format: 'application/vnd.ogc.gml'
+              }));
+            case 4:
+              featureInfo = _context.sent;
+              return _context.abrupt("return", featureInfo);
+            case 6:
+              return _context.abrupt("return", '');
+            case 7:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function getFeatureInfoText(_x, _x2) {
+        return _getFeatureInfoText.apply(this, arguments);
+      }
+      return getFeatureInfoText;
+    }()
+  }, {
+    key: "_createImageSource",
+    value: function _createImageSource(props) {
+      if (props.data instanceof ImageSource) {
+        return props.data;
+      }
+      if (typeof props.data === 'string') {
+        return new WMSImageSource(props.data, {
+          loadOptions: props.loadOptions
+        });
+      }
+      throw new Error('invalid image source in props.data');
+    }
+
+    /** Run a getMetadata on the image service */
+  }, {
+    key: "_loadMetadata",
+    value: (function () {
+      var _loadMetadata2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+        var imageSource, metadata, _this$getCurrentLayer, _this$getCurrentLayer2;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              imageSource = this.state.imageSource;
+              _context2.prev = 1;
+              this.state.loadCounter++;
+              _context2.next = 5;
+              return imageSource.getMetadata();
+            case 5:
+              metadata = _context2.sent;
+              // If a request takes a long time, it may no longer be expected
+              if (this.state.imageSource === imageSource) {
+                (_this$getCurrentLayer = this.getCurrentLayer()) === null || _this$getCurrentLayer === void 0 || _this$getCurrentLayer.props.onMetadataLoad(metadata);
+              }
+              _context2.next = 12;
+              break;
+            case 9:
+              _context2.prev = 9;
+              _context2.t0 = _context2["catch"](1);
+              (_this$getCurrentLayer2 = this.getCurrentLayer()) === null || _this$getCurrentLayer2 === void 0 || _this$getCurrentLayer2.props.onMetadataLoadError(_context2.t0);
+            case 12:
+              _context2.prev = 12;
+              this.state.loadCounter--;
+              return _context2.finish(12);
+            case 15:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[1, 9, 12, 15]]);
+      }));
+      function _loadMetadata() {
+        return _loadMetadata2.apply(this, arguments);
+      }
+      return _loadMetadata;
+    }() /** Load an image */)
+  }, {
+    key: "loadImage",
+    value: (function () {
+      var _loadImage = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(viewport, _reason) {
+        var _gl$getContextAttribu2;
+        var _this$props, layers, serviceType, transparent, bounds, width, height, minLat, maxLat, srs, requestParams, _WGS84ToPseudoMercato, _WGS84ToPseudoMercato2, minX, minY, _WGS84ToPseudoMercato3, _WGS84ToPseudoMercato4, maxX, maxY, gl, isExporting, _this$state$lastReque, currentZoom, lastZoom, isZoomingIn, lastBbox, currentBbox, fullyContained, requestId, image, _this$getCurrentLayer3, _this$context$onError, _this$context, _this$getCurrentLayer4;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _this$props = this.props, layers = _this$props.layers, serviceType = _this$props.serviceType, transparent = _this$props.transparent; // TODO - move to ImageSource?
+              if (!(serviceType === 'wms' && layers.length === 0)) {
+                _context3.next = 3;
+                break;
+              }
+              return _context3.abrupt("return");
+            case 3:
+              // In globe mode deck's GlobeViewport.getBounds() only unprojects 4 edge
+              // midpoints and takes their min/max. That misses the screen corners, the
+              // curved limb, and (most importantly) the case where a pole is in view when
+              // looking from a high latitude — where every meridian and part of the far
+              // hemisphere become visible. Compute a fuller visible bounding box instead so
+              // the requested WMS image covers everything on screen.
+              bounds = viewport.resolution ? getGlobeVisibleBounds(viewport) : viewport.getBounds();
+              width = viewport.width, height = viewport.height; // Edge case: when bounds are perfectly symmetric around 0° (both longitude and latitude),
+              // it can cause rendering artifacts with EPSG:4326 on the globe.
+              // Add asymmetry to avoid this issue.
+              if (viewport.resolution && bounds) {
+                minLat = bounds[1];
+                maxLat = bounds[3]; // Check if latitude bounds are symmetric around 0° (within 0.1° tolerance)
+                if (Math.abs(minLat + maxLat) < 0.1 && Math.abs(minLat) > 1) {
+                  bounds[3] += 0.1;
+                }
+              }
+              srs = this.props.srs;
+              if (srs === 'auto') {
+                // BitmapLayer only supports LNGLAT or CARTESIAN (Web-Mercator)
+                srs = viewport.resolution ? 'EPSG:4326' : 'EPSG:3857';
+              }
+              requestParams = {
+                width: width,
+                height: height,
+                // TODO: remove bbox once deck.gl is upgraded to ^8.10 with loaders.gl ^4
+                bbox: bounds,
+                boundingBox: [[bounds[0], bounds[1]], [bounds[2], bounds[3]]],
+                layers: layers,
+                srs: srs,
+                transparent: transparent
+              };
+              if (srs === 'EPSG:3857') {
+                _WGS84ToPseudoMercato = WGS84ToPseudoMercator([bounds[0], bounds[1]]), _WGS84ToPseudoMercato2 = _slicedToArray(_WGS84ToPseudoMercato, 2), minX = _WGS84ToPseudoMercato2[0], minY = _WGS84ToPseudoMercato2[1];
+                _WGS84ToPseudoMercato3 = WGS84ToPseudoMercator([bounds[2], bounds[3]]), _WGS84ToPseudoMercato4 = _slicedToArray(_WGS84ToPseudoMercato3, 2), maxX = _WGS84ToPseudoMercato4[0], maxY = _WGS84ToPseudoMercato4[1];
+                requestParams.boundingBox = [[minX, minY], [maxX, maxY]];
+                // TODO: remove bbox once deck.gl is upgraded to ^8.10 with loaders.gl ^4
+                requestParams.bbox = [minX, minY, maxX, maxY];
+              }
+
+              // Skip request if parameters haven't meaningfully changed from an in-flight request
+              if (!(this.state.inFlightRequestParameters && this._areRequestParamsEqual(this.state.inFlightRequestParameters, requestParams))) {
+                _context3.next = 12;
+                break;
+              }
+              return _context3.abrupt("return");
+            case 12:
+              if (!(this.state.lastRequestParameters && this._isViewCoveredByLastRequest(this.state.lastRequestParameters, requestParams))) {
+                _context3.next = 14;
+                break;
+              }
+              return _context3.abrupt("return");
+            case 14:
+              // During video export, throttle zoom-in requests to only fire on zoom level crossings.
+              // The existing image is stretched by the BitmapLayer until the next level is reached.
+              // However, always allow requests if the new view isn't fully covered by the last image.
+              gl = this.context.gl;
+              isExporting = gl === null || gl === void 0 || (_gl$getContextAttribu2 = gl.getContextAttributes) === null || _gl$getContextAttribu2 === void 0 || (_gl$getContextAttribu2 = _gl$getContextAttribu2.call(gl)) === null || _gl$getContextAttribu2 === void 0 ? void 0 : _gl$getContextAttribu2.preserveDrawingBuffer;
+              if (!(isExporting && this.state._lastRequestZoom >= 0)) {
+                _context3.next = 26;
+                break;
+              }
+              currentZoom = viewport.zoom;
+              lastZoom = this.state._lastRequestZoom;
+              isZoomingIn = currentZoom > lastZoom; // Check if the new view is fully covered by the last loaded image
+              lastBbox = (_this$state$lastReque = this.state.lastRequestParameters) === null || _this$state$lastReque === void 0 ? void 0 : _this$state$lastReque.bbox;
+              currentBbox = requestParams.bbox;
+              fullyContained = false;
+              if (lastBbox && currentBbox) {
+                // New bbox must be fully inside the previous bbox
+                fullyContained = currentBbox[0] >= lastBbox[0] && currentBbox[1] >= lastBbox[1] && currentBbox[2] <= lastBbox[2] && currentBbox[3] <= lastBbox[3];
+              }
+
+              // Only throttle if:
+              // 1. Zooming in (not zooming out or panning at same zoom)
+              // 2. Same zoom floor (haven't crossed an integer zoom level)
+              // 3. New view is fully contained in the last loaded image (no uncovered areas)
+              if (!(isZoomingIn && Math.floor(currentZoom) === Math.floor(lastZoom) && fullyContained)) {
+                _context3.next = 26;
+                break;
+              }
+              return _context3.abrupt("return");
+            case 26:
+              // Mark request as in-flight to prevent duplicate requests
+              this.state.inFlightRequestParameters = requestParams;
+              requestId = this.getRequestId();
+              _context3.prev = 28;
+              this.state.loadCounter++;
+              // Trigger a redraw to update the UI loading indicator
+              this.setNeedsRedraw();
+              this.props.onImageLoadStart(requestId);
+              _context3.next = 34;
+              return this.state.imageSource.getImage(requestParams);
+            case 34:
+              image = _context3.sent;
+              // If a request takes a long time, later requests may have already loaded.
+              if (this.state.lastRequestId < requestId) {
+                (_this$getCurrentLayer3 = this.getCurrentLayer()) === null || _this$getCurrentLayer3 === void 0 || _this$getCurrentLayer3.props.onImageLoad(requestId);
+                // Update lastRequestParameters only after successful load
+                // This ensures coverage checks only use successfully loaded images
+                this.state.lastRequestParameters = requestParams;
+                this.state._lastRequestZoom = viewport.zoom;
+                // Not type safe...
+                this.setState({
+                  image: image,
+                  bounds: bounds,
+                  lastRequestId: requestId
+                });
+              }
+              _context3.next = 42;
+              break;
+            case 38:
+              _context3.prev = 38;
+              _context3.t0 = _context3["catch"](28);
+              (_this$context$onError = (_this$context = this.context).onError) === null || _this$context$onError === void 0 || _this$context$onError.call(_this$context, _context3.t0, this);
+              (_this$getCurrentLayer4 = this.getCurrentLayer()) === null || _this$getCurrentLayer4 === void 0 || _this$getCurrentLayer4.props.onImageLoadError(requestId, _context3.t0);
+            case 42:
+              _context3.prev = 42;
+              // Clear in-flight marker when request completes (success or error)
+              this.state.inFlightRequestParameters = undefined;
+              this.state.loadCounter--;
+              // Trigger a redraw to update the UI loading indicator
+              this.setNeedsRedraw();
+              return _context3.finish(42);
+            case 47:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[28, 38, 42, 47]]);
+      }));
+      function loadImage(_x3, _x4) {
+        return _loadImage.apply(this, arguments);
+      }
+      return loadImage;
+    }() // HELPERS
+    /** Global counter for issuing unique request ids */
+    )
+  }, {
+    key: "getRequestId",
+    value: function getRequestId() {
+      return this.state._nextRequestId++;
+    }
+
+    /** Runs an action in the future, cancels it if the new action is issued before it executes */
+  }, {
+    key: "debounce",
+    value: function debounce(fn) {
+      var ms = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 500;
+      clearTimeout(this.state._timeoutId);
+      this.state._timeoutId = setTimeout(function () {
+        return fn();
+      }, ms);
+    }
+
+    /**
+     * Returns true when the `next` view is fully inside the `prev` (last requested)
+     * extent AND not meaningfully higher resolution, so the cached image already
+     * covers the screen and no new request is needed.
+     */
+  }, {
+    key: "_isViewCoveredByLastRequest",
+    value: function _isViewCoveredByLastRequest(prev, next) {
+      // Coverage only makes sense within the same projection / dataset / canvas size.
+      if (prev.srs !== next.srs || prev.width !== next.width || prev.height !== next.height || prev.transparent !== next.transparent || !deepEqual(prev.layers, next.layers)) {
+        return false;
+      }
+      var p = prev.bbox;
+      var n = next.bbox;
+      if (!p || !n) {
+        return false;
+      }
+
+      // Is the new bbox fully contained within the previously requested bbox?
+      var contained = n[0] >= p[0] && n[1] >= p[1] && n[2] <= p[2] && n[3] <= p[3];
+      if (!contained) {
+        return false;
+      }
+
+      // Ground resolution is proportional to bbox span / pixel count. The guard
+      // above already ensured prev and next share the same width/height, so equal
+      // pixel counts let us compare spans directly. Only skip while the new view
+      // isn't much finer than what we already fetched, otherwise the cached image
+      // would look stretched/blurry.
+      var prevSpanX = p[2] - p[0];
+      var nextSpanX = n[2] - n[0];
+      var prevSpanY = p[3] - p[1];
+      var nextSpanY = n[3] - n[1];
+      return nextSpanX >= prevSpanX / COVERAGE_REFETCH_ZOOM_FACTOR && nextSpanY >= prevSpanY / COVERAGE_REFETCH_ZOOM_FACTOR;
+    }
+
+    /** Compare request parameters to determine if a new request is needed */
+  }, {
+    key: "_areRequestParamsEqual",
+    value: function _areRequestParamsEqual(prev, next) {
+      // Compare dimensions
+      if (prev.width !== next.width || prev.height !== next.height) {
+        return false;
+      }
+
+      // Compare SRS
+      if (prev.srs !== next.srs) {
+        return false;
+      }
+
+      // Compare layers
+      if (!deepEqual(prev.layers, next.layers)) {
+        return false;
+      }
+
+      // Compare transparent
+      if (prev.transparent !== next.transparent) {
+        return false;
+      }
+
+      // Compare bounds with tolerance for floating point precision
+      var tolerance = 1e-10;
+      var prevBbox = prev.bbox;
+      var nextBbox = next.bbox;
+      if (prevBbox && nextBbox) {
+        for (var i = 0; i < 4; i++) {
+          if (Math.abs(prevBbox[i] - nextBbox[i]) > tolerance) {
+            return false;
+          }
+        }
+      }
+      return true;
+    }
+  }]);
+}(CompositeLayer);
+/**
+ * Compute the [minLng, minLat, maxLng, maxLat] bounding box of the part of the
+ * globe that is actually visible on screen.
+ *
+ * Unlike `GlobeViewport.getBounds()` (4 edge midpoints), this samples a grid of
+ * screen pixels, unprojects each onto the sphere (deck.gl clamps rays that miss
+ * the globe to the silhouette/limb, which is exactly the boundary we want), and
+ * takes the extent. It additionally detects when a pole is in view: at a pole all
+ * meridians converge, so we widen the box to the full longitude range and extend
+ * the latitude up to the pole, which is what makes viewing from near a pole
+ * (seeing across to the far hemisphere) work.
+ */
+_defineProperty(WMSLayer, "layerName", 'WMSLayer');
+_defineProperty(WMSLayer, "defaultProps", defaultProps);
+export { WMSLayer as default };
+export function getGlobeVisibleBounds(viewport) {
+  var _longitude;
+  var width = viewport.width,
+    height = viewport.height;
+  var centerLng = (_longitude = viewport.longitude) !== null && _longitude !== void 0 ? _longitude : 0;
+  var SAMPLES = 8; // 8x8 cells => 9x9 = 81 sample points
+  var lats = [];
+  // Longitudes tracked as signed offsets from the center longitude, unwrapped to
+  // (-180, 180], so an antimeridian-crossing view stays a contiguous range.
+  var lngOffsets = [];
+  for (var i = 0; i <= SAMPLES; i++) {
+    for (var j = 0; j <= SAMPLES; j++) {
+      var px = i / SAMPLES * width;
+      var py = j / SAMPLES * height;
+      var coord = viewport.unproject([px, py]);
+      var lng = coord[0];
+      var lat = coord[1];
+      if (!Number.isFinite(lng) || !Number.isFinite(lat)) {
+        continue;
+      }
+      lats.push(lat);
+      // Wrap the offset into (-180, 180].
+      var offset = (lng - centerLng + 540) % 360 - 180;
+      lngOffsets.push(offset);
+    }
+  }
+
+  // Extremely degenerate viewport: fall back to deck's default.
+  if (lats.length === 0) {
+    return viewport.getBounds();
+  }
+  var minLat = Math.min.apply(Math, lats);
+  var maxLat = Math.max.apply(Math, lats);
+  var northPoleVisible = isGlobeSurfacePointVisible(viewport, 90);
+  var southPoleVisible = isGlobeSurfacePointVisible(viewport, -90);
+  var minLng;
+  var maxLng;
+  if (northPoleVisible || southPoleVisible) {
+    // A pole is on screen: every meridian is visible, so cover all longitudes and
+    // extend latitude up to the visible pole.
+    minLng = -180;
+    maxLng = 180;
+    if (northPoleVisible) {
+      maxLat = 90;
+    }
+    if (southPoleVisible) {
+      minLat = -90;
+    }
+  } else {
+    minLng = centerLng + Math.min.apply(Math, lngOffsets);
+    maxLng = centerLng + Math.max.apply(Math, lngOffsets);
+  }
+
+  // Pad slightly so the discrete sampling doesn't clip the true limb.
+  var latPad = Math.min(5, (maxLat - minLat) * 0.05 + 0.5);
+  minLat = Math.max(-90, minLat - latPad);
+  maxLat = Math.min(90, maxLat + latPad);
+  if (maxLng - minLng < 360) {
+    var lngPad = Math.min(5, (maxLng - minLng) * 0.05 + 0.5);
+    minLng -= lngPad;
+    maxLng += lngPad;
+  }
+
+  // A single EPSG:4326 rectangle can't cross the antimeridian, so if the visible
+  // span wraps past ±180 (or covers the whole world) request the full longitude
+  // range. This over-covers only near the dateline, which is an acceptable
+  // trade-off for a valid, gap-free request.
+  if (maxLng - minLng >= 360 || minLng < -180 || maxLng > 180) {
+    minLng = -180;
+    maxLng = 180;
+  }
+  return [minLng, minLat, maxLng, maxLat];
+}
+
+/**
+ * Whether a point on the globe surface at the given latitude (longitude is
+ * irrelevant at the poles) is both front-facing (not occluded by the globe) and
+ * inside the screen. Uses the sphere-horizon test in deck.gl common space:
+ * a surface point is front-facing when the angle between its outward normal and
+ * the camera direction is within the horizon half-angle, i.e.
+ *   dot(normalize(pointCommon), normalize(cameraPosition)) >= radius / cameraDist
+ */
+function isGlobeSurfacePointVisible(viewport, lat) {
+  var width = viewport.width,
+    height = viewport.height;
+  var point = viewport.projectPosition([0, lat, 0]);
+  var camera = viewport.cameraPosition;
+  var rPoint = Math.hypot(point[0], point[1], point[2]);
+  var rCam = Math.hypot(camera[0], camera[1], camera[2]);
+  if (rPoint === 0 || rCam === 0 || rCam <= rPoint) {
+    return false;
+  }
+  var cosSurface = (point[0] * camera[0] + point[1] * camera[1] + point[2] * camera[2]) / (rPoint * rCam);
+  var cosHorizon = rPoint / rCam;
+  if (cosSurface < cosHorizon) {
+    return false;
+  }
+  var screen = viewport.project([0, lat, 0]);
+  return screen[0] >= 0 && screen[0] <= width && screen[1] >= 0 && screen[1] <= height;
+}
+
+// https://epsg.io/3857
+// +proj=merc +a=6378137 +b=6378137 +lat_ts=0 +lon_0=0 +x_0=0 +y_0=0 +k=1 +units=m +nadgrids=@null +wktext +no_defs +type=crs
+var HALF_EARTH_CIRCUMFERENCE = 6378137 * Math.PI;
+
+/** Projects EPSG:4326 to EPSG:3857
+ * This is a lightweight replacement of proj4. Use tests to ensure conformance.
+ */
+export function WGS84ToPseudoMercator(coord) {
+  var mercator = lngLatToWorld(coord);
+  mercator[0] = (mercator[0] / 256 - 1) * HALF_EARTH_CIRCUMFERENCE;
+  mercator[1] = (mercator[1] / 256 - 1) * HALF_EARTH_CIRCUMFERENCE;
+  return mercator;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["lngLatToWorld","CompositeLayer","COORDINATE_SYSTEM","_deepEqual","deepEqual","BitmapLayer","ImageSource","WMSImageSource","COVERAGE_REFETCH_ZOOM_FACTOR","defaultProps","id","data","serviceType","srs","layers","type","compare","value","onMetadataLoad","onMetadataLoadError","console","error","onImageLoadStart","onImageLoad","onImageLoadError","requestId","WMSLayer","_CompositeLayer","_classCallCheck","_callSuper","arguments","_inherits","_createClass","key","get","Boolean","state","loadCounter","_superPropGet","shouldUpdateState","initializeState","_nextRequestId","lastRequestId","_lastRequestZoom","updateState","_ref","_this","changeFlags","props","oldProps","viewport","context","dataChanged","imageSource","_createImageSource","_loadMetadata","debounce","loadImage","viewportChanged","_gl$getContextAttribu","gl","isPreservingBuffer","getContextAttributes","call","preserveDrawingBuffer","debounceDelay","undefined","renderLayers","_this$state","bounds","image","lastRequestParameters","_objectSpread","getSubLayerProps","_imageCoordinateSystem","LNGLAT","CARTESIAN","pickable","_getFeatureInfoText","_asyncToGenerator","_regeneratorRuntime","mark","_callee","x","y","_this$state$imageSour","_this$state$imageSour2","featureInfo","wrap","_callee$","_context","prev","next","getFeatureInfoText","query_layers","info_format","sent","abrupt","stop","_x","_x2","apply","loadOptions","Error","_loadMetadata2","_callee2","metadata","_this$getCurrentLayer","_this$getCurrentLayer2","_callee2$","_context2","getMetadata","getCurrentLayer","t0","finish","_loadImage","_callee3","_reason","_gl$getContextAttribu2","_this$props","transparent","width","height","minLat","maxLat","requestParams","_WGS84ToPseudoMercato","_WGS84ToPseudoMercato2","minX","minY","_WGS84ToPseudoMercato3","_WGS84ToPseudoMercato4","maxX","maxY","isExporting","_this$state$lastReque","currentZoom","lastZoom","isZoomingIn","lastBbox","currentBbox","fullyContained","_this$getCurrentLayer3","_this$context$onError","_this$context","_this$getCurrentLayer4","_callee3$","_context3","length","resolution","getGlobeVisibleBounds","getBounds","Math","abs","bbox","boundingBox","WGS84ToPseudoMercator","_slicedToArray","inFlightRequestParameters","_areRequestParamsEqual","_isViewCoveredByLastRequest","zoom","floor","getRequestId","setNeedsRedraw","getImage","setState","onError","_x3","_x4","fn","ms","clearTimeout","_timeoutId","setTimeout","p","n","contained","prevSpanX","nextSpanX","prevSpanY","nextSpanY","tolerance","prevBbox","nextBbox","i","_defineProperty","default","_longitude","centerLng","longitude","SAMPLES","lats","lngOffsets","j","px","py","coord","unproject","lng","lat","Number","isFinite","push","offset","min","max","northPoleVisible","isGlobeSurfacePointVisible","southPoleVisible","minLng","maxLng","latPad","lngPad","point","projectPosition","camera","cameraPosition","rPoint","hypot","rCam","cosSurface","cosHorizon","screen","project","HALF_EARTH_CIRCUMFERENCE","PI","mercator"],"sources":["../../../src/wms/wms-layer.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {lngLatToWorld} from '@math.gl/web-mercator';\n\nimport {\n  Layer,\n  CompositeLayer,\n  CompositeLayerProps,\n  UpdateParameters,\n  DefaultProps,\n  Viewport,\n  COORDINATE_SYSTEM,\n  _deepEqual as deepEqual\n} from '@deck.gl/core';\nimport {BitmapLayer} from '@deck.gl/layers';\nimport {ImageSource, WMSImageSource} from '@loaders.gl/wms';\n\nimport type {ImageSourceMetadata} from '@loaders.gl/loader-utils';\nimport type {ImageType} from '@loaders.gl/wms';\n\n// TODO: This is a modified copy of WMSLayer from deck.gl. Remove this once we upgrade deck.gl and loaders.gl.\n\n/** All props supported by the TileLayer */\nexport type WMSLayerProps = CompositeLayerProps & _WMSLayerProps;\n\n/** Props added by the TileLayer */\ntype _WMSLayerProps = {\n  data: string | ImageSource;\n  serviceType?: string | 'auto';\n  layers?: string[];\n  srs?: 'EPSG:4326' | 'EPSG:3857' | 'auto';\n  transparent?: boolean;\n  onMetadataLoad?: (metadata: ImageSourceMetadata) => void;\n  onMetadataLoadError?: (error: Error) => void;\n  onImageLoadStart?: (requestId: unknown) => void;\n  onImageLoad?: (requestId: unknown) => void;\n  onImageLoadError?: (requestId: unknown, error: Error) => void;\n};\n\n/**\n * How much the user may zoom in (shrinking the visible span) before a view that\n * is still contained in the last requested extent triggers a fresh, higher\n * resolution request. `2` means the cached image may be stretched up to ~2x\n * before refetching; higher values mean fewer requests but blurrier zoom-ins.\n */\nconst COVERAGE_REFETCH_ZOOM_FACTOR = 2;\n\nconst defaultProps: DefaultProps<WMSLayerProps> = {\n  id: 'imagery-layer',\n  data: '',\n  serviceType: 'auto',\n  srs: 'auto',\n  layers: {type: 'array', compare: true, value: []},\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  onMetadataLoad: {type: 'function', value: () => {}},\n  // eslint-disable-next-line\n  onMetadataLoadError: {type: 'function', value: console.error},\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  onImageLoadStart: {type: 'function', value: () => {}},\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  onImageLoad: {type: 'function', value: () => {}},\n  onImageLoadError: {\n    type: 'function',\n    compare: false,\n    // eslint-disable-next-line\n    value: (requestId: unknown, error: Error) => console.error(error, requestId)\n  }\n};\n\nexport default class WMSLayer extends CompositeLayer<Required<_WMSLayerProps>> {\n  static layerName = 'WMSLayer';\n  static defaultProps: DefaultProps = defaultProps;\n\n  declare state: {\n    imageSource: ImageSource;\n    image: ImageType;\n    bounds: [number, number, number, number];\n    lastRequestParameters: {\n      // TODO: remove bbox once deck.gl is upgraded to ^8.10 with loaders.gl ^4\n      bbox: [number, number, number, number];\n      boundingBox: [[number, number], [number, number]];\n      layers: string[];\n      srs: 'EPSG:4326' | 'EPSG:3857';\n      width: number;\n      height: number;\n    };\n    inFlightRequestParameters?: {\n      bbox: [number, number, number, number];\n      boundingBox: [[number, number], [number, number]];\n      layers: string[];\n      srs: 'EPSG:4326' | 'EPSG:3857';\n      width: number;\n      height: number;\n    };\n    lastRequestId: number;\n    _nextRequestId: number;\n    /** TODO: Change any => setTimeout return type. Different between Node and browser... */\n    _timeoutId: any;\n    loadCounter: number;\n    _lastRequestZoom: number;\n  };\n\n  /** Returns true if all async resources are loaded */\n  get isLoaded(): boolean {\n    // Track the explicit loading done by this layer\n    return Boolean(this.state) && this.state.loadCounter === 0 && super.isLoaded;\n  }\n\n  /** Lets deck.gl know that we want viewport change events */\n  override shouldUpdateState(): boolean {\n    return true;\n  }\n\n  override initializeState(): void {\n    // intentionally empty, initialization is done in updateState\n    this.state._nextRequestId = 0;\n    this.state.lastRequestId = -1;\n    this.state.loadCounter = 0;\n    this.state._lastRequestZoom = -1;\n  }\n\n  override updateState({changeFlags, props, oldProps}: UpdateParameters<this>): void {\n    const {viewport} = this.context;\n\n    // Check if data source has changed\n    if (changeFlags.dataChanged || props.serviceType !== oldProps.serviceType) {\n      this.state.imageSource = this._createImageSource(props);\n\n      this._loadMetadata();\n      this.debounce(() => this.loadImage(viewport, 'image source changed'), 0);\n    } else if (!deepEqual(props.layers, oldProps.layers, 1)) {\n      this.debounce(() => this.loadImage(viewport, 'layers changed'), 0);\n    } else if (changeFlags.viewportChanged) {\n      // Check if preserveDrawingBuffer is enabled (indicates video recording or image export)\n      // Use minimal debounce (10ms) during export for responsive frame capture\n      // Request deduplication in loadImage prevents spam from redundant viewport updates\n      const gl = this.context.gl;\n      const isPreservingBuffer = gl?.getContextAttributes?.()?.preserveDrawingBuffer;\n\n      const debounceDelay = isPreservingBuffer ? 10 : undefined;\n      this.debounce(() => this.loadImage(viewport, 'viewport changed'), debounceDelay);\n    }\n  }\n\n  override renderLayers(): Layer<any> {\n    const {bounds, image, lastRequestParameters} = this.state;\n\n    return (\n      image &&\n      new BitmapLayer({\n        ...this.getSubLayerProps({id: 'bitmap'}),\n        _imageCoordinateSystem:\n          lastRequestParameters.srs === 'EPSG:4326'\n            ? COORDINATE_SYSTEM.LNGLAT\n            : COORDINATE_SYSTEM.CARTESIAN,\n        bounds,\n        image,\n        pickable: this.props.pickable\n      })\n    );\n  }\n\n  async getFeatureInfoText(x: number, y: number): Promise<string | null> {\n    const {lastRequestParameters} = this.state;\n    if (lastRequestParameters) {\n      // @ts-expect-error Undocumented method\n      const featureInfo = await this.state.imageSource.getFeatureInfoText?.({\n        ...lastRequestParameters,\n        query_layers: lastRequestParameters.layers,\n        x,\n        y,\n        info_format: 'application/vnd.ogc.gml'\n      });\n      return featureInfo;\n    }\n    return '';\n  }\n\n  _createImageSource(props: WMSLayerProps): ImageSource {\n    if (props.data instanceof ImageSource) {\n      return props.data;\n    }\n\n    if (typeof props.data === 'string') {\n      return new WMSImageSource(props.data, {\n        loadOptions: props.loadOptions\n      });\n    }\n\n    throw new Error('invalid image source in props.data');\n  }\n\n  /** Run a getMetadata on the image service */\n  async _loadMetadata(): Promise<void> {\n    const {imageSource} = this.state;\n    try {\n      this.state.loadCounter++;\n      const metadata = await imageSource.getMetadata();\n\n      // If a request takes a long time, it may no longer be expected\n      if (this.state.imageSource === imageSource) {\n        this.getCurrentLayer()?.props.onMetadataLoad(metadata);\n      }\n    } catch (error) {\n      this.getCurrentLayer()?.props.onMetadataLoadError(error as Error);\n    } finally {\n      this.state.loadCounter--;\n    }\n  }\n\n  /** Load an image */\n  async loadImage(viewport: Viewport, _reason: string): Promise<void> {\n    const {layers, serviceType, transparent} = this.props;\n\n    // TODO - move to ImageSource?\n    if (serviceType === 'wms' && layers.length === 0) {\n      return;\n    }\n\n    // In globe mode deck's GlobeViewport.getBounds() only unprojects 4 edge\n    // midpoints and takes their min/max. That misses the screen corners, the\n    // curved limb, and (most importantly) the case where a pole is in view when\n    // looking from a high latitude — where every meridian and part of the far\n    // hemisphere become visible. Compute a fuller visible bounding box instead so\n    // the requested WMS image covers everything on screen.\n    const bounds = viewport.resolution\n      ? getGlobeVisibleBounds(viewport)\n      : viewport.getBounds();\n    const {width, height} = viewport;\n    \n    // Edge case: when bounds are perfectly symmetric around 0° (both longitude and latitude),\n    // it can cause rendering artifacts with EPSG:4326 on the globe.\n    // Add asymmetry to avoid this issue.\n    if (viewport.resolution && bounds) {\n      const minLat = bounds[1];\n      const maxLat = bounds[3];\n      // Check if latitude bounds are symmetric around 0° (within 0.1° tolerance)\n      if (Math.abs(minLat + maxLat) < 0.1 && Math.abs(minLat) > 1) {\n        bounds[3] += 0.1;\n      }\n    }\n    \n    let {srs} = this.props;\n    if (srs === 'auto') {\n      // BitmapLayer only supports LNGLAT or CARTESIAN (Web-Mercator)\n      srs = viewport.resolution ? 'EPSG:4326' : 'EPSG:3857';\n    }\n    const requestParams = {\n      width,\n      height,\n      // TODO: remove bbox once deck.gl is upgraded to ^8.10 with loaders.gl ^4\n      bbox: bounds,\n      boundingBox: [\n        [bounds[0], bounds[1]],\n        [bounds[2], bounds[3]]\n      ] as [[number, number], [number, number]],\n      layers,\n      srs,\n      transparent\n    };\n    if (srs === 'EPSG:3857') {\n      const [minX, minY] = WGS84ToPseudoMercator([bounds[0], bounds[1]]);\n      const [maxX, maxY] = WGS84ToPseudoMercator([bounds[2], bounds[3]]);\n      requestParams.boundingBox = [\n        [minX, minY],\n        [maxX, maxY]\n      ];\n      // TODO: remove bbox once deck.gl is upgraded to ^8.10 with loaders.gl ^4\n      requestParams.bbox = [minX, minY, maxX, maxY];\n    }\n\n    // Skip request if parameters haven't meaningfully changed from an in-flight request\n    if (\n      this.state.inFlightRequestParameters &&\n      this._areRequestParamsEqual(this.state.inFlightRequestParameters, requestParams)\n    ) {\n      return;\n    }\n\n    // Skip request if the new view is already fully covered by the last COMPLETED request\n    // at comparable resolution. This is very common while panning (and small\n    // zoom-ins) within a larger, recently fetched extent — e.g. on the globe a\n    // single request can cover the whole visible hemisphere, so rotating around it\n    // shouldn't hit the network again. The existing image is simply repositioned by\n    // the BitmapLayer. We still refetch once the user zooms in enough that the\n    // cached image would be visibly stretched (see COVERAGE_REFETCH_ZOOM_FACTOR).\n    if (\n      this.state.lastRequestParameters &&\n      this._isViewCoveredByLastRequest(this.state.lastRequestParameters, requestParams)\n    ) {\n      return;\n    }\n\n    // During video export, throttle zoom-in requests to only fire on zoom level crossings.\n    // The existing image is stretched by the BitmapLayer until the next level is reached.\n    // However, always allow requests if the new view isn't fully covered by the last image.\n    const gl = this.context.gl;\n    const isExporting = gl?.getContextAttributes?.()?.preserveDrawingBuffer;\n    \n    if (isExporting && this.state._lastRequestZoom >= 0) {\n      const currentZoom = viewport.zoom;\n      const lastZoom = this.state._lastRequestZoom;\n      const isZoomingIn = currentZoom > lastZoom;\n      \n      // Check if the new view is fully covered by the last loaded image\n      const lastBbox = this.state.lastRequestParameters?.bbox;\n      const currentBbox = requestParams.bbox;\n      let fullyContained = false;\n      \n      if (lastBbox && currentBbox) {\n        // New bbox must be fully inside the previous bbox\n        fullyContained = \n          currentBbox[0] >= lastBbox[0] && \n          currentBbox[1] >= lastBbox[1] && \n          currentBbox[2] <= lastBbox[2] && \n          currentBbox[3] <= lastBbox[3];\n      }\n      \n      // Only throttle if:\n      // 1. Zooming in (not zooming out or panning at same zoom)\n      // 2. Same zoom floor (haven't crossed an integer zoom level)\n      // 3. New view is fully contained in the last loaded image (no uncovered areas)\n      if (isZoomingIn && Math.floor(currentZoom) === Math.floor(lastZoom) && fullyContained) {\n        return;\n      }\n    }\n\n    // Mark request as in-flight to prevent duplicate requests\n    this.state.inFlightRequestParameters = requestParams;\n\n    const requestId = this.getRequestId();\n    try {\n      this.state.loadCounter++;\n      // Trigger a redraw to update the UI loading indicator\n      this.setNeedsRedraw();\n      this.props.onImageLoadStart(requestId);\n\n      const image = await this.state.imageSource.getImage(requestParams);\n\n      // If a request takes a long time, later requests may have already loaded.\n      if (this.state.lastRequestId < requestId) {\n        this.getCurrentLayer()?.props.onImageLoad(requestId);\n        // Update lastRequestParameters only after successful load\n        // This ensures coverage checks only use successfully loaded images\n        this.state.lastRequestParameters = requestParams;\n        this.state._lastRequestZoom = viewport.zoom;\n        // Not type safe...\n        this.setState({\n          image,\n          bounds,\n          lastRequestId: requestId\n        });\n      }\n    } catch (error) {\n      this.context.onError?.(error as Error, this);\n      this.getCurrentLayer()?.props.onImageLoadError(requestId, error as Error);\n    } finally {\n      // Clear in-flight marker when request completes (success or error)\n      this.state.inFlightRequestParameters = undefined;\n      this.state.loadCounter--;\n      // Trigger a redraw to update the UI loading indicator\n      this.setNeedsRedraw();\n    }\n  }\n\n  // HELPERS\n\n  /** Global counter for issuing unique request ids */\n  private getRequestId(): number {\n    return this.state._nextRequestId++;\n  }\n\n  /** Runs an action in the future, cancels it if the new action is issued before it executes */\n  private debounce(fn: () => void, ms = 500): void {\n    clearTimeout(this.state._timeoutId);\n    this.state._timeoutId = setTimeout(() => fn(), ms);\n  }\n\n  /**\n   * Returns true when the `next` view is fully inside the `prev` (last requested)\n   * extent AND not meaningfully higher resolution, so the cached image already\n   * covers the screen and no new request is needed.\n   */\n  private _isViewCoveredByLastRequest(prev: any, next: any): boolean {\n    // Coverage only makes sense within the same projection / dataset / canvas size.\n    if (\n      prev.srs !== next.srs ||\n      prev.width !== next.width ||\n      prev.height !== next.height ||\n      prev.transparent !== next.transparent ||\n      !deepEqual(prev.layers, next.layers)\n    ) {\n      return false;\n    }\n\n    const p = prev.bbox;\n    const n = next.bbox;\n    if (!p || !n) {\n      return false;\n    }\n\n    // Is the new bbox fully contained within the previously requested bbox?\n    const contained = n[0] >= p[0] && n[1] >= p[1] && n[2] <= p[2] && n[3] <= p[3];\n    \n    if (!contained) {\n      return false;\n    }\n\n    // Ground resolution is proportional to bbox span / pixel count. The guard\n    // above already ensured prev and next share the same width/height, so equal\n    // pixel counts let us compare spans directly. Only skip while the new view\n    // isn't much finer than what we already fetched, otherwise the cached image\n    // would look stretched/blurry.\n    const prevSpanX = p[2] - p[0];\n    const nextSpanX = n[2] - n[0];\n    const prevSpanY = p[3] - p[1];\n    const nextSpanY = n[3] - n[1];\n\n    return (\n      nextSpanX >= prevSpanX / COVERAGE_REFETCH_ZOOM_FACTOR &&\n      nextSpanY >= prevSpanY / COVERAGE_REFETCH_ZOOM_FACTOR\n    );\n  }\n\n  /** Compare request parameters to determine if a new request is needed */\n  private _areRequestParamsEqual(prev: any, next: any): boolean {\n    // Compare dimensions\n    if (prev.width !== next.width || prev.height !== next.height) {\n      return false;\n    }\n\n    // Compare SRS\n    if (prev.srs !== next.srs) {\n      return false;\n    }\n\n    // Compare layers\n    if (!deepEqual(prev.layers, next.layers)) {\n      return false;\n    }\n\n    // Compare transparent\n    if (prev.transparent !== next.transparent) {\n      return false;\n    }\n\n    // Compare bounds with tolerance for floating point precision\n    const tolerance = 1e-10;\n    const prevBbox = prev.bbox;\n    const nextBbox = next.bbox;\n\n    if (prevBbox && nextBbox) {\n      for (let i = 0; i < 4; i++) {\n        if (Math.abs(prevBbox[i] - nextBbox[i]) > tolerance) {\n          return false;\n        }\n      }\n    }\n\n    return true;\n  }\n}\n\n/**\n * Compute the [minLng, minLat, maxLng, maxLat] bounding box of the part of the\n * globe that is actually visible on screen.\n *\n * Unlike `GlobeViewport.getBounds()` (4 edge midpoints), this samples a grid of\n * screen pixels, unprojects each onto the sphere (deck.gl clamps rays that miss\n * the globe to the silhouette/limb, which is exactly the boundary we want), and\n * takes the extent. It additionally detects when a pole is in view: at a pole all\n * meridians converge, so we widen the box to the full longitude range and extend\n * the latitude up to the pole, which is what makes viewing from near a pole\n * (seeing across to the far hemisphere) work.\n */\nexport function getGlobeVisibleBounds(viewport: Viewport): [number, number, number, number] {\n  const {width, height} = viewport;\n  const centerLng = (viewport as any).longitude ?? 0;\n\n  const SAMPLES = 8; // 8x8 cells => 9x9 = 81 sample points\n  const lats: number[] = [];\n  // Longitudes tracked as signed offsets from the center longitude, unwrapped to\n  // (-180, 180], so an antimeridian-crossing view stays a contiguous range.\n  const lngOffsets: number[] = [];\n\n  for (let i = 0; i <= SAMPLES; i++) {\n    for (let j = 0; j <= SAMPLES; j++) {\n      const px = (i / SAMPLES) * width;\n      const py = (j / SAMPLES) * height;\n      const coord = viewport.unproject([px, py]);\n      const lng = coord[0];\n      const lat = coord[1];\n      if (!Number.isFinite(lng) || !Number.isFinite(lat)) {\n        continue;\n      }\n      lats.push(lat);\n      // Wrap the offset into (-180, 180].\n      const offset = ((lng - centerLng + 540) % 360) - 180;\n      lngOffsets.push(offset);\n    }\n  }\n\n  // Extremely degenerate viewport: fall back to deck's default.\n  if (lats.length === 0) {\n    return viewport.getBounds();\n  }\n\n  let minLat = Math.min(...lats);\n  let maxLat = Math.max(...lats);\n\n  const northPoleVisible = isGlobeSurfacePointVisible(viewport, 90);\n  const southPoleVisible = isGlobeSurfacePointVisible(viewport, -90);\n\n  let minLng: number;\n  let maxLng: number;\n\n  if (northPoleVisible || southPoleVisible) {\n    // A pole is on screen: every meridian is visible, so cover all longitudes and\n    // extend latitude up to the visible pole.\n    minLng = -180;\n    maxLng = 180;\n    if (northPoleVisible) {\n      maxLat = 90;\n    }\n    if (southPoleVisible) {\n      minLat = -90;\n    }\n  } else {\n    minLng = centerLng + Math.min(...lngOffsets);\n    maxLng = centerLng + Math.max(...lngOffsets);\n  }\n\n  // Pad slightly so the discrete sampling doesn't clip the true limb.\n  const latPad = Math.min(5, (maxLat - minLat) * 0.05 + 0.5);\n  minLat = Math.max(-90, minLat - latPad);\n  maxLat = Math.min(90, maxLat + latPad);\n\n  if (maxLng - minLng < 360) {\n    const lngPad = Math.min(5, (maxLng - minLng) * 0.05 + 0.5);\n    minLng -= lngPad;\n    maxLng += lngPad;\n  }\n\n  // A single EPSG:4326 rectangle can't cross the antimeridian, so if the visible\n  // span wraps past ±180 (or covers the whole world) request the full longitude\n  // range. This over-covers only near the dateline, which is an acceptable\n  // trade-off for a valid, gap-free request.\n  if (maxLng - minLng >= 360 || minLng < -180 || maxLng > 180) {\n    minLng = -180;\n    maxLng = 180;\n  }\n\n  return [minLng, minLat, maxLng, maxLat];\n}\n\n/**\n * Whether a point on the globe surface at the given latitude (longitude is\n * irrelevant at the poles) is both front-facing (not occluded by the globe) and\n * inside the screen. Uses the sphere-horizon test in deck.gl common space:\n * a surface point is front-facing when the angle between its outward normal and\n * the camera direction is within the horizon half-angle, i.e.\n *   dot(normalize(pointCommon), normalize(cameraPosition)) >= radius / cameraDist\n */\nfunction isGlobeSurfacePointVisible(viewport: Viewport, lat: number): boolean {\n  const {width, height} = viewport;\n  const point = viewport.projectPosition([0, lat, 0]);\n  const camera = viewport.cameraPosition;\n\n  const rPoint = Math.hypot(point[0], point[1], point[2]);\n  const rCam = Math.hypot(camera[0], camera[1], camera[2]);\n  if (rPoint === 0 || rCam === 0 || rCam <= rPoint) {\n    return false;\n  }\n\n  const cosSurface =\n    (point[0] * camera[0] + point[1] * camera[1] + point[2] * camera[2]) / (rPoint * rCam);\n  const cosHorizon = rPoint / rCam;\n  if (cosSurface < cosHorizon) {\n    return false;\n  }\n\n  const screen = viewport.project([0, lat, 0]);\n  return screen[0] >= 0 && screen[0] <= width && screen[1] >= 0 && screen[1] <= height;\n}\n\n// https://epsg.io/3857\n// +proj=merc +a=6378137 +b=6378137 +lat_ts=0 +lon_0=0 +x_0=0 +y_0=0 +k=1 +units=m +nadgrids=@null +wktext +no_defs +type=crs\nconst HALF_EARTH_CIRCUMFERENCE = 6378137 * Math.PI;\n\n/** Projects EPSG:4326 to EPSG:3857\n * This is a lightweight replacement of proj4. Use tests to ensure conformance.\n */\nexport function WGS84ToPseudoMercator(coord: [number, number]): [number, number] {\n  const mercator = lngLatToWorld(coord);\n  mercator[0] = (mercator[0] / 256 - 1) * HALF_EARTH_CIRCUMFERENCE;\n  mercator[1] = (mercator[1] / 256 - 1) * HALF_EARTH_CIRCUMFERENCE;\n  return mercator;\n}\n"],"mappings":"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","ignoreList":[]}