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

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

@@ -0,0 +1,561 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { COORDINATE_SYSTEM } from '@deck.gl/core';
+import { SolidPolygonLayer, BitmapLayer } from '@deck.gl/layers';
+import { TileLayer, MVTLayer } from '@deck.gl/geo-layers';
+import { getGlobeAtmosphereLayer, getGlobeAtmosphereSkyLayer } from './atmosphere-layer';
+import { getGlobeDepthDiskLayer } from './globe-depth-disk-layer';
+import { MVTLabelLayer } from './mvt-label-layer';
+var devicePixelRatio = Math.min(2, typeof window !== 'undefined' && window.devicePixelRatio || 1);
+var BACKGROUND_PARAMETERS = {
+  depthTest: true,
+  cull: true,
+  depthMask: false
+};
+var BASEMAP_RASTER_PARAMETERS = {
+  depthMask: false
+};
+var BACKGROUND_DATA = [[[-180, 90], [0, 90], [180, 90], [180, -90], [0, -90], [-180, -90]]];
+var BACKGROUND_NORTH_POLE_DATA = [[[-180, 90], [0, 90], [180, 90], [180, 85], [0, 85], [-180, 85]]];
+export var DEFAULT_BASEMAP_COLOR = {
+  backgroundFillColor: [9, 16, 29],
+  basemapDefaultFillColor: [255, 255, 255],
+  basemapWaterFillColor: [17, 35, 48],
+  basemapDefaultLineColor: [40, 63, 93],
+  basemapAdminLineColor: [40, 63, 93],
+  basemapLabelColor: [114.75, 114.75, 114.75]
+};
+function getPaintColor(color) {
+  if (Array.isArray(color) && color[0] === 'interpolate') {
+    return color[4];
+  }
+  return color;
+}
+function colorStringToRGB(color) {
+  if (!color) return null;
+  if (typeof color !== 'string') return null;
+
+  // Handle hsl() format
+  var hslMatch = color.match(/hsl\(\s*(\d+)\s*,\s*(\d+)%\s*,\s*(\d+)%\s*\)/);
+  if (hslMatch) {
+    var h = parseInt(hslMatch[1], 10) / 360;
+    var s = parseInt(hslMatch[2], 10) / 100;
+    var l = parseInt(hslMatch[3], 10) / 100;
+    // HSL to RGB conversion
+    var r, g, b;
+    if (s === 0) {
+      r = g = b = l;
+    } else {
+      var hue2rgb = function hue2rgb(p, q, t) {
+        if (t < 0) t += 1;
+        if (t > 1) t -= 1;
+        if (t < 1 / 6) return p + (q - p) * 6 * t;
+        if (t < 1 / 2) return q;
+        if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+        return p;
+      };
+      var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+      var p = 2 * l - q;
+      r = hue2rgb(p, q, h + 1 / 3);
+      g = hue2rgb(p, q, h);
+      b = hue2rgb(p, q, h - 1 / 3);
+    }
+    return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
+  }
+
+  // Handle rgb() format
+  var rgbMatch = color.match(/rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/);
+  if (rgbMatch) {
+    return [parseInt(rgbMatch[1], 10), parseInt(rgbMatch[2], 10), parseInt(rgbMatch[3], 10)];
+  }
+
+  // Handle hex format
+  var hexMatch = color.match(/^#([0-9a-f]{6})$/i);
+  if (hexMatch) {
+    var hex = hexMatch[1];
+    return [parseInt(hex.slice(0, 2), 16), parseInt(hex.slice(2, 4), 16), parseInt(hex.slice(4, 6), 16)];
+  }
+  return null;
+}
+function findFirstLayerByGroup(layers, layerGroups, groupSlug) {
+  var layerGroup = layerGroups.find(function (group) {
+    return group.slug === groupSlug;
+  });
+  if (!layerGroup) return null;
+  return layers.find(function (layer) {
+    return layerGroup.filter(layer);
+  });
+}
+function findBackgroundColor(style) {
+  var _found;
+  var found = style.layers.find(function (l) {
+    return l.id === 'background' || l.id === 'land';
+  });
+  found = found || style.layers.find(function (l) {
+    return l.type === 'background';
+  });
+  return colorStringToRGB(getPaintColor((_found = found) === null || _found === void 0 || (_found = _found.paint) === null || _found === void 0 ? void 0 : _found['background-color']));
+}
+function findWaterColor(style, layerGroups) {
+  var _found$paint;
+  var found = style.layers.find(function (l) {
+    return l.id === 'water';
+  }) || findFirstLayerByGroup(style.layers, layerGroups, 'water');
+  return colorStringToRGB(found === null || found === void 0 || (_found$paint = found.paint) === null || _found$paint === void 0 ? void 0 : _found$paint['fill-color']);
+}
+function findAdminColor(style, layerGroups) {
+  var _borderLayers$paint;
+  var borderLayers = style.layers.find(function (lyr) {
+    return lyr.id === 'admin-3-4-boundaries';
+  }) || findFirstLayerByGroup(style.layers, layerGroups, 'border');
+  return colorStringToRGB(borderLayers === null || borderLayers === void 0 || (_borderLayers$paint = borderLayers.paint) === null || _borderLayers$paint === void 0 ? void 0 : _borderLayers$paint['line-color']);
+}
+function findLabelColor(style, layerGroups) {
+  var _labelLayer;
+  var labelLayer = style.layers.find(function (lyr) {
+    return lyr.id === 'country-label-lg' && lyr.type === 'symbol';
+  });
+  labelLayer = labelLayer || style.layers.find(function (lyr) {
+    return lyr.id === 'country-label' && lyr.type === 'symbol';
+  });
+  labelLayer = labelLayer || findFirstLayerByGroup(style.layers, layerGroups, 'label');
+  return colorStringToRGB((_labelLayer = labelLayer) === null || _labelLayer === void 0 || (_labelLayer = _labelLayer.paint) === null || _labelLayer === void 0 ? void 0 : _labelLayer['text-color']);
+}
+export var getBasemapColors = function getBasemapColors(mapStyle) {
+  var _findBackgroundColor, _findWaterColor, _findAdminColor, _findLabelColor;
+  var _mapStyle$style = mapStyle.style,
+    styleJson = _mapStyle$style === void 0 ? {
+      layers: []
+    } : _mapStyle$style,
+    _mapStyle$layerGroups = mapStyle.layerGroups,
+    layerGroups = _mapStyle$layerGroups === void 0 ? [] : _mapStyle$layerGroups;
+  return {
+    backgroundFillColor: (_findBackgroundColor = findBackgroundColor(styleJson)) !== null && _findBackgroundColor !== void 0 ? _findBackgroundColor : DEFAULT_BASEMAP_COLOR.backgroundFillColor,
+    basemapWaterFillColor: (_findWaterColor = findWaterColor(styleJson, layerGroups)) !== null && _findWaterColor !== void 0 ? _findWaterColor : DEFAULT_BASEMAP_COLOR.basemapWaterFillColor,
+    basemapAdminLineColor: (_findAdminColor = findAdminColor(styleJson, layerGroups)) !== null && _findAdminColor !== void 0 ? _findAdminColor : DEFAULT_BASEMAP_COLOR.basemapAdminLineColor,
+    basemapLabelColor: (_findLabelColor = findLabelColor(styleJson, layerGroups)) !== null && _findLabelColor !== void 0 ? _findLabelColor : DEFAULT_BASEMAP_COLOR.basemapLabelColor
+  };
+};
+
+// Predefined color schemes for well-known basemap styles
+var KNOWN_STYLE_COLORS = {
+  dark: {
+    backgroundFillColor: [15, 15, 15],
+    basemapWaterFillColor: [10, 20, 35],
+    basemapAdminLineColor: [60, 60, 80],
+    basemapLabelColor: [150, 150, 150]
+  },
+  'dark-matter': {
+    backgroundFillColor: [18, 18, 18],
+    basemapWaterFillColor: [14, 19, 29],
+    basemapAdminLineColor: [50, 50, 60],
+    basemapLabelColor: [130, 130, 130]
+  },
+  light: {
+    backgroundFillColor: [235, 233, 228],
+    basemapWaterFillColor: [170, 211, 223],
+    basemapAdminLineColor: [180, 175, 170],
+    basemapLabelColor: [80, 80, 80]
+  },
+  positron: {
+    backgroundFillColor: [242, 239, 233],
+    basemapWaterFillColor: [174, 209, 220],
+    basemapAdminLineColor: [190, 185, 180],
+    basemapLabelColor: [90, 90, 90]
+  },
+  voyager: {
+    backgroundFillColor: [234, 229, 220],
+    basemapWaterFillColor: [170, 211, 223],
+    basemapAdminLineColor: [180, 170, 160],
+    basemapLabelColor: [70, 70, 70]
+  },
+  muted: {
+    backgroundFillColor: [225, 225, 218],
+    basemapWaterFillColor: [180, 210, 220],
+    basemapAdminLineColor: [170, 165, 160],
+    basemapLabelColor: [90, 90, 90]
+  },
+  muted_night: {
+    backgroundFillColor: [22, 26, 30],
+    basemapWaterFillColor: [15, 25, 40],
+    basemapAdminLineColor: [55, 60, 70],
+    basemapLabelColor: [140, 140, 140]
+  }
+};
+
+/**
+ * Get basemap colors either from the style JSON or from known style presets.
+ * Falls back to default dark colors if style is unknown and no JSON is available.
+ */
+export var getBasemapColorsForStyle = function getBasemapColorsForStyle(styleType, mapStyle) {
+  var _mapStyle$style2;
+  // Try to extract from style JSON first
+  if (mapStyle !== null && mapStyle !== void 0 && (_mapStyle$style2 = mapStyle.style) !== null && _mapStyle$style2 !== void 0 && (_mapStyle$style2 = _mapStyle$style2.layers) !== null && _mapStyle$style2 !== void 0 && _mapStyle$style2.length) {
+    return getBasemapColors(mapStyle);
+  }
+  // Fall back to known style presets
+  if (KNOWN_STYLE_COLORS[styleType]) {
+    return KNOWN_STYLE_COLORS[styleType];
+  }
+  // Default dark colors
+  return {
+    backgroundFillColor: DEFAULT_BASEMAP_COLOR.backgroundFillColor,
+    basemapWaterFillColor: DEFAULT_BASEMAP_COLOR.basemapWaterFillColor,
+    basemapAdminLineColor: DEFAULT_BASEMAP_COLOR.basemapAdminLineColor,
+    basemapLabelColor: DEFAULT_BASEMAP_COLOR.basemapLabelColor
+  };
+};
+
+/**
+ * Clear color (background around the globe) for globe mode, in RGBA 0-255 as
+ * expected by deck.gl's View `clearColor` prop (deck.gl >= 9 no longer supports
+ * the global `parameters.clearColor`; it must be set per-view with `clear: true`).
+ */
+export function getGlobeClearColor(backgroundColor) {
+  if (backgroundColor) {
+    return [backgroundColor[0], backgroundColor[1], backgroundColor[2], 255];
+  }
+  // Default matches the previous hardcoded clear color [0.015, 0.035, 0.065] in 0-1 space.
+  return [4, 9, 17, 255];
+}
+var INVISIBLE_COLOR = [0, 0, 0, 0];
+var BASEMAP_MVT_PARAMETERS = {
+  // Occlude the far side of the globe via the DEPTH DISK (getGlobeDepthDiskLayer)
+  // rather than back-face culling. Globe mode sets a global `cull: true` for the
+  // opaque sphere surface, but back-face culling relies on stable triangle
+  // winding — and deck.gl 9's globe projection loses precision at high zoom
+  // (float32), flipping the winding of the small admin/water triangles so they
+  // get wrongly culled and the geometry vanishes past ~zoom 12 (you then see
+  // through to the far side / "different geometry"). Depth testing against the disk
+  // is a precision-robust occluder that works at any zoom, so:
+  //   - cull: false     → don't winding-cull the near-side geometry
+  //   - depthTest: true → far-side geometry (behind the disk) fails depth, hidden
+  //   - depthMask: false → don't write depth (avoid self z-fighting on the shell)
+  // Raster tiles are unaffected (their 4-corner quads keep stable winding), which
+  // is why satellite already zooms to max cleanly. Labels disable cull for the
+  // same reason (see mvt-label-layer.ts).
+  depthTest: true,
+  depthMask: false,
+  cull: false
+};
+
+// deck.gl 9's globe selects finer tiles than needed for a given view (its
+// GlobeViewport scale is ~3x smaller than the equivalent mercator zoom), so bias
+// vector tile selection coarser to keep the tile count — and thus performance —
+// in check. This trades a little detail for far fewer tiles; make it less negative
+// (toward 0) for sharper detail, or more negative for more perf.
+// These are *base* offsets: globeLatitudeZoomCompensation is added on top at draw
+// time, so the effective zoomOffset only equals these exact values at the equator.
+// Satellite raster uses base 0 — it doesn't need the vector bias (a coarser raster
+// tile just looks softer rather than dropping features).
+var MAPBOX_GLOBE_VECTOR_ZOOM_OFFSET = -2;
+var CARTO_GLOBE_VECTOR_ZOOM_OFFSET = -2;
+var GLOBE_SATELLITE_ZOOM_OFFSET = 0;
+
+// Whole-world tile extent (Web Mercator latitude limit). Required whenever a
+// negative `zoomOffset` is used: deck's `getTileIndices` returns NO tiles when
+// the target zoom drops below `minZoom` *unless* an `extent` is set (in which
+// case it clamps to `minZoom` instead). Without this, zooming out or panning
+// toward the poles (where deck 9's globe controller lowers the effective zoom)
+// makes the whole globe basemap disappear.
+var GLOBE_TILE_EXTENT = [-180, -85.051129, 180, 85.051129];
+
+// Max *native* zoom of each vector tile source. Set this (not an arbitrarily
+// high number) so deck overzooms — i.e. keeps rendering the deepest real tile
+// when the view zooms past it — instead of requesting tiles that don't exist
+// and 404 (which shows up as empty rectangles). The raw `.vector.pbf` /`.mvt`
+// endpoints do NOT auto-overzoom the way Mapbox GL does.
+//   - mapbox-streets-v8 has data up to z16
+//   - CARTO carto.streets v1 has data up to z14
+var MAPBOX_VECTOR_MAX_DATA_ZOOM = 16;
+var CARTO_VECTOR_MAX_DATA_ZOOM = 14;
+
+/**
+ * deck.gl 9's globe couples zoom to latitude via `zoomAdjust` (see
+ * globe-viewport.js): `scale = 2^(zoom - zoomAdjust(lat))`, and its controller
+ * *lowers* the stored `zoom` as you pan toward the poles to keep the globe's
+ * on-screen size constant. Tile LOD, however, is selected from the raw `zoom`,
+ * so rotating toward a pole silently drops the LOD and thins out labels.
+ * Replicated from `@deck.gl/core` globe-viewport.js `zoomAdjust`.
+ */
+function zoomAdjust(latitude) {
+  return Math.log2(Math.PI * Math.cos(latitude * Math.PI / 180));
+}
+
+/**
+ * Latitude compensation to add to a globe tile layer's `zoomOffset`, so tile LOD
+ * tracks the *visual* (on-screen) scale instead of the latitude-adjusted mercator
+ * zoom. This cancels the pan-induced zoom drop, keeping tile detail/labels
+ * constant while rotating toward the poles.
+ */
+function globeLatitudeZoomCompensation(latitude) {
+  if (latitude == null || !Number.isFinite(latitude)) {
+    return 0;
+  }
+  // Clamp away from the poles to avoid log2(0) = -Infinity at |lat| = 90.
+  var clamped = Math.max(-85, Math.min(85, latitude));
+  return zoomAdjust(0) - zoomAdjust(clamped);
+}
+
+/**
+ * Globe basemap tile provider.
+ *
+ * - `mapbox` uses Mapbox vector/raster tiles and requires an access token.
+ * - `carto` uses CARTO's free OpenMapTiles vector tiles + Esri World Imagery
+ *   raster, and needs no token. Used as an automatic fallback when no Mapbox
+ *   token is available (e.g. MapLibre / CARTO basemap setups), so the globe
+ *   basemap still renders instead of showing a solid-color sphere.
+ */
+
+/**
+ * Resolve which globe basemap tile provider to use.
+ *
+ * The globe should follow the *selected basemap style's* rendering library so
+ * it stays consistent with the flat 2D map: a MapLibre/CARTO style uses the
+ * free CARTO tiles (even when a Mapbox token is available), and a Mapbox style
+ * uses Mapbox tiles. A Mapbox style with no token falls back to CARTO so the
+ * globe still renders instead of showing a bare colored sphere.
+ *
+ * @param baseMapLibrary the selected style's library ('mapbox' | 'maplibre'),
+ *   e.g. from `getBaseMapLibrary(currentStyle)`.
+ */
+export var resolveGlobeBasemapProvider = function resolveGlobeBasemapProvider(baseMapLibrary, mapboxApiAccessToken) {
+  if (baseMapLibrary === 'maplibre') {
+    return 'carto';
+  }
+  if (baseMapLibrary === 'mapbox') {
+    return mapboxApiAccessToken ? 'mapbox' : 'carto';
+  }
+  // Unknown library: prefer Mapbox when a token exists, otherwise CARTO.
+  return mapboxApiAccessToken ? 'mapbox' : 'carto';
+};
+
+// CARTO free vector tiles (OpenMapTiles schema, no API key required).
+var CARTO_VECTOR_TILE_URLS = ['https://tiles-a.basemaps.cartocdn.com/vectortiles/carto.streets/v1/{z}/{x}/{y}.mvt', 'https://tiles-b.basemaps.cartocdn.com/vectortiles/carto.streets/v1/{z}/{x}/{y}.mvt', 'https://tiles-c.basemaps.cartocdn.com/vectortiles/carto.streets/v1/{z}/{x}/{y}.mvt', 'https://tiles-d.basemaps.cartocdn.com/vectortiles/carto.streets/v1/{z}/{x}/{y}.mvt'];
+
+// Free satellite raster fallback (Esri World Imagery, no API key required).
+var ESRI_WORLD_IMAGERY_URL = 'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}';
+
+/**
+ * Maps a raw MVT source-layer name to a normalized semantic layer kind, so the
+ * fill/line/label accessors work across both the Mapbox (`mapbox-streets-v8`)
+ * and CARTO/OpenMapTiles schemas.
+ *
+ * | semantic | mapbox        | openmaptiles |
+ * | -------- | ------------- | ------------ |
+ * | water    | `water`       | `water`      |
+ * | admin    | `admin`       | `boundary`   |
+ * | label    | `place_label` | `place`      |
+ */
+
+function getBasemapLayerKind(layerName) {
+  switch (layerName) {
+    case 'water':
+      return 'water';
+    case 'admin':
+    case 'boundary':
+      return 'admin';
+    case 'place_label':
+    case 'place':
+      return 'label';
+    default:
+      return 'other';
+  }
+}
+var MAPBOX_ATTRIBUTION = {
+  label: '© Mapbox',
+  href: 'https://www.mapbox.com/about/maps/'
+};
+var OSM_ATTRIBUTION = {
+  label: '© OpenStreetMap',
+  href: 'https://www.openstreetmap.org/copyright'
+};
+var CARTO_ATTRIBUTION = {
+  label: '© CARTO',
+  href: 'https://carto.com/attributions'
+};
+var ESRI_ATTRIBUTION = {
+  label: 'Powered by Esri',
+  href: 'https://www.esri.com/'
+};
+
+/**
+ * Resolve the tile-source attribution entries for the globe basemap. deck.gl
+ * renders the globe basemap tiles itself (not the base Maplibre/Mapbox map), so
+ * the base map's attribution machinery never sees them. This lets the UI credit
+ * the actual tile provider(s) in globe mode.
+ */
+export var getGlobeBasemapAttributions = function getGlobeBasemapAttributions(_ref) {
+  var _globe$config;
+  var globe = _ref.globe,
+    mapboxApiAccessToken = _ref.mapboxApiAccessToken,
+    mapStyleType = _ref.mapStyleType,
+    basemapProvider = _ref.basemapProvider;
+  if (!(globe !== null && globe !== void 0 && globe.enabled) || !((_globe$config = globe.config) !== null && _globe$config !== void 0 && _globe$config.basemap)) {
+    return [];
+  }
+  var provider = basemapProvider !== null && basemapProvider !== void 0 ? basemapProvider : resolveGlobeBasemapProvider(undefined, mapboxApiAccessToken);
+  if (provider === 'mapbox') {
+    return mapboxApiAccessToken ? [MAPBOX_ATTRIBUTION, OSM_ATTRIBUTION] : [];
+  }
+  var isSatellite = mapStyleType === 'satellite' || mapStyleType === 'satellite-street';
+  // CARTO vector tiles are OpenStreetMap-derived; Esri imagery is credited separately.
+  return isSatellite ? [ESRI_ATTRIBUTION, CARTO_ATTRIBUTION, OSM_ATTRIBUTION] : [CARTO_ATTRIBUTION, OSM_ATTRIBUTION];
+};
+
+// eslint-disable-next-line complexity
+export var getGlobeBaseLayers = function getGlobeBaseLayers(_ref2) {
+  var mapboxApiAccessToken = _ref2.mapboxApiAccessToken,
+    globe = _ref2.globe,
+    mapStyleType = _ref2.mapStyleType,
+    basemapProvider = _ref2.basemapProvider,
+    latitude = _ref2.latitude,
+    zoom = _ref2.zoom;
+  var config = globe.config;
+  var isSatellite = mapStyleType === 'satellite';
+  var isSatelliteStreet = mapStyleType === 'satellite-street';
+  var latZoomCompensation = globeLatitudeZoomCompensation(latitude);
+
+  // Fall back to the free CARTO tiles whenever no Mapbox token is available so
+  // the globe basemap still renders (matches kepler's default token-free
+  // MapLibre/CARTO basemaps). Callers should pass an explicit `basemapProvider`
+  // (derived from the selected style) so the globe follows the 2D basemap.
+  var provider = basemapProvider !== null && basemapProvider !== void 0 ? basemapProvider : resolveGlobeBasemapProvider(undefined, mapboxApiAccessToken);
+  var useCarto = provider === 'carto';
+  var hasTileAccess = useCarto || Boolean(mapboxApiAccessToken);
+  return [config.atmosphere ? getGlobeAtmosphereSkyLayer({
+    config: config,
+    zoom: zoom
+  }) : null,
+  // Depth-only cross-section disk: writes depth at the globe's silhouette so
+  // far-side geometry (arcs/lines) is occluded by the planet.
+  getGlobeDepthDiskLayer({
+    fillColor: config.surfaceColor
+  }),
+  // Background surface polygon
+  (!config.basemap || !isSatellite && !isSatelliteStreet) && new SolidPolygonLayer({
+    id: 'globe-background',
+    data: BACKGROUND_DATA,
+    getPolygon: function (d) {
+      return d;
+    },
+    filled: true,
+    getFillColor: config.surfaceColor,
+    parameters: BACKGROUND_PARAMETERS
+  }),
+  // Fill hole at north pole
+  config.basemap && new SolidPolygonLayer({
+    id: 'globe-background-north-pole',
+    data: BACKGROUND_NORTH_POLE_DATA,
+    getPolygon: function (d) {
+      return d;
+    },
+    filled: true,
+    getFillColor: config.water ? config.waterColor : config.surfaceColor,
+    parameters: BACKGROUND_PARAMETERS
+  }),
+  // Satellite tiles
+  config.basemap && (isSatellite || isSatelliteStreet) && hasTileAccess && new TileLayer({
+    id: "globe-satellite-tiles-".concat(provider),
+    data: useCarto ? [ESRI_WORLD_IMAGERY_URL] : ["https://api.mapbox.com/v4/mapbox.satellite/{z}/{x}/{y}@2x.png?access_token=".concat(mapboxApiAccessToken)],
+    minZoom: 0,
+    maxZoom: useCarto ? 18 : 19,
+    zoomOffset: GLOBE_SATELLITE_ZOOM_OFFSET + latZoomCompensation,
+    extent: GLOBE_TILE_EXTENT,
+    // Esri tiles are 256px; Mapbox @2x tiles are 512px.
+    tileSize: useCarto ? 256 : 512 / devicePixelRatio,
+    renderSubLayers: function renderSubLayers(props) {
+      var _props$tile$bbox = props.tile.bbox,
+        west = _props$tile$bbox.west,
+        south = _props$tile$bbox.south,
+        east = _props$tile$bbox.east,
+        north = _props$tile$bbox.north;
+      return [new BitmapLayer(props, {
+        _imageCoordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
+        data: undefined,
+        image: props.data,
+        bounds: [west, south, east, north]
+      })];
+    },
+    parameters: BASEMAP_RASTER_PARAMETERS
+  }),
+  // Vector basemap (MVT labels/admin/water)
+  config.basemap && !isSatellite && hasTileAccess && new MVTLayer({
+    // force the layer to update when the style/label/provider config changes
+    id: "globe-basemap-mvt-layer-".concat(provider, "-").concat(mapStyleType),
+    data: useCarto ? CARTO_VECTOR_TILE_URLS : "https://a.tiles.mapbox.com/v4/mapbox.mapbox-streets-v8/{z}/{x}/{y}.vector.pbf?access_token=".concat(mapboxApiAccessToken),
+    minZoom: 0,
+    // Overzoom past the source's native max instead of 404-ing on tiles that
+    // don't exist (which renders as empty rectangles at high zoom).
+    maxZoom: useCarto ? CARTO_VECTOR_MAX_DATA_ZOOM : MAPBOX_VECTOR_MAX_DATA_ZOOM,
+    zoomOffset: (useCarto ? CARTO_GLOBE_VECTOR_ZOOM_OFFSET : MAPBOX_GLOBE_VECTOR_ZOOM_OFFSET) + latZoomCompensation,
+    extent: GLOBE_TILE_EXTENT,
+    binary: false,
+    parameters: BASEMAP_MVT_PARAMETERS,
+    loadOptions: useCarto ? {
+      // OpenMapTiles schema: `boundary` = admin lines, `place` = labels.
+      mvt: {
+        layers: isSatelliteStreet ? ['place', 'boundary'] : ['place', 'boundary', 'water', 'transportation']
+      }
+    } : {
+      mvt: {
+        layers: isSatelliteStreet ? ['place_label', 'admin'] : ['place_label', 'admin', 'water', 'road']
+      }
+    },
+    // Render admin/water via GeoJsonLayer and place labels via TextLayer.
+    config: config,
+    renderSubLayers: function renderSubLayers(props) {
+      return new MVTLabelLayer(props);
+    },
+    getFillColor: function getFillColor(f) {
+      switch (getBasemapLayerKind(f.properties.layerName)) {
+        case 'water':
+          return config.water ? config.waterColor : INVISIBLE_COLOR;
+        default:
+          return config.surfaceColor;
+      }
+    },
+    getLineColor: function getLineColor(f) {
+      switch (getBasemapLayerKind(f.properties.layerName)) {
+        case 'admin':
+          return config.adminLines ? config.adminLinesColor : INVISIBLE_COLOR;
+        default:
+          return config.surfaceColor;
+      }
+    },
+    getLineWidth: function getLineWidth(f) {
+      switch (getBasemapLayerKind(f.properties.layerName)) {
+        case 'admin':
+          switch (f.properties.admin_level) {
+            case 0:
+            case 2:
+              return 1;
+            default:
+              return 0.75;
+          }
+        default:
+          return 0;
+      }
+    },
+    updateTriggers: {
+      getFillColor: [config.waterColor, config.surfaceColor, config.water],
+      getLineColor: [config.adminLinesColor, config.surfaceColor, config.adminLines]
+    },
+    lineWidthUnits: 'pixels',
+    lineWidthMinPixels: 0,
+    lineWidthMaxPixels: 20,
+    getPointRadius: 0,
+    pointRadiusMinPixels: 0
+  })].filter(Boolean);
+};
+export var getGlobeTopLayers = function getGlobeTopLayers(_ref3) {
+  var globe = _ref3.globe,
+    zoom = _ref3.zoom;
+  var config = globe.config;
+  return [config.atmosphere ? getGlobeAtmosphereLayer({
+    config: config,
+    zoom: zoom
+  }) : null].filter(Boolean);
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["COORDINATE_SYSTEM","SolidPolygonLayer","BitmapLayer","TileLayer","MVTLayer","getGlobeAtmosphereLayer","getGlobeAtmosphereSkyLayer","getGlobeDepthDiskLayer","MVTLabelLayer","devicePixelRatio","Math","min","window","BACKGROUND_PARAMETERS","depthTest","cull","depthMask","BASEMAP_RASTER_PARAMETERS","BACKGROUND_DATA","BACKGROUND_NORTH_POLE_DATA","DEFAULT_BASEMAP_COLOR","backgroundFillColor","basemapDefaultFillColor","basemapWaterFillColor","basemapDefaultLineColor","basemapAdminLineColor","basemapLabelColor","getPaintColor","color","Array","isArray","colorStringToRGB","hslMatch","match","h","parseInt","s","l","r","g","b","hue2rgb","p","q","t","round","rgbMatch","hexMatch","hex","slice","findFirstLayerByGroup","layers","layerGroups","groupSlug","layerGroup","find","group","slug","layer","filter","findBackgroundColor","style","_found","found","id","type","paint","findWaterColor","_found$paint","findAdminColor","_borderLayers$paint","borderLayers","lyr","findLabelColor","_labelLayer","labelLayer","getBasemapColors","mapStyle","_findBackgroundColor","_findWaterColor","_findAdminColor","_findLabelColor","_mapStyle$style","styleJson","_mapStyle$layerGroups","KNOWN_STYLE_COLORS","dark","light","positron","voyager","muted","muted_night","getBasemapColorsForStyle","styleType","_mapStyle$style2","length","getGlobeClearColor","backgroundColor","INVISIBLE_COLOR","BASEMAP_MVT_PARAMETERS","MAPBOX_GLOBE_VECTOR_ZOOM_OFFSET","CARTO_GLOBE_VECTOR_ZOOM_OFFSET","GLOBE_SATELLITE_ZOOM_OFFSET","GLOBE_TILE_EXTENT","MAPBOX_VECTOR_MAX_DATA_ZOOM","CARTO_VECTOR_MAX_DATA_ZOOM","zoomAdjust","latitude","log2","PI","cos","globeLatitudeZoomCompensation","Number","isFinite","clamped","max","resolveGlobeBasemapProvider","baseMapLibrary","mapboxApiAccessToken","CARTO_VECTOR_TILE_URLS","ESRI_WORLD_IMAGERY_URL","getBasemapLayerKind","layerName","MAPBOX_ATTRIBUTION","label","href","OSM_ATTRIBUTION","CARTO_ATTRIBUTION","ESRI_ATTRIBUTION","getGlobeBasemapAttributions","_ref","_globe$config","globe","mapStyleType","basemapProvider","enabled","config","basemap","provider","undefined","isSatellite","getGlobeBaseLayers","_ref2","zoom","isSatelliteStreet","latZoomCompensation","useCarto","hasTileAccess","Boolean","atmosphere","fillColor","surfaceColor","data","getPolygon","d","filled","getFillColor","parameters","water","waterColor","concat","minZoom","maxZoom","zoomOffset","extent","tileSize","renderSubLayers","props","_props$tile$bbox","tile","bbox","west","south","east","north","_imageCoordinateSystem","CARTESIAN","image","bounds","binary","loadOptions","mvt","f","properties","getLineColor","adminLines","adminLinesColor","getLineWidth","admin_level","updateTriggers","lineWidthUnits","lineWidthMinPixels","lineWidthMaxPixels","getPointRadius","pointRadiusMinPixels","getGlobeTopLayers","_ref3"],"sources":["../../../src/globe/globe-layers.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {COORDINATE_SYSTEM, Layer} from '@deck.gl/core';\nimport {SolidPolygonLayer, BitmapLayer} from '@deck.gl/layers';\nimport {TileLayer, MVTLayer} from '@deck.gl/geo-layers';\n\nimport type {Globe} from '@kepler.gl/constants';\nimport type {RGBColor} from '@kepler.gl/types';\n\nimport {getGlobeAtmosphereLayer, getGlobeAtmosphereSkyLayer} from './atmosphere-layer';\nimport {getGlobeDepthDiskLayer} from './globe-depth-disk-layer';\nimport {MVTLabelLayer} from './mvt-label-layer';\n\ntype LayerGroup = {slug: string; filter: (layer: any) => boolean};\n\nconst devicePixelRatio = Math.min(\n  2,\n  (typeof window !== 'undefined' && window.devicePixelRatio) || 1\n);\n\nconst BACKGROUND_PARAMETERS = {\n  depthTest: true,\n  cull: true,\n  depthMask: false\n};\n\nconst BASEMAP_RASTER_PARAMETERS = {\n  depthMask: false\n};\n\nconst BACKGROUND_DATA = [\n  [\n    [-180, 90],\n    [0, 90],\n    [180, 90],\n    [180, -90],\n    [0, -90],\n    [-180, -90]\n  ]\n];\n\nconst BACKGROUND_NORTH_POLE_DATA = [\n  [\n    [-180, 90],\n    [0, 90],\n    [180, 90],\n    [180, 85],\n    [0, 85],\n    [-180, 85]\n  ]\n];\n\nexport const DEFAULT_BASEMAP_COLOR = {\n  backgroundFillColor: [9, 16, 29] as RGBColor,\n  basemapDefaultFillColor: [255, 255, 255] as RGBColor,\n  basemapWaterFillColor: [17, 35, 48] as RGBColor,\n  basemapDefaultLineColor: [40, 63, 93] as RGBColor,\n  basemapAdminLineColor: [40, 63, 93] as RGBColor,\n  basemapLabelColor: [114.75, 114.75, 114.75] as RGBColor\n};\n\nfunction getPaintColor(color: any): string | null {\n  if (Array.isArray(color) && color[0] === 'interpolate') {\n    return color[4];\n  }\n  return color;\n}\n\nfunction colorStringToRGB(color: string | null): RGBColor | null {\n  if (!color) return null;\n  if (typeof color !== 'string') return null;\n\n  // Handle hsl() format\n  const hslMatch = color.match(/hsl\\(\\s*(\\d+)\\s*,\\s*(\\d+)%\\s*,\\s*(\\d+)%\\s*\\)/);\n  if (hslMatch) {\n    const h = parseInt(hslMatch[1], 10) / 360;\n    const s = parseInt(hslMatch[2], 10) / 100;\n    const l = parseInt(hslMatch[3], 10) / 100;\n    // HSL to RGB conversion\n    let r: number, g: number, b: number;\n    if (s === 0) {\n      r = g = b = l;\n    } else {\n      const hue2rgb = (p: number, q: number, t: number) => {\n        if (t < 0) t += 1;\n        if (t > 1) t -= 1;\n        if (t < 1 / 6) return p + (q - p) * 6 * t;\n        if (t < 1 / 2) return q;\n        if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;\n        return p;\n      };\n      const q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n      const p = 2 * l - q;\n      r = hue2rgb(p, q, h + 1 / 3);\n      g = hue2rgb(p, q, h);\n      b = hue2rgb(p, q, h - 1 / 3);\n    }\n    return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)] as RGBColor;\n  }\n\n  // Handle rgb() format\n  const rgbMatch = color.match(/rgb\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)\\s*\\)/);\n  if (rgbMatch) {\n    return [\n      parseInt(rgbMatch[1], 10),\n      parseInt(rgbMatch[2], 10),\n      parseInt(rgbMatch[3], 10)\n    ] as RGBColor;\n  }\n\n  // Handle hex format\n  const hexMatch = color.match(/^#([0-9a-f]{6})$/i);\n  if (hexMatch) {\n    const hex = hexMatch[1];\n    return [\n      parseInt(hex.slice(0, 2), 16),\n      parseInt(hex.slice(2, 4), 16),\n      parseInt(hex.slice(4, 6), 16)\n    ] as RGBColor;\n  }\n\n  return null;\n}\n\nfunction findFirstLayerByGroup(layers: any[], layerGroups: LayerGroup[], groupSlug: string) {\n  const layerGroup = layerGroups.find(group => group.slug === groupSlug);\n  if (!layerGroup) return null;\n  return layers.find(layer => layerGroup.filter(layer));\n}\n\nfunction findBackgroundColor(style: any): RGBColor | null {\n  let found = style.layers.find((l: any) => l.id === 'background' || l.id === 'land');\n  found = found || style.layers.find((l: any) => l.type === 'background');\n  return colorStringToRGB(getPaintColor(found?.paint?.['background-color']));\n}\n\nfunction findWaterColor(style: any, layerGroups: LayerGroup[]): RGBColor | null {\n  const found =\n    style.layers.find((l: any) => l.id === 'water') ||\n    findFirstLayerByGroup(style.layers, layerGroups, 'water');\n  return colorStringToRGB(found?.paint?.['fill-color']);\n}\n\nfunction findAdminColor(style: any, layerGroups: LayerGroup[]): RGBColor | null {\n  const borderLayers =\n    style.layers.find((lyr: any) => lyr.id === 'admin-3-4-boundaries') ||\n    findFirstLayerByGroup(style.layers, layerGroups, 'border');\n  return colorStringToRGB(borderLayers?.paint?.['line-color']);\n}\n\nfunction findLabelColor(style: any, layerGroups: LayerGroup[]): RGBColor | null {\n  let labelLayer = style.layers.find(\n    (lyr: any) => lyr.id === 'country-label-lg' && lyr.type === 'symbol'\n  );\n  labelLayer =\n    labelLayer ||\n    style.layers.find((lyr: any) => lyr.id === 'country-label' && lyr.type === 'symbol');\n  labelLayer = labelLayer || findFirstLayerByGroup(style.layers, layerGroups, 'label');\n  return colorStringToRGB(labelLayer?.paint?.['text-color']);\n}\n\nexport const getBasemapColors = (\n  mapStyle: Partial<{style: any; layerGroups: LayerGroup[]}>\n): {\n  backgroundFillColor: RGBColor;\n  basemapWaterFillColor: RGBColor;\n  basemapAdminLineColor: RGBColor;\n  basemapLabelColor: RGBColor;\n} => {\n  const {style: styleJson = {layers: []}, layerGroups = []} = mapStyle;\n\n  return {\n    backgroundFillColor:\n      findBackgroundColor(styleJson) ?? DEFAULT_BASEMAP_COLOR.backgroundFillColor,\n    basemapWaterFillColor:\n      findWaterColor(styleJson, layerGroups) ?? DEFAULT_BASEMAP_COLOR.basemapWaterFillColor,\n    basemapAdminLineColor:\n      findAdminColor(styleJson, layerGroups) ?? DEFAULT_BASEMAP_COLOR.basemapAdminLineColor,\n    basemapLabelColor:\n      findLabelColor(styleJson, layerGroups) ?? DEFAULT_BASEMAP_COLOR.basemapLabelColor\n  };\n};\n\n// Predefined color schemes for well-known basemap styles\nconst KNOWN_STYLE_COLORS: Record<\n  string,\n  {\n    backgroundFillColor: RGBColor;\n    basemapWaterFillColor: RGBColor;\n    basemapAdminLineColor: RGBColor;\n    basemapLabelColor: RGBColor;\n  }\n> = {\n  dark: {\n    backgroundFillColor: [15, 15, 15],\n    basemapWaterFillColor: [10, 20, 35],\n    basemapAdminLineColor: [60, 60, 80],\n    basemapLabelColor: [150, 150, 150]\n  },\n  'dark-matter': {\n    backgroundFillColor: [18, 18, 18],\n    basemapWaterFillColor: [14, 19, 29],\n    basemapAdminLineColor: [50, 50, 60],\n    basemapLabelColor: [130, 130, 130]\n  },\n  light: {\n    backgroundFillColor: [235, 233, 228],\n    basemapWaterFillColor: [170, 211, 223],\n    basemapAdminLineColor: [180, 175, 170],\n    basemapLabelColor: [80, 80, 80]\n  },\n  positron: {\n    backgroundFillColor: [242, 239, 233],\n    basemapWaterFillColor: [174, 209, 220],\n    basemapAdminLineColor: [190, 185, 180],\n    basemapLabelColor: [90, 90, 90]\n  },\n  voyager: {\n    backgroundFillColor: [234, 229, 220],\n    basemapWaterFillColor: [170, 211, 223],\n    basemapAdminLineColor: [180, 170, 160],\n    basemapLabelColor: [70, 70, 70]\n  },\n  muted: {\n    backgroundFillColor: [225, 225, 218],\n    basemapWaterFillColor: [180, 210, 220],\n    basemapAdminLineColor: [170, 165, 160],\n    basemapLabelColor: [90, 90, 90]\n  },\n  muted_night: {\n    backgroundFillColor: [22, 26, 30],\n    basemapWaterFillColor: [15, 25, 40],\n    basemapAdminLineColor: [55, 60, 70],\n    basemapLabelColor: [140, 140, 140]\n  }\n};\n\n/**\n * Get basemap colors either from the style JSON or from known style presets.\n * Falls back to default dark colors if style is unknown and no JSON is available.\n */\nexport const getBasemapColorsForStyle = (\n  styleType: string,\n  mapStyle?: Partial<{style: any; layerGroups: LayerGroup[]}>\n): {\n  backgroundFillColor: RGBColor;\n  basemapWaterFillColor: RGBColor;\n  basemapAdminLineColor: RGBColor;\n  basemapLabelColor: RGBColor;\n} => {\n  // Try to extract from style JSON first\n  if (mapStyle?.style?.layers?.length) {\n    return getBasemapColors(mapStyle);\n  }\n  // Fall back to known style presets\n  if (KNOWN_STYLE_COLORS[styleType]) {\n    return KNOWN_STYLE_COLORS[styleType];\n  }\n  // Default dark colors\n  return {\n    backgroundFillColor: DEFAULT_BASEMAP_COLOR.backgroundFillColor,\n    basemapWaterFillColor: DEFAULT_BASEMAP_COLOR.basemapWaterFillColor,\n    basemapAdminLineColor: DEFAULT_BASEMAP_COLOR.basemapAdminLineColor,\n    basemapLabelColor: DEFAULT_BASEMAP_COLOR.basemapLabelColor\n  };\n};\n\n/**\n * Clear color (background around the globe) for globe mode, in RGBA 0-255 as\n * expected by deck.gl's View `clearColor` prop (deck.gl >= 9 no longer supports\n * the global `parameters.clearColor`; it must be set per-view with `clear: true`).\n */\nexport function getGlobeClearColor(\n  backgroundColor?: [number, number, number] | number[]\n): [number, number, number, number] {\n  if (backgroundColor) {\n    return [backgroundColor[0], backgroundColor[1], backgroundColor[2], 255];\n  }\n  // Default matches the previous hardcoded clear color [0.015, 0.035, 0.065] in 0-1 space.\n  return [4, 9, 17, 255];\n}\n\nconst INVISIBLE_COLOR: [number, number, number, number] = [0, 0, 0, 0];\n\nconst BASEMAP_MVT_PARAMETERS = {\n  // Occlude the far side of the globe via the DEPTH DISK (getGlobeDepthDiskLayer)\n  // rather than back-face culling. Globe mode sets a global `cull: true` for the\n  // opaque sphere surface, but back-face culling relies on stable triangle\n  // winding — and deck.gl 9's globe projection loses precision at high zoom\n  // (float32), flipping the winding of the small admin/water triangles so they\n  // get wrongly culled and the geometry vanishes past ~zoom 12 (you then see\n  // through to the far side / \"different geometry\"). Depth testing against the disk\n  // is a precision-robust occluder that works at any zoom, so:\n  //   - cull: false     → don't winding-cull the near-side geometry\n  //   - depthTest: true → far-side geometry (behind the disk) fails depth, hidden\n  //   - depthMask: false → don't write depth (avoid self z-fighting on the shell)\n  // Raster tiles are unaffected (their 4-corner quads keep stable winding), which\n  // is why satellite already zooms to max cleanly. Labels disable cull for the\n  // same reason (see mvt-label-layer.ts).\n  depthTest: true,\n  depthMask: false,\n  cull: false\n};\n\n// deck.gl 9's globe selects finer tiles than needed for a given view (its\n// GlobeViewport scale is ~3x smaller than the equivalent mercator zoom), so bias\n// vector tile selection coarser to keep the tile count — and thus performance —\n// in check. This trades a little detail for far fewer tiles; make it less negative\n// (toward 0) for sharper detail, or more negative for more perf.\n// These are *base* offsets: globeLatitudeZoomCompensation is added on top at draw\n// time, so the effective zoomOffset only equals these exact values at the equator.\n// Satellite raster uses base 0 — it doesn't need the vector bias (a coarser raster\n// tile just looks softer rather than dropping features).\nconst MAPBOX_GLOBE_VECTOR_ZOOM_OFFSET = -2;\nconst CARTO_GLOBE_VECTOR_ZOOM_OFFSET = -2;\nconst GLOBE_SATELLITE_ZOOM_OFFSET = 0;\n\n// Whole-world tile extent (Web Mercator latitude limit). Required whenever a\n// negative `zoomOffset` is used: deck's `getTileIndices` returns NO tiles when\n// the target zoom drops below `minZoom` *unless* an `extent` is set (in which\n// case it clamps to `minZoom` instead). Without this, zooming out or panning\n// toward the poles (where deck 9's globe controller lowers the effective zoom)\n// makes the whole globe basemap disappear.\nconst GLOBE_TILE_EXTENT: [number, number, number, number] = [\n  -180, -85.051129, 180, 85.051129\n];\n\n// Max *native* zoom of each vector tile source. Set this (not an arbitrarily\n// high number) so deck overzooms — i.e. keeps rendering the deepest real tile\n// when the view zooms past it — instead of requesting tiles that don't exist\n// and 404 (which shows up as empty rectangles). The raw `.vector.pbf` /`.mvt`\n// endpoints do NOT auto-overzoom the way Mapbox GL does.\n//   - mapbox-streets-v8 has data up to z16\n//   - CARTO carto.streets v1 has data up to z14\nconst MAPBOX_VECTOR_MAX_DATA_ZOOM = 16;\nconst CARTO_VECTOR_MAX_DATA_ZOOM = 14;\n\n/**\n * deck.gl 9's globe couples zoom to latitude via `zoomAdjust` (see\n * globe-viewport.js): `scale = 2^(zoom - zoomAdjust(lat))`, and its controller\n * *lowers* the stored `zoom` as you pan toward the poles to keep the globe's\n * on-screen size constant. Tile LOD, however, is selected from the raw `zoom`,\n * so rotating toward a pole silently drops the LOD and thins out labels.\n * Replicated from `@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 * Latitude compensation to add to a globe tile layer's `zoomOffset`, so tile LOD\n * tracks the *visual* (on-screen) scale instead of the latitude-adjusted mercator\n * zoom. This cancels the pan-induced zoom drop, keeping tile detail/labels\n * constant while rotating toward the poles.\n */\nfunction globeLatitudeZoomCompensation(latitude?: number): number {\n  if (latitude == null || !Number.isFinite(latitude)) {\n    return 0;\n  }\n  // Clamp away from the poles to avoid log2(0) = -Infinity at |lat| = 90.\n  const clamped = Math.max(-85, Math.min(85, latitude));\n  return zoomAdjust(0) - zoomAdjust(clamped);\n}\n\n/**\n * Globe basemap tile provider.\n *\n * - `mapbox` uses Mapbox vector/raster tiles and requires an access token.\n * - `carto` uses CARTO's free OpenMapTiles vector tiles + Esri World Imagery\n *   raster, and needs no token. Used as an automatic fallback when no Mapbox\n *   token is available (e.g. MapLibre / CARTO basemap setups), so the globe\n *   basemap still renders instead of showing a solid-color sphere.\n */\nexport type GlobeBasemapProvider = 'mapbox' | 'carto';\n\n/**\n * Resolve which globe basemap tile provider to use.\n *\n * The globe should follow the *selected basemap style's* rendering library so\n * it stays consistent with the flat 2D map: a MapLibre/CARTO style uses the\n * free CARTO tiles (even when a Mapbox token is available), and a Mapbox style\n * uses Mapbox tiles. A Mapbox style with no token falls back to CARTO so the\n * globe still renders instead of showing a bare colored sphere.\n *\n * @param baseMapLibrary the selected style's library ('mapbox' | 'maplibre'),\n *   e.g. from `getBaseMapLibrary(currentStyle)`.\n */\nexport const resolveGlobeBasemapProvider = (\n  baseMapLibrary: 'mapbox' | 'maplibre' | undefined,\n  mapboxApiAccessToken?: string\n): GlobeBasemapProvider => {\n  if (baseMapLibrary === 'maplibre') {\n    return 'carto';\n  }\n  if (baseMapLibrary === 'mapbox') {\n    return mapboxApiAccessToken ? 'mapbox' : 'carto';\n  }\n  // Unknown library: prefer Mapbox when a token exists, otherwise CARTO.\n  return mapboxApiAccessToken ? 'mapbox' : 'carto';\n};\n\n// CARTO free vector tiles (OpenMapTiles schema, no API key required).\nconst CARTO_VECTOR_TILE_URLS = [\n  'https://tiles-a.basemaps.cartocdn.com/vectortiles/carto.streets/v1/{z}/{x}/{y}.mvt',\n  'https://tiles-b.basemaps.cartocdn.com/vectortiles/carto.streets/v1/{z}/{x}/{y}.mvt',\n  'https://tiles-c.basemaps.cartocdn.com/vectortiles/carto.streets/v1/{z}/{x}/{y}.mvt',\n  'https://tiles-d.basemaps.cartocdn.com/vectortiles/carto.streets/v1/{z}/{x}/{y}.mvt'\n];\n\n// Free satellite raster fallback (Esri World Imagery, no API key required).\nconst ESRI_WORLD_IMAGERY_URL =\n  'https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}';\n\n/**\n * Maps a raw MVT source-layer name to a normalized semantic layer kind, so the\n * fill/line/label accessors work across both the Mapbox (`mapbox-streets-v8`)\n * and CARTO/OpenMapTiles schemas.\n *\n * | semantic | mapbox        | openmaptiles |\n * | -------- | ------------- | ------------ |\n * | water    | `water`       | `water`      |\n * | admin    | `admin`       | `boundary`   |\n * | label    | `place_label` | `place`      |\n */\ntype BasemapLayerKind = 'water' | 'admin' | 'label' | 'other';\n\nfunction getBasemapLayerKind(layerName?: string): BasemapLayerKind {\n  switch (layerName) {\n    case 'water':\n      return 'water';\n    case 'admin':\n    case 'boundary':\n      return 'admin';\n    case 'place_label':\n    case 'place':\n      return 'label';\n    default:\n      return 'other';\n  }\n}\n\nexport type GlobeAttribution = {label: string; href: string};\n\nconst MAPBOX_ATTRIBUTION: GlobeAttribution = {\n  label: '© Mapbox',\n  href: 'https://www.mapbox.com/about/maps/'\n};\nconst OSM_ATTRIBUTION: GlobeAttribution = {\n  label: '© OpenStreetMap',\n  href: 'https://www.openstreetmap.org/copyright'\n};\nconst CARTO_ATTRIBUTION: GlobeAttribution = {\n  label: '© CARTO',\n  href: 'https://carto.com/attributions'\n};\nconst ESRI_ATTRIBUTION: GlobeAttribution = {\n  label: 'Powered by Esri',\n  href: 'https://www.esri.com/'\n};\n\n/**\n * Resolve the tile-source attribution entries for the globe basemap. deck.gl\n * renders the globe basemap tiles itself (not the base Maplibre/Mapbox map), so\n * the base map's attribution machinery never sees them. This lets the UI credit\n * the actual tile provider(s) in globe mode.\n */\nexport const getGlobeBasemapAttributions = ({\n  globe,\n  mapboxApiAccessToken,\n  mapStyleType,\n  basemapProvider\n}: {\n  globe?: Globe;\n  mapboxApiAccessToken?: string;\n  mapStyleType?: string;\n  basemapProvider?: GlobeBasemapProvider;\n}): GlobeAttribution[] => {\n  if (!globe?.enabled || !globe.config?.basemap) {\n    return [];\n  }\n\n  const provider: GlobeBasemapProvider =\n    basemapProvider ?? resolveGlobeBasemapProvider(undefined, mapboxApiAccessToken);\n\n  if (provider === 'mapbox') {\n    return mapboxApiAccessToken ? [MAPBOX_ATTRIBUTION, OSM_ATTRIBUTION] : [];\n  }\n\n  const isSatellite = mapStyleType === 'satellite' || mapStyleType === 'satellite-street';\n  // CARTO vector tiles are OpenStreetMap-derived; Esri imagery is credited separately.\n  return isSatellite\n    ? [ESRI_ATTRIBUTION, CARTO_ATTRIBUTION, OSM_ATTRIBUTION]\n    : [CARTO_ATTRIBUTION, OSM_ATTRIBUTION];\n};\n\n// eslint-disable-next-line complexity\nexport const getGlobeBaseLayers = ({\n  mapboxApiAccessToken,\n  globe,\n  mapStyleType,\n  basemapProvider,\n  latitude,\n  zoom\n}: {\n  mapboxApiAccessToken: string;\n  globe: Globe;\n  mapStyleType?: string;\n  /**\n   * Which tile provider to use for the globe basemap. Defaults to `mapbox` when\n   * a token is present, otherwise falls back to the token-free `carto` tiles.\n   */\n  basemapProvider?: GlobeBasemapProvider;\n  /**\n   * Current camera center latitude. Used to keep tile LOD constant while rotating\n   * toward the poles (deck.gl 9 lowers the effective zoom near the poles). When\n   * omitted, no latitude compensation is applied (equator behavior).\n   */\n  latitude?: number;\n  /**\n   * Current map zoom level. Used to fade the atmosphere effects out when the user\n   * zooms in past a certain threshold (mirrors Google Maps globe behaviour).\n   */\n  zoom?: number;\n}): Layer[] => {\n  const {config} = globe;\n\n  const isSatellite = mapStyleType === 'satellite';\n  const isSatelliteStreet = mapStyleType === 'satellite-street';\n\n  const latZoomCompensation = globeLatitudeZoomCompensation(latitude);\n\n  // Fall back to the free CARTO tiles whenever no Mapbox token is available so\n  // the globe basemap still renders (matches kepler's default token-free\n  // MapLibre/CARTO basemaps). Callers should pass an explicit `basemapProvider`\n  // (derived from the selected style) so the globe follows the 2D basemap.\n  const provider: GlobeBasemapProvider =\n    basemapProvider ?? resolveGlobeBasemapProvider(undefined, mapboxApiAccessToken);\n  const useCarto = provider === 'carto';\n  const hasTileAccess = useCarto || Boolean(mapboxApiAccessToken);\n\n  return [\n    config.atmosphere ? getGlobeAtmosphereSkyLayer({config, zoom}) : null,\n\n    // Depth-only cross-section disk: writes depth at the globe's silhouette so\n    // far-side geometry (arcs/lines) is occluded by the planet.\n    getGlobeDepthDiskLayer({fillColor: config.surfaceColor}),\n\n    // Background surface polygon\n    (!config.basemap || (!isSatellite && !isSatelliteStreet)) &&\n      new SolidPolygonLayer({\n        id: 'globe-background',\n        data: BACKGROUND_DATA,\n        getPolygon: ((d: number[][]) => d) as any,\n        filled: true,\n        getFillColor: config.surfaceColor as any,\n        parameters: BACKGROUND_PARAMETERS\n      }),\n\n    // Fill hole at north pole\n    config.basemap &&\n      new SolidPolygonLayer({\n        id: 'globe-background-north-pole',\n        data: BACKGROUND_NORTH_POLE_DATA,\n        getPolygon: ((d: number[][]) => d) as any,\n        filled: true,\n        getFillColor: (config.water ? config.waterColor : config.surfaceColor) as any,\n        parameters: BACKGROUND_PARAMETERS\n      }),\n\n    // Satellite tiles\n    config.basemap &&\n      (isSatellite || isSatelliteStreet) &&\n      hasTileAccess &&\n      new TileLayer({\n        id: `globe-satellite-tiles-${provider}`,\n        data: useCarto\n          ? [ESRI_WORLD_IMAGERY_URL]\n          : [\n              `https://api.mapbox.com/v4/mapbox.satellite/{z}/{x}/{y}@2x.png?access_token=${mapboxApiAccessToken}`\n            ],\n        minZoom: 0,\n        maxZoom: useCarto ? 18 : 19,\n        zoomOffset: GLOBE_SATELLITE_ZOOM_OFFSET + latZoomCompensation,\n        extent: GLOBE_TILE_EXTENT,\n        // Esri tiles are 256px; Mapbox @2x tiles are 512px.\n        tileSize: useCarto ? 256 : 512 / devicePixelRatio,\n        renderSubLayers: (props: any) => {\n          const {\n            bbox: {west, south, east, north}\n          } = props.tile;\n\n          return [\n            new BitmapLayer(props, {\n              _imageCoordinateSystem: COORDINATE_SYSTEM.CARTESIAN,\n              data: undefined,\n              image: props.data,\n              bounds: [west, south, east, north]\n            })\n          ];\n        },\n        parameters: BASEMAP_RASTER_PARAMETERS\n      }),\n\n    // Vector basemap (MVT labels/admin/water)\n    config.basemap &&\n      !isSatellite &&\n      hasTileAccess &&\n      new MVTLayer({\n        // force the layer to update when the style/label/provider config changes\n        id: `globe-basemap-mvt-layer-${provider}-${mapStyleType}`,\n        data: useCarto\n          ? CARTO_VECTOR_TILE_URLS\n          : `https://a.tiles.mapbox.com/v4/mapbox.mapbox-streets-v8/{z}/{x}/{y}.vector.pbf?access_token=${mapboxApiAccessToken}`,\n        minZoom: 0,\n        // Overzoom past the source's native max instead of 404-ing on tiles that\n        // don't exist (which renders as empty rectangles at high zoom).\n        maxZoom: useCarto ? CARTO_VECTOR_MAX_DATA_ZOOM : MAPBOX_VECTOR_MAX_DATA_ZOOM,\n        zoomOffset:\n          (useCarto ? CARTO_GLOBE_VECTOR_ZOOM_OFFSET : MAPBOX_GLOBE_VECTOR_ZOOM_OFFSET) +\n          latZoomCompensation,\n        extent: GLOBE_TILE_EXTENT,\n        binary: false,\n        parameters: BASEMAP_MVT_PARAMETERS,\n        loadOptions: useCarto\n          ? {\n              // OpenMapTiles schema: `boundary` = admin lines, `place` = labels.\n              mvt: {\n                layers: isSatelliteStreet\n                  ? ['place', 'boundary']\n                  : ['place', 'boundary', 'water', 'transportation']\n              }\n            }\n          : {\n              mvt: {\n                layers: isSatelliteStreet\n                  ? ['place_label', 'admin']\n                  : ['place_label', 'admin', 'water', 'road']\n              }\n            },\n        // Render admin/water via GeoJsonLayer and place labels via TextLayer.\n        config,\n        renderSubLayers: (props: any) => new MVTLabelLayer(props),\n        getFillColor: (f: any) => {\n          switch (getBasemapLayerKind(f.properties.layerName)) {\n            case 'water':\n              return config.water ? config.waterColor : INVISIBLE_COLOR;\n            default:\n              return config.surfaceColor;\n          }\n        },\n        getLineColor: (f: any) => {\n          switch (getBasemapLayerKind(f.properties.layerName)) {\n            case 'admin':\n              return config.adminLines ? config.adminLinesColor : INVISIBLE_COLOR;\n            default:\n              return config.surfaceColor;\n          }\n        },\n        getLineWidth: (f: any) => {\n          switch (getBasemapLayerKind(f.properties.layerName)) {\n            case 'admin':\n              switch (f.properties.admin_level) {\n                case 0:\n                case 2:\n                  return 1;\n                default:\n                  return 0.75;\n              }\n            default:\n              return 0;\n          }\n        },\n        updateTriggers: {\n          getFillColor: [config.waterColor, config.surfaceColor, config.water],\n          getLineColor: [config.adminLinesColor, config.surfaceColor, config.adminLines]\n        },\n        lineWidthUnits: 'pixels',\n        lineWidthMinPixels: 0,\n        lineWidthMaxPixels: 20,\n        getPointRadius: 0,\n        pointRadiusMinPixels: 0\n      } as any)\n  ].filter(Boolean) as Layer[];\n};\n\nexport const getGlobeTopLayers = ({globe, zoom}: {globe: Globe; zoom?: number}): Layer[] => {\n  const {config} = globe;\n  return [config.atmosphere ? getGlobeAtmosphereLayer({config, zoom}) : null].filter(Boolean) as Layer[];\n};\n"],"mappings":"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","ignoreList":[]}