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

package/dist/esm/globe/globe-stars-layer.js

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Generates a CSS-compatible star-field background image as a data URL.
+ * The stars are rendered onto an offscreen canvas, tiled seamlessly via CSS
+ * `background-repeat`. The result is deterministic (seeded PRNG) and cached
+ * so it's only generated once.
+ */
+
+var STAR_CANVAS_SIZE = 512;
+var STAR_COUNT = 600;
+
+// Seeded pseudo-random number generator (Park-Miller) for determinism.
+function seededRandom(seed) {
+  var s = seed;
+  return function () {
+    s = s * 16807 % 2147483647;
+    return (s - 1) / 2147483646;
+  };
+}
+
+// Transparent 1x1 PNG used as a fallback when a canvas context is unavailable
+// (SSR or unsupported browser), so that `url(...)` never resolves to an empty
+// value that could trigger a request for the current document.
+var TRANSPARENT_PIXEL = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=';
+var cachedDataUrl = null;
+
+/**
+ * Returns a data URL of a tileable star-field image (512×512 PNG).
+ * Generates the image once and caches it for subsequent calls.
+ */
+export function getStarsBackgroundImage() {
+  if (cachedDataUrl) return cachedDataUrl;
+  if (typeof document === 'undefined') {
+    // SSR fallback: return a transparent 1x1 pixel to avoid url() triggering a page request
+    return TRANSPARENT_PIXEL;
+  }
+  var canvas = document.createElement('canvas');
+  canvas.width = STAR_CANVAS_SIZE;
+  canvas.height = STAR_CANVAS_SIZE;
+  var ctx = canvas.getContext('2d');
+  if (!ctx) return cachedDataUrl = TRANSPARENT_PIXEL;
+
+  // Transparent background so CSS backgroundColor shows through
+  ctx.clearRect(0, 0, STAR_CANVAS_SIZE, STAR_CANVAS_SIZE);
+  var random = seededRandom(42);
+  for (var i = 0; i < STAR_COUNT; i++) {
+    var x = random() * STAR_CANVAS_SIZE;
+    var y = random() * STAR_CANVAS_SIZE;
+    var brightness = 140 + Math.floor(random() * 115); // 140–255
+    var alpha = 0.4 + random() * 0.6; // 0.4–1.0
+    var radius = 0.3 + random() * 1.0; // 0.3–1.3 px
+
+    ctx.beginPath();
+    ctx.arc(x, y, radius, 0, Math.PI * 2);
+    ctx.fillStyle = "rgba(".concat(brightness, ", ").concat(brightness, ", ").concat(brightness, ", ").concat(alpha, ")");
+    ctx.fill();
+  }
+  cachedDataUrl = canvas.toDataURL('image/png');
+  return cachedDataUrl;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/globe/globe-view.js

@@ -0,0 +1,401 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _readOnlyError from "@babel/runtime/helpers/esm/readOnlyError";
+import _get from "@babel/runtime/helpers/esm/get";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+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 _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; }
+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; })(); }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import * as DeckCore from '@deck.gl/core';
+import { clamp, vec4 } from '@math.gl/core';
+import { GLOBE_MAX_LATITUDE } from '@kepler.gl/constants';
+import { GLOBE_COMMON_RADIUS } from './globe-depth-disk-layer';
+
+// deck.gl exposes GlobeView / GlobeController as experimental, underscore-prefixed
+// members. Their named type bindings aren't reliably resolvable through the
+// package barrel under this project's module resolution, so we pull them off the
+// namespace with a loose type. Runtime behavior is unchanged.
+var DeckGlobeView = DeckCore._GlobeView;
+var GlobeController = DeckCore._GlobeController;
+var DeckGlobeViewport = DeckCore._GlobeViewport;
+
+/**
+ * Latitude-based zoom adjustment used by deck.gl's GlobeViewport, replicated
+ * here so our custom `_constrainZoom` matches deck.gl's coordinate math.
+ * See @deck.gl/core globe-viewport.js `zoomAdjust`.
+ */
+function zoomAdjust(latitude) {
+  return Math.log2(Math.PI * Math.cos(latitude * Math.PI / 180));
+}
+
+/**
+ * Returns true if the screen pixel `pos` lies within the visible globe
+ * silhouette.
+ *
+ * GlobeViewport.unproject() clamps the ray–sphere discriminant with
+ * Math.max(0, r²−d²), so it always returns a valid lng/lat even for
+ * off-globe pixels (snapping to the limb).  We replicate the same ray cast
+ * but check the discriminant before the clamp using the standard
+ * squared-distance-from-origin-to-ray formula: |P₀ × dir|² / |dir|².
+ */
+function isPixelOnGlobe(viewport, pos) {
+  var m = viewport.pixelUnprojectionMatrix;
+  if (!m) return true; // conservative fallback if matrix unavailable
+
+  // Cast a ray through the pixel at the near and far planes.
+  var p0 = vec4.transformMat4([], [pos[0], pos[1], -1, 1], m);
+  var p1 = vec4.transformMat4([], [pos[0], pos[1], 1, 1], m);
+  if (p0[3] === 0 || p1[3] === 0) return true; // degenerate projection
+
+  // Perspective-divide to world space.
+  var ax = p0[0] / p0[3],
+    ay = p0[1] / p0[3],
+    az = p0[2] / p0[3];
+  var bx = p1[0] / p1[3],
+    by = p1[1] / p1[3],
+    bz = p1[2] / p1[3];
+
+  // Ray direction.
+  var dx = bx - ax,
+    dy = by - ay,
+    dz = bz - az;
+
+  // Squared distance from the origin (globe center) to the ray:
+  //   d² = |P₀ × dir|² / |dir|²
+  var cx = ay * dz - az * dy;
+  var cy = az * dx - ax * dz;
+  var cz = ax * dy - ay * dx;
+  var dSqr = (cx * cx + cy * cy + cz * cz) / (dx * dx + dy * dy + dz * dz);
+  return dSqr <= GLOBE_COMMON_RADIUS * GLOBE_COMMON_RADIUS;
+}
+
+/**
+ * Custom GlobeController that restores zoom-to-cursor behavior.
+ *
+ * In deck.gl 9.x, the default GlobeController's GlobeState.zoom() ignores the
+ * cursor position and always zooms toward the center. This controller patches
+ * that behavior by overriding the ControllerState's zoom method to pan the
+ * globe under the cursor while zooming, so zoom-to-cursor works the same way it
+ * does for the 2D MapController.
+ */
+var ZoomToCursorGlobeController = /*#__PURE__*/function (_GlobeController) {
+  function ZoomToCursorGlobeController() {
+    var _this;
+    _classCallCheck(this, ZoomToCursorGlobeController);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, ZoomToCursorGlobeController, [].concat(args));
+    var OriginalGlobeState = _this.ControllerState;
+
+    // Tracks when the most recent off-globe wheel-zoom tick fired.
+    // Stored as a controller-level closure variable rather than in ViewState
+    // because deck.gl's Controller never calls zoomEnd() for wheel events —
+    // only for pinch/touch — so there is no reliable hook to clear a
+    // ViewState-based sentinel after a wheel scroll session ends.
+    // A simple timestamp lets us detect when a new scroll burst has started
+    // (> BURST_TIMEOUT_MS since the last off-globe tick) so cursor-anchored
+    // zoom can resume naturally on the next independent scroll.
+    var offGlobeZoomAt = null;
+
+    // Create patched GlobeState that supports zoom-to-cursor
+    _this.ControllerState = /*#__PURE__*/function (_OriginalGlobeState) {
+      function PatchedGlobeState() {
+        _classCallCheck(this, PatchedGlobeState);
+        return _callSuper(this, PatchedGlobeState, arguments);
+      }
+      _inherits(PatchedGlobeState, _OriginalGlobeState);
+      return _createClass(PatchedGlobeState, [{
+        key: "applyConstraints",
+        value:
+        // Constrain the camera target to a latitude band around the equator so the
+        // view can't be centered on the poles. deck.gl's applyConstraints clamps
+        // latitude to ~85°, which still lets the camera look straight at a pole.
+        function applyConstraints(props) {
+          // Avoid `(super.fn as any)(args)` — Babel compiles that to a property GET
+          // (`_superPropGet(..., 1)`) that drops `this`. A direct call uses method-CALL
+          // form (`_superPropGet(..., 3)`), which preserves the binding.
+          var result = _superPropGet(PatchedGlobeState, "applyConstraints", this, 3)([props]);
+          var clampedLatitude = clamp(result.latitude, -GLOBE_MAX_LATITUDE, GLOBE_MAX_LATITUDE);
+          if (clampedLatitude !== result.latitude) {
+            // deck.gl couples zoom to latitude via zoomAdjust; when we further
+            // clamp latitude, re-apply the same delta so zoom stays consistent.
+            result.zoom += zoomAdjust(clampedLatitude) - zoomAdjust(result.latitude);
+            result.latitude = clampedLatitude;
+          }
+          return result;
+        }
+
+        // deck.gl's GlobeState._constrainZoom derives a minimum zoom from `maxBounds`
+        // that forces the globe to fill the viewport. That bounds-based minimum
+        // (~3 for a typical window) overrides any configured `minZoom`, so the user
+        // can never zoom out far enough to see the whole globe small on screen.
+        // Override it to honor only the configured minZoom/maxZoom (plus the same
+        // latitude adjustment deck.gl uses), ignoring the bounds-based floor.
+      }, {
+        key: "_constrainZoom",
+        value: function _constrainZoom(zoom, props) {
+          props = props || this.getViewportProps();
+          var _props = props,
+            latitude = _props.latitude,
+            maxZoom = _props.maxZoom;
+          var _props2 = props,
+            minZoom = _props2.minZoom;
+          if (minZoom === undefined || minZoom === null) {
+            minZoom = 0;
+          }
+          var ZOOM0 = zoomAdjust(0);
+          var zoomAdjustment = zoomAdjust(latitude) - ZOOM0;
+          return clamp(zoom, minZoom + zoomAdjustment, maxZoom + zoomAdjustment);
+        }
+
+        // Exact zoom-to-cursor. deck.gl 9.x's GlobeController does not keep the point
+        // under the cursor fixed while zooming, in two ways we work around here:
+        //   1. Its GlobeState.zoom() ignores the cursor and zooms toward the center.
+        //   2. Its GlobeViewport.panByPosition is a lossy, *linearized* 3-arg
+        //      rotation (longitude += (0.25/scale)*(startPixel-pixel), re-derives
+        //      zoom). Using it per wheel tick accumulates error, so after a long
+        //      continuous zoom the point ends up noticeably shifted from what was
+        //      originally under the cursor.
+        // The recenter below is an *exact absolute* translation: unproject the
+        // cursor pixel in the zoomed viewport to get the geo point currently under it,
+        // then shift the center by (anchor - thatPoint). No zoom coupling, no
+        // rotationSpeed, and it applies to zoom-in and zoom-out symmetrically, so
+        // there is no per-tick accumulated drift.
+      }, {
+        key: "zoom",
+        value: function zoom(_ref) {
+          var pos = _ref.pos,
+            startPos = _ref.startPos,
+            scale = _ref.scale;
+          var _getState = this.getState(),
+            startZoom = _getState.startZoom,
+            startZoomLngLat = _getState.startZoomLngLat;
+          var currentProps = this.getViewportProps();
+          if (!startZoomLngLat) {
+            // Wheel zoom: re-derive anchor each tick (pinch sets it once in zoomStart).
+            startZoom = currentProps.zoom;
+
+            // Suppress cursor-anchoring when the cursor is off-globe or when a
+            // recent tick was off-globe (within BURST_TIMEOUT_MS).  deck.gl never
+            // calls zoomEnd() for wheel events so we track the session with the
+            // closure variable `offGlobeZoomAt` rather than ViewState.
+            var BURST_TIMEOUT_MS = 200;
+            var now = Date.now();
+            var anchorViewport = this.makeViewport(currentProps);
+            var onGlobe = isPixelOnGlobe(anchorViewport, startPos || pos);
+            if (!onGlobe) offGlobeZoomAt = now;
+            if (!onGlobe || offGlobeZoomAt !== null && now - offGlobeZoomAt < BURST_TIMEOUT_MS) {
+              var _zoom = this._constrainZoom(startZoom + Math.log2(scale));
+              return this._getUpdatedState({
+                zoom: _zoom
+              });
+            }
+            offGlobeZoomAt = null;
+            startZoomLngLat = this._unproject(startPos) || this._unproject(pos);
+          }
+          var zoom = this._constrainZoom(startZoom + Math.log2(scale));
+          if (!startZoomLngLat) {
+            return this._getUpdatedState({
+              zoom: zoom
+            });
+          }
+
+          // Zoom-out (scale < 1): exact cursor anchoring is unstable near the limb
+          // (non-linear geo-to-pixel mapping pulls the view toward the poles).
+          // Instead, gently steer the center toward the cursor location per tick.
+          if (scale < 1) {
+            if (!Array.isArray(startZoomLngLat) || !Number.isFinite(startZoomLngLat[0]) || !Number.isFinite(startZoomLngLat[1])) {
+              return this._getUpdatedState({
+                zoom: zoom
+              });
+            }
+
+            // Per-tick lerp strength scales with zoom-out amount; clamped to avoid overshoot.
+            var t = Math.min(1, (1 - scale) * 0.11);
+
+            // Shortest-path longitude interpolation (handles antimeridian wrap).
+            var dLng = startZoomLngLat[0] - currentProps.longitude;
+            if (dLng > 180) dLng -= 360;
+            if (dLng < -180) dLng += 360;
+            return this._getUpdatedState({
+              zoom: zoom,
+              longitude: currentProps.longitude + dLng * t,
+              latitude: currentProps.latitude + (startZoomLngLat[1] - currentProps.latitude) * t
+            });
+          }
+          var zoomedViewport = this.makeViewport(_objectSpread(_objectSpread({}, currentProps), {}, {
+            zoom: zoom
+          }));
+
+          // Zoom-in: exact anchor — unproject the cursor in the post-zoom viewport and
+          // shift the center so the grabbed geo point lands back under the cursor.
+          // Guard with isPixelOnGlobe: if pos moved off-globe during a fast pinch,
+          // fall back to center zoom.
+          if (!isPixelOnGlobe(zoomedViewport, pos)) {
+            return this._getUpdatedState({
+              zoom: zoom
+            });
+          }
+          var fromPosition = zoomedViewport.unproject(pos);
+          return this._getUpdatedState({
+            zoom: zoom,
+            longitude: startZoomLngLat[0] - fromPosition[0] + zoomedViewport.longitude,
+            latitude: startZoomLngLat[1] - fromPosition[1] + zoomedViewport.latitude
+          });
+        }
+
+        // Clear the persisted pinch anchor at gesture end.
+      }, {
+        key: "zoomEnd",
+        value: function zoomEnd() {
+          return this._getUpdatedState({
+            startZoom: null,
+            startZoomLngLat: null
+          });
+        }
+
+        // Exact, cursor-anchored pan: the geo point grabbed on mousedown stays
+        // locked under the cursor for the whole drag.
+        //
+        // deck.gl 9.x's GlobeController pans with a *linearized, center-anchored*
+        // rotation (GlobeViewport.panByPosition([lng,lat,zoom], pixel, startPixel):
+        // longitude += (0.25/scale)*(startPixel-pixel)). Because the anchor is the
+        // view CENTER rather than the grabbed point, the first drag frame snaps the
+        // center to satisfy the linear approximation, producing the visible "jump to
+        // the side/up" at the start of a pan (most noticeable at high zoom), after
+        // which incremental deltas track fine. The exact anchor below removes that
+        // first-frame snap.
+      }, {
+        key: "panStart",
+        value: function panStart(_ref2) {
+          var pos = _ref2.pos;
+          var viewport = this.makeViewport(this.getViewportProps());
+          // If the mousedown pixel is outside the globe silhouette, store `false`
+          // as an explicit sentinel so that every subsequent `pan` call for this
+          // gesture is a no-op.  We can't rely on `_unproject(pos)` returning
+          // undefined here because GlobeViewport.unproject clamps the
+          // ray–sphere discriminant to 0 via Math.max(0, …), which means it
+          // always returns a valid-looking lng/lat even for off-globe pixels.
+          if (!isPixelOnGlobe(viewport, pos)) {
+            return this._getUpdatedState({
+              startPanLngLat: false
+            });
+          }
+          return this._getUpdatedState({
+            startPanLngLat: this._unproject(pos)
+          });
+        }
+      }, {
+        key: "pan",
+        value: function pan(_ref3) {
+          var pos = _ref3.pos,
+            startPos = _ref3.startPos;
+          var storedStart = this.getState().startPanLngLat;
+          var props = this.getViewportProps();
+          var viewport = this.makeViewport(props);
+
+          // `false` means the drag started outside the globe. If the cursor has
+          // now moved onto the globe, latch the current position as the anchor
+          // so rotation begins from the entry point. Otherwise stay frozen.
+          if (storedStart === false) {
+            if (!isPixelOnGlobe(viewport, pos)) {
+              return this;
+            }
+            // Cursor just entered the globe — establish the anchor and return
+            // without moving; the next pan event will apply the first delta.
+            return this._getUpdatedState({
+              startPanLngLat: this._unproject(pos)
+            });
+          }
+          var startPanLngLat = storedStart || this._unproject(startPos);
+          if (!startPanLngLat) {
+            return this;
+          }
+
+          // Once the cursor leaves the globe silhouette mid-drag, freeze the view.
+          // viewport.unproject() snaps off-globe pixels to the nearest limb point
+          // (via Math.max(0, …) in its ray–sphere discriminant), so without this
+          // guard the globe would keep rotating toward the edge as the cursor moves
+          // further outside.
+          if (!isPixelOnGlobe(viewport, pos)) {
+            return this;
+          }
+          var fromPosition = viewport.unproject(pos);
+          var longitude = startPanLngLat[0] - fromPosition[0] + props.longitude;
+          var latitude = startPanLngLat[1] - fromPosition[1] + props.latitude;
+          latitude = clamp(latitude, -GLOBE_MAX_LATITUDE, GLOBE_MAX_LATITUDE);
+
+          // deck.gl 9's GlobeViewport scale = 2^(zoom - zoomAdjust(latitude)), so a
+          // constant zoom would make the globe grow on screen as the center moves
+          // toward the poles. Re-couple zoom to the new latitude (as deck.gl 9's own
+          // pan does) to keep the on-screen scale — and thus tile LOD — constant.
+          var visualZoom = props.zoom - zoomAdjust(props.latitude);
+          var zoom = visualZoom + zoomAdjust(latitude);
+          return this._getUpdatedState({
+            longitude: longitude,
+            latitude: latitude,
+            zoom: zoom
+          });
+        }
+      }, {
+        key: "panEnd",
+        value: function panEnd() {
+          return this._getUpdatedState({
+            startPanLngLat: null
+          });
+        }
+      }]);
+    }(OriginalGlobeState);
+    return _this;
+  }
+  _inherits(ZoomToCursorGlobeController, _GlobeController);
+  return _createClass(ZoomToCursorGlobeController);
+}(GlobeController);
+/**
+ * Custom GlobeView that uses zoom-to-cursor controller behavior.
+ */
+export var KeplerGlobeView = /*#__PURE__*/function (_DeckGlobeView) {
+  // Forward constructor props to deck.gl's GlobeView. Declared explicitly because
+  // the base class is loosely typed (see DeckGlobeView above), which would
+  // otherwise surface a parameterless constructor to callers.
+  function KeplerGlobeView(props) {
+    _classCallCheck(this, KeplerGlobeView);
+    return _callSuper(this, KeplerGlobeView, [props]);
+  }
+  _inherits(KeplerGlobeView, _DeckGlobeView);
+  return _createClass(KeplerGlobeView, [{
+    key: "ControllerType",
+    get: function get() {
+      return ZoomToCursorGlobeController;
+    }
+
+    // deck.gl 9's GlobeView.getViewportType() swaps the viewport class based on zoom:
+    //   `return viewState.zoom > 12 ? WebMercatorViewport : GlobeViewport;`
+    // Crossing zoom 12 therefore recomputes tile bounds with completely different
+    // projection math (globe vs flat mercator). That makes deck's TileLayer/MVTLayer
+    // reselect tiles inconsistently across the boundary — mixed LODs (e.g. a z4 tile
+    // next to z11), a visible "flicker" at 12, and tiles that get dropped and stick
+    // as black/empty quads (most often crossing 12 on the way *out*).
+    //
+    // Force GlobeViewport at every zoom to eliminate the z=12 viewport swap so tile
+    // selection stays consistent. The trade-off is that zoom > 12 now uses float32
+    // globe precision (deck's documented "no high-precision rendering > 12" limit)
+    // instead of switching to mercator — far preferable to the black quads.
+  }, {
+    key: "getViewportType",
+    value: function getViewportType() {
+      return DeckGlobeViewport;
+    }
+  }]);
+}(DeckGlobeView);
+KeplerGlobeView.displayName = 'KeplerGlobeView';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DeckCore","clamp","vec4","GLOBE_MAX_LATITUDE","GLOBE_COMMON_RADIUS","DeckGlobeView","_GlobeView","GlobeController","_GlobeController","DeckGlobeViewport","_GlobeViewport","zoomAdjust","latitude","Math","log2","PI","cos","isPixelOnGlobe","viewport","pos","m","pixelUnprojectionMatrix","p0","transformMat4","p1","ax","ay","az","bx","by","bz","dx","dy","dz","cx","cy","cz","dSqr","ZoomToCursorGlobeController","_this","_classCallCheck","_len","arguments","length","args","Array","_key","_callSuper","concat","OriginalGlobeState","ControllerState","offGlobeZoomAt","_OriginalGlobeState","PatchedGlobeState","_inherits","_createClass","key","value","applyConstraints","props","result","_superPropGet","clampedLatitude","zoom","_constrainZoom","getViewportProps","_props","maxZoom","_props2","minZoom","undefined","ZOOM0","zoomAdjustment","_ref","startPos","scale","_getState","getState","startZoom","startZoomLngLat","currentProps","BURST_TIMEOUT_MS","now","Date","anchorViewport","makeViewport","onGlobe","_getUpdatedState","_unproject","isArray","Number","isFinite","t","min","dLng","longitude","zoomedViewport","_objectSpread","fromPosition","unproject","zoomEnd","panStart","_ref2","startPanLngLat","pan","_ref3","storedStart","visualZoom","panEnd","KeplerGlobeView","_DeckGlobeView","get","getViewportType","displayName"],"sources":["../../../src/globe/globe-view.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport * as DeckCore from '@deck.gl/core';\nimport {clamp, vec4} from '@math.gl/core';\nimport {GLOBE_MAX_LATITUDE} from '@kepler.gl/constants';\nimport {GLOBE_COMMON_RADIUS} from './globe-depth-disk-layer';\n\n// deck.gl exposes GlobeView / GlobeController as experimental, underscore-prefixed\n// members. Their named type bindings aren't reliably resolvable through the\n// package barrel under this project's module resolution, so we pull them off the\n// namespace with a loose type. Runtime behavior is unchanged.\nconst DeckGlobeView = (DeckCore as any)._GlobeView as any;\nconst GlobeController = (DeckCore as any)._GlobeController as any;\nconst DeckGlobeViewport = (DeckCore as any)._GlobeViewport as any;\n\n/**\n * Latitude-based zoom adjustment used by deck.gl's GlobeViewport, replicated\n * here so our custom `_constrainZoom` matches deck.gl's coordinate math.\n * See @deck.gl/core globe-viewport.js `zoomAdjust`.\n */\nfunction zoomAdjust(latitude: number): number {\n  return Math.log2(Math.PI * Math.cos((latitude * Math.PI) / 180));\n}\n\n/**\n * Returns true if the screen pixel `pos` lies within the visible globe\n * silhouette.\n *\n * GlobeViewport.unproject() clamps the ray–sphere discriminant with\n * Math.max(0, r²−d²), so it always returns a valid lng/lat even for\n * off-globe pixels (snapping to the limb).  We replicate the same ray cast\n * but check the discriminant before the clamp using the standard\n * squared-distance-from-origin-to-ray formula: |P₀ × dir|² / |dir|².\n */\nfunction isPixelOnGlobe(viewport: any, pos: [number, number]): boolean {\n  const m: number[] = viewport.pixelUnprojectionMatrix;\n  if (!m) return true; // conservative fallback if matrix unavailable\n\n  // Cast a ray through the pixel at the near and far planes.\n  const p0 = vec4.transformMat4([], [pos[0], pos[1], -1, 1], m);\n  const p1 = vec4.transformMat4([], [pos[0], pos[1], 1, 1], m);\n  if (p0[3] === 0 || p1[3] === 0) return true; // degenerate projection\n\n  // Perspective-divide to world space.\n  const ax = p0[0] / p0[3], ay = p0[1] / p0[3], az = p0[2] / p0[3];\n  const bx = p1[0] / p1[3], by = p1[1] / p1[3], bz = p1[2] / p1[3];\n\n  // Ray direction.\n  const dx = bx - ax, dy = by - ay, dz = bz - az;\n\n  // Squared distance from the origin (globe center) to the ray:\n  //   d² = |P₀ × dir|² / |dir|²\n  const cx = ay * dz - az * dy;\n  const cy = az * dx - ax * dz;\n  const cz = ax * dy - ay * dx;\n  const dSqr = (cx * cx + cy * cy + cz * cz) / (dx * dx + dy * dy + dz * dz);\n\n  return dSqr <= GLOBE_COMMON_RADIUS * GLOBE_COMMON_RADIUS;\n}\n\n/**\n * Custom GlobeController that restores zoom-to-cursor behavior.\n *\n * In deck.gl 9.x, the default GlobeController's GlobeState.zoom() ignores the\n * cursor position and always zooms toward the center. This controller patches\n * that behavior by overriding the ControllerState's zoom method to pan the\n * globe under the cursor while zooming, so zoom-to-cursor works the same way it\n * does for the 2D MapController.\n */\nclass ZoomToCursorGlobeController extends GlobeController {\n  constructor(...args: any[]) {\n    super(...args);\n    const OriginalGlobeState = this.ControllerState;\n\n    // Tracks when the most recent off-globe wheel-zoom tick fired.\n    // Stored as a controller-level closure variable rather than in ViewState\n    // because deck.gl's Controller never calls zoomEnd() for wheel events —\n    // only for pinch/touch — so there is no reliable hook to clear a\n    // ViewState-based sentinel after a wheel scroll session ends.\n    // A simple timestamp lets us detect when a new scroll burst has started\n    // (> BURST_TIMEOUT_MS since the last off-globe tick) so cursor-anchored\n    // zoom can resume naturally on the next independent scroll.\n    let offGlobeZoomAt: number | null = null;\n\n    // Create patched GlobeState that supports zoom-to-cursor\n    this.ControllerState = class PatchedGlobeState extends OriginalGlobeState {\n      // Constrain the camera target to a latitude band around the equator so the\n      // view can't be centered on the poles. deck.gl's applyConstraints clamps\n      // latitude to ~85°, which still lets the camera look straight at a pole.\n      applyConstraints(props: any) {\n        // Avoid `(super.fn as any)(args)` — Babel compiles that to a property GET\n        // (`_superPropGet(..., 1)`) that drops `this`. A direct call uses method-CALL\n        // form (`_superPropGet(..., 3)`), which preserves the binding.\n        const result = super.applyConstraints(props);\n        const clampedLatitude = clamp(result.latitude, -GLOBE_MAX_LATITUDE, GLOBE_MAX_LATITUDE);\n        if (clampedLatitude !== result.latitude) {\n          // deck.gl couples zoom to latitude via zoomAdjust; when we further\n          // clamp latitude, re-apply the same delta so zoom stays consistent.\n          result.zoom += zoomAdjust(clampedLatitude) - zoomAdjust(result.latitude);\n          result.latitude = clampedLatitude;\n        }\n        return result;\n      }\n\n      // deck.gl's GlobeState._constrainZoom derives a minimum zoom from `maxBounds`\n      // that forces the globe to fill the viewport. That bounds-based minimum\n      // (~3 for a typical window) overrides any configured `minZoom`, so the user\n      // can never zoom out far enough to see the whole globe small on screen.\n      // Override it to honor only the configured minZoom/maxZoom (plus the same\n      // latitude adjustment deck.gl uses), ignoring the bounds-based floor.\n      _constrainZoom(zoom: number, props?: any) {\n        props = props || (this as any).getViewportProps();\n        const {latitude, maxZoom} = props;\n        let {minZoom} = props;\n        if (minZoom === undefined || minZoom === null) {\n          minZoom = 0;\n        }\n        const ZOOM0 = zoomAdjust(0);\n        const zoomAdjustment = zoomAdjust(latitude) - ZOOM0;\n        return clamp(zoom, minZoom + zoomAdjustment, maxZoom + zoomAdjustment);\n      }\n\n      // Exact zoom-to-cursor. deck.gl 9.x's GlobeController does not keep the point\n      // under the cursor fixed while zooming, in two ways we work around here:\n      //   1. Its GlobeState.zoom() ignores the cursor and zooms toward the center.\n      //   2. Its GlobeViewport.panByPosition is a lossy, *linearized* 3-arg\n      //      rotation (longitude += (0.25/scale)*(startPixel-pixel), re-derives\n      //      zoom). Using it per wheel tick accumulates error, so after a long\n      //      continuous zoom the point ends up noticeably shifted from what was\n      //      originally under the cursor.\n      // The recenter below is an *exact absolute* translation: unproject the\n      // cursor pixel in the zoomed viewport to get the geo point currently under it,\n      // then shift the center by (anchor - thatPoint). No zoom coupling, no\n      // rotationSpeed, and it applies to zoom-in and zoom-out symmetrically, so\n      // there is no per-tick accumulated drift.\n      zoom({\n        pos,\n        startPos,\n        scale\n      }: {\n        pos: [number, number];\n        startPos?: [number, number];\n        scale: number;\n      }) {\n        let {startZoom, startZoomLngLat} = (this as any).getState();\n        const currentProps = (this as any).getViewportProps();\n\n        if (!startZoomLngLat) {\n          // Wheel zoom: re-derive anchor each tick (pinch sets it once in zoomStart).\n          startZoom = currentProps.zoom;\n\n          // Suppress cursor-anchoring when the cursor is off-globe or when a\n          // recent tick was off-globe (within BURST_TIMEOUT_MS).  deck.gl never\n          // calls zoomEnd() for wheel events so we track the session with the\n          // closure variable `offGlobeZoomAt` rather than ViewState.\n          const BURST_TIMEOUT_MS = 200;\n          const now = Date.now();\n          const anchorViewport = (this as any).makeViewport(currentProps);\n          const onGlobe = isPixelOnGlobe(anchorViewport, startPos || pos);\n\n          if (!onGlobe) offGlobeZoomAt = now;\n\n          if (!onGlobe || (offGlobeZoomAt !== null && now - offGlobeZoomAt < BURST_TIMEOUT_MS)) {\n            const zoom = (this as any)._constrainZoom(startZoom + Math.log2(scale));\n            return (this as any)._getUpdatedState({zoom});\n          }\n\n          offGlobeZoomAt = null;\n          startZoomLngLat = (this as any)._unproject(startPos) || (this as any)._unproject(pos);\n        }\n\n        const zoom = (this as any)._constrainZoom(startZoom + Math.log2(scale));\n\n        if (!startZoomLngLat) {\n          return (this as any)._getUpdatedState({zoom});\n        }\n\n        // Zoom-out (scale < 1): exact cursor anchoring is unstable near the limb\n        // (non-linear geo-to-pixel mapping pulls the view toward the poles).\n        // Instead, gently steer the center toward the cursor location per tick.\n        if (scale < 1) {\n          if (\n            !Array.isArray(startZoomLngLat) ||\n            !Number.isFinite(startZoomLngLat[0]) ||\n            !Number.isFinite(startZoomLngLat[1])\n          ) {\n            return (this as any)._getUpdatedState({zoom});\n          }\n\n          // Per-tick lerp strength scales with zoom-out amount; clamped to avoid overshoot.\n          const t = Math.min(1, (1 - scale) * 0.11);\n\n          // Shortest-path longitude interpolation (handles antimeridian wrap).\n          let dLng = startZoomLngLat[0] - currentProps.longitude;\n          if (dLng > 180) dLng -= 360;\n          if (dLng < -180) dLng += 360;\n\n          return (this as any)._getUpdatedState({\n            zoom,\n            longitude: currentProps.longitude + dLng * t,\n            latitude: currentProps.latitude + (startZoomLngLat[1] - currentProps.latitude) * t\n          });\n        }\n\n        const zoomedViewport = (this as any).makeViewport({\n          ...currentProps,\n          zoom\n        });\n\n        // Zoom-in: exact anchor — unproject the cursor in the post-zoom viewport and\n        // shift the center so the grabbed geo point lands back under the cursor.\n        // Guard with isPixelOnGlobe: if pos moved off-globe during a fast pinch,\n        // fall back to center zoom.\n        if (!isPixelOnGlobe(zoomedViewport, pos)) {\n          return (this as any)._getUpdatedState({zoom});\n        }\n\n        const fromPosition = zoomedViewport.unproject(pos);\n\n        return (this as any)._getUpdatedState({\n          zoom,\n          longitude: startZoomLngLat[0] - fromPosition[0] + zoomedViewport.longitude,\n          latitude: startZoomLngLat[1] - fromPosition[1] + zoomedViewport.latitude\n        });\n      }\n\n      // Clear the persisted pinch anchor at gesture end.\n      zoomEnd() {\n        return (this as any)._getUpdatedState({\n          startZoom: null,\n          startZoomLngLat: null\n        });\n      }\n\n      // Exact, cursor-anchored pan: the geo point grabbed on mousedown stays\n      // locked under the cursor for the whole drag.\n      //\n      // deck.gl 9.x's GlobeController pans with a *linearized, center-anchored*\n      // rotation (GlobeViewport.panByPosition([lng,lat,zoom], pixel, startPixel):\n      // longitude += (0.25/scale)*(startPixel-pixel)). Because the anchor is the\n      // view CENTER rather than the grabbed point, the first drag frame snaps the\n      // center to satisfy the linear approximation, producing the visible \"jump to\n      // the side/up\" at the start of a pan (most noticeable at high zoom), after\n      // which incremental deltas track fine. The exact anchor below removes that\n      // first-frame snap.\n      panStart({pos}: {pos: [number, number]}) {\n        const viewport = (this as any).makeViewport((this as any).getViewportProps());\n        // If the mousedown pixel is outside the globe silhouette, store `false`\n        // as an explicit sentinel so that every subsequent `pan` call for this\n        // gesture is a no-op.  We can't rely on `_unproject(pos)` returning\n        // undefined here because GlobeViewport.unproject clamps the\n        // ray–sphere discriminant to 0 via Math.max(0, …), which means it\n        // always returns a valid-looking lng/lat even for off-globe pixels.\n        if (!isPixelOnGlobe(viewport, pos)) {\n          return (this as any)._getUpdatedState({startPanLngLat: false});\n        }\n        return (this as any)._getUpdatedState({\n          startPanLngLat: (this as any)._unproject(pos)\n        });\n      }\n\n      pan({pos, startPos}: {pos: [number, number]; startPos?: [number, number]}) {\n        const storedStart = (this as any).getState().startPanLngLat;\n\n        const props = (this as any).getViewportProps();\n        const viewport = (this as any).makeViewport(props);\n\n        // `false` means the drag started outside the globe. If the cursor has\n        // now moved onto the globe, latch the current position as the anchor\n        // so rotation begins from the entry point. Otherwise stay frozen.\n        if (storedStart === false) {\n          if (!isPixelOnGlobe(viewport, pos)) {\n            return this;\n          }\n          // Cursor just entered the globe — establish the anchor and return\n          // without moving; the next pan event will apply the first delta.\n          return (this as any)._getUpdatedState({\n            startPanLngLat: (this as any)._unproject(pos)\n          });\n        }\n\n        const startPanLngLat = storedStart || (this as any)._unproject(startPos);\n        if (!startPanLngLat) {\n          return this;\n        }\n\n        // Once the cursor leaves the globe silhouette mid-drag, freeze the view.\n        // viewport.unproject() snaps off-globe pixels to the nearest limb point\n        // (via Math.max(0, …) in its ray–sphere discriminant), so without this\n        // guard the globe would keep rotating toward the edge as the cursor moves\n        // further outside.\n        if (!isPixelOnGlobe(viewport, pos)) {\n          return this;\n        }\n\n        const fromPosition = viewport.unproject(pos);\n\n        const longitude = startPanLngLat[0] - fromPosition[0] + props.longitude;\n        let latitude = startPanLngLat[1] - fromPosition[1] + props.latitude;\n        latitude = clamp(latitude, -GLOBE_MAX_LATITUDE, GLOBE_MAX_LATITUDE);\n\n        // deck.gl 9's GlobeViewport scale = 2^(zoom - zoomAdjust(latitude)), so a\n        // constant zoom would make the globe grow on screen as the center moves\n        // toward the poles. Re-couple zoom to the new latitude (as deck.gl 9's own\n        // pan does) to keep the on-screen scale — and thus tile LOD — constant.\n        const visualZoom = props.zoom - zoomAdjust(props.latitude);\n        const zoom = visualZoom + zoomAdjust(latitude);\n\n        return (this as any)._getUpdatedState({longitude, latitude, zoom});\n      }\n\n      panEnd() {\n        return (this as any)._getUpdatedState({startPanLngLat: null});\n      }\n    } as any;\n  }\n}\n\n/**\n * Custom GlobeView that uses zoom-to-cursor controller behavior.\n */\nexport class KeplerGlobeView extends DeckGlobeView {\n  // Forward constructor props to deck.gl's GlobeView. Declared explicitly because\n  // the base class is loosely typed (see DeckGlobeView above), which would\n  // otherwise surface a parameterless constructor to callers.\n  constructor(props?: any) {\n    super(props);\n  }\n\n  get ControllerType() {\n    return ZoomToCursorGlobeController;\n  }\n\n  // deck.gl 9's GlobeView.getViewportType() swaps the viewport class based on zoom:\n  //   `return viewState.zoom > 12 ? WebMercatorViewport : GlobeViewport;`\n  // Crossing zoom 12 therefore recomputes tile bounds with completely different\n  // projection math (globe vs flat mercator). That makes deck's TileLayer/MVTLayer\n  // reselect tiles inconsistently across the boundary — mixed LODs (e.g. a z4 tile\n  // next to z11), a visible \"flicker\" at 12, and tiles that get dropped and stick\n  // as black/empty quads (most often crossing 12 on the way *out*).\n  //\n  // Force GlobeViewport at every zoom to eliminate the z=12 viewport swap so tile\n  // selection stays consistent. The trade-off is that zoom > 12 now uses float32\n  // globe precision (deck's documented \"no high-precision rendering > 12\" limit)\n  // instead of switching to mercator — far preferable to the black quads.\n  getViewportType() {\n    return DeckGlobeViewport;\n  }\n}\n\nKeplerGlobeView.displayName = 'KeplerGlobeView';\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/globe/index.js

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// Globe mode layer adjustments.
+//
+// Globe-specific adjustments handled here:
+// - Grid / Hexagon aggregation cells on the globe: deck.gl 9.x's GridCellLayer /
+//   HexagonCellLayer position cells in flat mercator common space and draw them with
+//   project_common_position_to_clipspace, which leaves them on the XY plane through the
+//   globe center rather than on its surface. ScaleEnhancedGridLayer /
+//   ScaleEnhancedHexagonLayer swap in a globe-aware cell subclass (see
+//   layer-utils/globe-cell-utils) that remaps each cell vertex from common space back to
+//   lng/lat and onto the sphere.
+// - Text/Label rendering with back-face culling: MVTLabelLayer renders place labels via a
+//   TextLayer whose glyph sublayer is EnhancedMultiIconLayer, which degenerates glyph
+//   vertices on the far side of the globe (dot(surfaceNormal, toCamera) < 0.1) so labels
+//   don't show through the planet. Implemented as a GLSL inject.
+
+export { AtmosphereLayerRealistic, AtmosphereSkyLayerRealistic, getGlobeAtmosphereLayer, getGlobeAtmosphereSkyLayer } from './atmosphere-layer';
+export { GlobeDepthDiskLayer, getGlobeDepthDiskLayer } from './globe-depth-disk-layer';
+export { getGlobeBaseLayers, getGlobeTopLayers, getGlobeClearColor, getGlobeBasemapAttributions, resolveGlobeBasemapProvider, DEFAULT_BASEMAP_COLOR, getBasemapColors, getBasemapColorsForStyle } from './globe-layers';
+export { MVTLabelLayer } from './mvt-label-layer';
+export { default as EnhancedMultiIconLayer } from './enhanced-multi-icon-layer';
+export { KeplerGlobeView } from './globe-view';
+export { getStarsBackgroundImage } from './globe-stars-layer';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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