@kepler.gl/components 3.3.0-alpha.5 → 3.3.0-alpha.6

package/dist/esm/modals/hubble-utils.js

@@ -0,0 +1,429 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+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; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { MapView, WebMercatorViewport } from '@deck.gl/core';
+import { DEFAULT_MAPBOX_API_URL, EMPTY_MAPBOX_STYLE, FILTER_VIEW_TYPES, FILTER_TYPES, GLOBE_MIN_ZOOM, GLOBE_MAX_ZOOM } from '@kepler.gl/constants';
+import { getLayerBlendingParameters, getBaseMapLibrary } from '@kepler.gl/utils';
+import { getGlobeBaseLayers, getGlobeTopLayers, KeplerGlobeView } from '@kepler.gl/deckgl-layers';
+import { computeDeckLayers } from '@kepler.gl/reducers';
+import { isMapboxURL, transformMapboxUrl } from 'maplibregl-mapbox-request-transformer';
+import { point } from '@turf/helpers';
+import { transformTranslate } from '@turf/transform-translate';
+// luma.gl defaults `debug` to true whenever NODE_ENV !== 'production', which
+// instruments every render pass with a TIME_ELAPSED_EXT timer query. WebGL2 only
+// allows one such query to be active at a time, and the globe export renders
+// several passes per frame, so the debug context throws INVALID_OPERATION and
+// takes the whole export modal down. Export previews are throwaway render
+// targets that don't need the validation layer.
+
+/** Device props for export previews that own their canvas and read pixels back off it. */
+export var EXPORT_DECK_DEVICE_PROPS = {
+  type: 'webgl',
+  webgl: {
+    preserveDrawingBuffer: true
+  },
+  debug: false
+};
+
+/** Device props for export previews that draw as an overlay on top of a basemap. */
+export var EXPORT_OVERLAY_DEVICE_PROPS = {
+  type: 'webgl',
+  webgl: {
+    stencil: true
+  },
+  debug: false
+};
+var linear = function linear(p) {
+  return p;
+};
+var hold = function hold(p) {
+  return p === 1 ? 1 : 0;
+};
+function getKeyFramesFree(filter) {
+  var delta = filter.value[1] - filter.value[0];
+  return {
+    keyframes: [{
+      value: [filter.domain[0], filter.domain[0] + delta]
+    }, {
+      value: [filter.domain[1] - delta, filter.domain[1]]
+    }],
+    easings: linear
+  };
+}
+export function getTimeRangeFilterKeyframes(_ref) {
+  var filter = _ref.filter,
+    timings = _ref.timings;
+  if (filter.type !== FILTER_TYPES.timeRange) {
+    throw new Error("filter type must be 'timeRange'.");
+  }
+  var duration = timings[1] - timings[0];
+  switch (filter.animationWindow) {
+    default:
+    case 'free':
+      {
+        return getKeyFramesFree(filter);
+      }
+    case 'incremental':
+      {
+        return {
+          keyframes: [{
+            value: [filter.value[0], filter.value[0] + 1]
+          }, {
+            value: [filter.value[0], filter.domain[1]]
+          }],
+          easings: linear
+        };
+      }
+    case 'point':
+      {
+        return {
+          keyframes: [{
+            value: filter.domain[0]
+          }, {
+            value: filter.domain[1]
+          }],
+          easings: linear
+        };
+      }
+    case 'interval':
+      {
+        var _timeBins$dataId$;
+        var plotType = filter.plotType,
+          timeBins = filter.timeBins,
+          dataId = filter.dataId;
+        var interval = plotType.interval;
+        var bins = timeBins === null || timeBins === void 0 || (_timeBins$dataId$ = timeBins[dataId[0]]) === null || _timeBins$dataId$ === void 0 ? void 0 : _timeBins$dataId$[interval];
+        if (!interval || !bins || bins.length === 0) {
+          return getKeyFramesFree(filter);
+        }
+        var delta = Math.round(duration / bins.length);
+        return {
+          timings: bins.map(function (_, idx) {
+            return timings[0] + delta * idx;
+          }),
+          keyframes: bins.map(function (bin) {
+            return {
+              value: [bin.x0, bin.x1]
+            };
+          }),
+          easings: hold
+        };
+      }
+  }
+}
+export function getBeforeLayerId(topMapStyle, bottomMapStyle) {
+  var _topMapStyle$layers, _bottomMapStyle$layer;
+  if (topMapStyle !== null && topMapStyle !== void 0 && (_topMapStyle$layers = topMapStyle.layers) !== null && _topMapStyle$layers !== void 0 && _topMapStyle$layers.length && bottomMapStyle !== null && bottomMapStyle !== void 0 && (_bottomMapStyle$layer = bottomMapStyle.layers) !== null && _bottomMapStyle$layer !== void 0 && _bottomMapStyle$layer.length) {
+    var firstTopLayer = topMapStyle.layers[0];
+    var firstTopLayerIdx = bottomMapStyle.layers.findIndex(function (layer) {
+      return layer.id === firstTopLayer.id;
+    });
+    var beforeIdx = firstTopLayerIdx - 1;
+    return beforeIdx > -1 ? bottomMapStyle.layers[beforeIdx] : null;
+  }
+  return null;
+}
+export function getStaticMapProps(keplerState, onViewChange, mapboxApiAccessToken) {
+  var _keplerState$mapStyle, _keplerState$mapState, _keplerState$mapStyle2, _keplerState$mapStyle3;
+  var mapboxApiUrl = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : DEFAULT_MAPBOX_API_URL;
+  var currentStyle = (_keplerState$mapStyle = keplerState.mapStyle) === null || _keplerState$mapStyle === void 0 || (_keplerState$mapStyle = _keplerState$mapStyle.mapStyles) === null || _keplerState$mapStyle === void 0 ? void 0 : _keplerState$mapStyle[keplerState.mapStyle.styleType];
+  var accessToken = (currentStyle === null || currentStyle === void 0 ? void 0 : currentStyle.accessToken) || mapboxApiAccessToken;
+  var isMapbox = getBaseMapLibrary(currentStyle) === 'mapbox';
+  var isGlobe = Boolean((_keplerState$mapState = keplerState.mapState) === null || _keplerState$mapState === void 0 || (_keplerState$mapState = _keplerState$mapState.globe) === null || _keplerState$mapState === void 0 ? void 0 : _keplerState$mapState.enabled);
+  var mapboxTransformRequest = function mapboxTransformRequest(url, resourceType) {
+    if (isMapboxURL(url)) {
+      return transformMapboxUrl(url, resourceType, accessToken);
+    }
+    return {
+      url: url
+    };
+  };
+
+  // In globe mode the deck.gl GlobeView renders the planet + basemap tiles as
+  // deck layers on a transparent canvas, so the flat maplibre base map must be
+  // suppressed (otherwise a 2D Mercator basemap would render behind the globe).
+  var bottomMapStyle = isGlobe ? EMPTY_MAPBOX_STYLE : isMapbox ? convertMapboxStyleUrls((_keplerState$mapStyle2 = keplerState.mapStyle) === null || _keplerState$mapStyle2 === void 0 ? void 0 : _keplerState$mapStyle2.bottomMapStyle, accessToken) : (_keplerState$mapStyle3 = keplerState.mapStyle) === null || _keplerState$mapStyle3 === void 0 ? void 0 : _keplerState$mapStyle3.bottomMapStyle;
+  return _objectSpread(_objectSpread({}, keplerState.mapState), {}, {
+    preserveDrawingBuffer: true,
+    mapboxApiAccessToken: accessToken,
+    mapboxApiUrl: mapboxApiUrl,
+    transformRequest: mapboxTransformRequest,
+    mapStyle: bottomMapStyle,
+    onViewportChange: onViewChange,
+    mapLib: import('maplibre-gl')
+  });
+}
+
+/**
+ * Convert mapbox:// URLs inside a Mapbox style object to HTTPS API URLs
+ * so that maplibre-gl can fetch them directly.
+ */
+function convertMapboxStyleUrls(style, accessToken) {
+  if (!style || _typeof(style) !== 'object') return style;
+  var converted = _objectSpread({}, style);
+  if (typeof converted.sprite === 'string' && isMapboxURL(converted.sprite)) {
+    var _transformMapboxUrl;
+    converted.sprite = (_transformMapboxUrl = transformMapboxUrl(converted.sprite, 'Sprite', accessToken)) === null || _transformMapboxUrl === void 0 ? void 0 : _transformMapboxUrl.url;
+  }
+  if (typeof converted.glyphs === 'string' && isMapboxURL(converted.glyphs)) {
+    var _transformMapboxUrl2;
+    converted.glyphs = (_transformMapboxUrl2 = transformMapboxUrl(converted.glyphs, 'Glyphs', accessToken)) === null || _transformMapboxUrl2 === void 0 ? void 0 : _transformMapboxUrl2.url;
+  }
+  if (converted.sources) {
+    var newSources = {};
+    for (var _i = 0, _Object$entries = Object.entries(converted.sources); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        key = _Object$entries$_i[0],
+        source = _Object$entries$_i[1];
+      if (source !== null && source !== void 0 && source.url && isMapboxURL(source.url)) {
+        var _transformMapboxUrl3;
+        newSources[key] = _objectSpread(_objectSpread({}, source), {}, {
+          url: (_transformMapboxUrl3 = transformMapboxUrl(source.url, 'Source', accessToken)) === null || _transformMapboxUrl3 === void 0 ? void 0 : _transformMapboxUrl3.url
+        });
+      } else {
+        newSources[key] = source;
+      }
+    }
+    converted.sources = newSources;
+  }
+  return converted;
+}
+function getHubbleParameters(keplerState) {
+  return getLayerBlendingParameters(keplerState.visState.layerBlending);
+}
+export function getHubbleDeckGlProps(keplerState, mapboxApiAccessToken) {
+  var _keplerState$mapState2, _keplerState$mapStyle4;
+  var mapboxApiUrl = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_MAPBOX_API_URL;
+  var globe = (_keplerState$mapState2 = keplerState.mapState) === null || _keplerState$mapState2 === void 0 ? void 0 : _keplerState$mapState2.globe;
+  var isGlobe = Boolean(globe === null || globe === void 0 ? void 0 : globe.enabled);
+  if (!isGlobe) {
+    return {
+      parameters: getHubbleParameters(keplerState),
+      controller: true,
+      views: new MapView({
+        id: 'mapbox',
+        farZMultiplier: 1.2
+      })
+    };
+  }
+
+  // Globe video export: mirror the interactive globe render path in map-container.
+  // - Use a GlobeView so the camera/projection curve data around the sphere.
+  // - Provide layers explicitly (globe base layers + kepler data layers + globe
+  //   top layers). When `deckProps.layers` is set, hubble's preview uses them
+  //   verbatim (skipping its internal 2D-only createKeplerLayers path), and the
+  //   kepler layers are built from `mapState.globe`, so composite layers (e.g.
+  //   the heatmap) emit their globe-conforming sublayers.
+  var globeBaseLayers = getGlobeBaseLayers({
+    mapboxApiAccessToken: mapboxApiAccessToken || '',
+    globe: globe,
+    mapStyleType: (_keplerState$mapStyle4 = keplerState.mapStyle) === null || _keplerState$mapStyle4 === void 0 ? void 0 : _keplerState$mapStyle4.styleType
+  });
+  var globeTopLayers = getGlobeTopLayers({
+    globe: globe
+  });
+  var dataLayers = computeDeckLayers(keplerState, {
+    primaryMap: true,
+    mapboxApiAccessToken: mapboxApiAccessToken,
+    mapboxApiUrl: mapboxApiUrl
+  });
+
+  // hubble's video-export preview renders a bare <DeckGL> in the disableBaseMap
+  // (globe) branch and — unlike its mapbox branch — never forwards a viewState.
+  // With `controller: true` deck.gl then constructs a controller state from an
+  // empty view state, and GlobeState/MapState assert on the missing
+  // latitude/longitude/zoom ("assertion failed at new MapState/GlobeState").
+  // That degenerate viewport also leaves tile/MVT base layers permanently
+  // "not loaded", so hubble's `layers.every(l => l.isLoaded)` capture gate never
+  // fires and the export hangs. Provide an explicit initialViewState (deck.gl
+  // uses it to seed the controller when no controlled viewState is supplied) so
+  // the globe camera is valid, tiles resolve, and interaction works.
+  var _ref2 = keplerState.mapState || {},
+    longitude = _ref2.longitude,
+    latitude = _ref2.latitude,
+    zoom = _ref2.zoom,
+    pitch = _ref2.pitch,
+    bearing = _ref2.bearing;
+  var initialViewState = {
+    longitude: longitude,
+    latitude: latitude,
+    zoom: zoom,
+    pitch: pitch || 0,
+    bearing: bearing || 0,
+    minZoom: GLOBE_MIN_ZOOM,
+    maxZoom: GLOBE_MAX_ZOOM
+  };
+  return {
+    parameters: _objectSpread(_objectSpread({}, getHubbleParameters(keplerState)), {}, {
+      cull: true
+    }),
+    // Match the interactive globe controller bounds so panning/zoom feels the
+    // same in the preview as on the main map.
+    controller: {
+      minZoom: GLOBE_MIN_ZOOM,
+      maxZoom: GLOBE_MAX_ZOOM
+    },
+    initialViewState: initialViewState,
+    views: new KeplerGlobeView({
+      resolution: 5,
+      // clearColor:false (not a solid color) is deliberate and mirrors the
+      // interactive map: deck.gl applies a View's clearColor in EVERY pass
+      // including the picking pass, forcing alpha to 255. In the picking buffer
+      // the alpha byte encodes the layer index, so a solid clear makes deck.gl
+      // decode every pixel as a non-existent layer ("Picked non-existent layer.
+      // Is picking buffer corrupt?") whenever the controller picks on hover.
+      // Skipping the color clear keeps the picking buffer's 0 alpha intact; the
+      // sphere itself stays opaque via the globe-background SolidPolygonLayer.
+      clear: true,
+      clearColor: false
+    }),
+    layers: [].concat(_toConsumableArray(globeBaseLayers), _toConsumableArray(dataLayers), _toConsumableArray(globeTopLayers))
+  };
+}
+
+/**
+ * Build a fresh set of globe layers (base + data + top) for a given split-map
+ * index. Used by the swipe export preview, which mounts two independent Deck
+ * instances: each side needs its OWN layer instances (deck.gl Layer objects are
+ * stateful and bound to a single Deck) and its own `mapIndex` so the split-map
+ * layer visibility is respected on each half of the swipe.
+ */
+export function getGlobeExportLayers(keplerState, _ref3) {
+  var _keplerState$mapState3, _keplerState$mapStyle5;
+  var mapIndex = _ref3.mapIndex,
+    mapboxApiAccessToken = _ref3.mapboxApiAccessToken,
+    mapboxApiUrl = _ref3.mapboxApiUrl;
+  var globe = (_keplerState$mapState3 = keplerState.mapState) === null || _keplerState$mapState3 === void 0 ? void 0 : _keplerState$mapState3.globe;
+  var globeBaseLayers = getGlobeBaseLayers({
+    mapboxApiAccessToken: mapboxApiAccessToken || '',
+    globe: globe,
+    mapStyleType: (_keplerState$mapStyle5 = keplerState.mapStyle) === null || _keplerState$mapStyle5 === void 0 ? void 0 : _keplerState$mapStyle5.styleType
+  });
+  var globeTopLayers = getGlobeTopLayers({
+    globe: globe
+  });
+  var dataLayers = computeDeckLayers(keplerState, {
+    mapIndex: mapIndex,
+    primaryMap: mapIndex === 0,
+    mapboxApiAccessToken: mapboxApiAccessToken,
+    mapboxApiUrl: mapboxApiUrl
+  });
+  return [].concat(_toConsumableArray(globeBaseLayers), _toConsumableArray(dataLayers), _toConsumableArray(globeTopLayers));
+}
+export function getAnimatableFilters(keplerState) {
+  var _keplerState$visState;
+  var filters = ((_keplerState$visState = keplerState.visState) === null || _keplerState$visState === void 0 ? void 0 : _keplerState$visState.filters) || [];
+  return filters.filter(function (f) {
+    return f.type === FILTER_TYPES.timeRange && (f.view === FILTER_VIEW_TYPES.enlarged || f.syncedWithLayerTimeline);
+  });
+}
+
+// --- Video export utilities (inlined from @hubble.gl internals) ---
+
+export function scaleToVideoExport(viewState, container) {
+  // In globe mode (and at extreme zooms) the WebMercatorViewport used below can
+  // produce a non-invertible projection matrix, making `unproject` throw. The
+  // Mercator fit-bounds rescaling only makes sense for the flat MapView anyway,
+  // so fall back to simply resizing the viewport to the export container.
+  try {
+    var viewport = new WebMercatorViewport(viewState);
+    var nw = viewport.unproject([0, 0]);
+    var se = viewport.unproject([viewport.width, viewport.height]);
+    var videoViewport = new WebMercatorViewport(_objectSpread(_objectSpread({}, viewState), {}, {
+      width: container.width,
+      height: container.height
+    })).fitBounds([nw, se]);
+    var height = videoViewport.height,
+      width = videoViewport.width,
+      latitude = videoViewport.latitude,
+      longitude = videoViewport.longitude,
+      zoom = videoViewport.zoom,
+      altitude = videoViewport.altitude;
+    return {
+      height: height,
+      width: width,
+      latitude: latitude,
+      longitude: longitude,
+      pitch: viewState.pitch,
+      zoom: zoom,
+      bearing: viewState.bearing,
+      altitude: altitude
+    };
+  } catch (e) {
+    return _objectSpread(_objectSpread({}, viewState), {}, {
+      width: container.width,
+      height: container.height
+    });
+  }
+}
+export function parseSetCameraType(strCameraType, viewState) {
+  var modifiedViewState = _objectSpread({}, viewState);
+  var match = strCameraType.match(/\b(?!to)\b\S+\w/g);
+  if (!match) return modifiedViewState;
+  var turfPoint = point([modifiedViewState.longitude, modifiedViewState.latitude]);
+  if (match[0] === 'Orbit') {
+    modifiedViewState.bearing = modifiedViewState.bearing + parseInt(match[1], 10);
+  }
+  var directions = new Set(['East', 'South', 'West', 'North']);
+  if (directions.has(match[0])) {
+    var directionMap = {
+      East: 270,
+      South: 0,
+      West: 90,
+      North: 180
+    };
+    var translatedPoly = transformTranslate(turfPoint, 10, directionMap[match[0]]);
+    if (match[0] === 'East' || match[0] === 'West') {
+      modifiedViewState.longitude = translatedPoly.geometry.coordinates[0];
+    } else {
+      modifiedViewState.latitude = translatedPoly.geometry.coordinates[1];
+    }
+  }
+  if (match[0] === 'Zoom') {
+    modifiedViewState.zoom += match[1] === 'In' ? 3 : -3;
+  }
+  return modifiedViewState;
+}
+var RESOLUTIONS = [{
+  value: '960x540',
+  label: 'Good (540p)',
+  width: 960,
+  height: 540
+}, {
+  value: '1280x720',
+  label: 'High (720p)',
+  width: 1280,
+  height: 720
+}, {
+  value: '1920x1080',
+  label: 'Highest (1080p)',
+  width: 1920,
+  height: 1080
+}, {
+  value: '640x480',
+  label: 'Good (480p)',
+  width: 640,
+  height: 480
+}, {
+  value: '1280x960',
+  label: 'High (960p)',
+  width: 1280,
+  height: 960
+}, {
+  value: '1920x1440',
+  label: 'Highest (1440p)',
+  width: 1920,
+  height: 1440
+}];
+export function getResolutionSetting(value) {
+  return RESOLUTIONS.find(function (r) {
+    return r.value === value;
+  }) || RESOLUTIONS[0];
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["MapView","WebMercatorViewport","DEFAULT_MAPBOX_API_URL","EMPTY_MAPBOX_STYLE","FILTER_VIEW_TYPES","FILTER_TYPES","GLOBE_MIN_ZOOM","GLOBE_MAX_ZOOM","getLayerBlendingParameters","getBaseMapLibrary","getGlobeBaseLayers","getGlobeTopLayers","KeplerGlobeView","computeDeckLayers","isMapboxURL","transformMapboxUrl","point","transformTranslate","EXPORT_DECK_DEVICE_PROPS","type","webgl","preserveDrawingBuffer","debug","EXPORT_OVERLAY_DEVICE_PROPS","stencil","linear","p","hold","getKeyFramesFree","filter","delta","value","keyframes","domain","easings","getTimeRangeFilterKeyframes","_ref","timings","timeRange","Error","duration","animationWindow","_timeBins$dataId$","plotType","timeBins","dataId","interval","bins","length","Math","round","map","_","idx","bin","x0","x1","getBeforeLayerId","topMapStyle","bottomMapStyle","_topMapStyle$layers","_bottomMapStyle$layer","layers","firstTopLayer","firstTopLayerIdx","findIndex","layer","id","beforeIdx","getStaticMapProps","keplerState","onViewChange","mapboxApiAccessToken","_keplerState$mapStyle","_keplerState$mapState","_keplerState$mapStyle2","_keplerState$mapStyle3","mapboxApiUrl","arguments","undefined","currentStyle","mapStyle","mapStyles","styleType","accessToken","isMapbox","isGlobe","Boolean","mapState","globe","enabled","mapboxTransformRequest","url","resourceType","convertMapboxStyleUrls","_objectSpread","transformRequest","onViewportChange","mapLib","style","_typeof","converted","sprite","_transformMapboxUrl","glyphs","_transformMapboxUrl2","sources","newSources","_i","_Object$entries","Object","entries","_Object$entries$_i","_slicedToArray","key","source","_transformMapboxUrl3","getHubbleParameters","visState","layerBlending","getHubbleDeckGlProps","_keplerState$mapState2","_keplerState$mapStyle4","parameters","controller","views","farZMultiplier","globeBaseLayers","mapStyleType","globeTopLayers","dataLayers","primaryMap","_ref2","longitude","latitude","zoom","pitch","bearing","initialViewState","minZoom","maxZoom","cull","resolution","clear","clearColor","concat","_toConsumableArray","getGlobeExportLayers","_ref3","_keplerState$mapState3","_keplerState$mapStyle5","mapIndex","getAnimatableFilters","_keplerState$visState","filters","f","view","enlarged","syncedWithLayerTimeline","scaleToVideoExport","viewState","container","viewport","nw","unproject","se","width","height","videoViewport","fitBounds","altitude","e","parseSetCameraType","strCameraType","modifiedViewState","match","turfPoint","parseInt","directions","Set","has","directionMap","East","South","West","North","translatedPoly","geometry","coordinates","RESOLUTIONS","label","getResolutionSetting","find","r"],"sources":["../../../src/modals/hubble-utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {MapView, WebMercatorViewport, type MapViewState} from '@deck.gl/core';\nimport {\n  DEFAULT_MAPBOX_API_URL,\n  EMPTY_MAPBOX_STYLE,\n  FILTER_VIEW_TYPES,\n  FILTER_TYPES,\n  GLOBE_MIN_ZOOM,\n  GLOBE_MAX_ZOOM\n} from '@kepler.gl/constants';\nimport {getLayerBlendingParameters, getBaseMapLibrary} from '@kepler.gl/utils';\nimport {getGlobeBaseLayers, getGlobeTopLayers, KeplerGlobeView} from '@kepler.gl/deckgl-layers';\nimport {computeDeckLayers} from '@kepler.gl/reducers';\nimport {isMapboxURL, transformMapboxUrl} from 'maplibregl-mapbox-request-transformer';\nimport {point} from '@turf/helpers';\nimport {transformTranslate} from '@turf/transform-translate';\nimport {TimeRangeFilter} from '@kepler.gl/types';\n\ntype KeplerState = {\n  visState: any;\n  mapState: any;\n  mapStyle: any;\n};\n\ntype MapboxLayerRef = {\n  id: string;\n} & Record<string, any>;\n\n// luma.gl defaults `debug` to true whenever NODE_ENV !== 'production', which\n// instruments every render pass with a TIME_ELAPSED_EXT timer query. WebGL2 only\n// allows one such query to be active at a time, and the globe export renders\n// several passes per frame, so the debug context throws INVALID_OPERATION and\n// takes the whole export modal down. Export previews are throwaway render\n// targets that don't need the validation layer.\n\n/** Device props for export previews that own their canvas and read pixels back off it. */\nexport const EXPORT_DECK_DEVICE_PROPS = {\n  type: 'webgl' as const,\n  webgl: {preserveDrawingBuffer: true},\n  debug: false\n};\n\n/** Device props for export previews that draw as an overlay on top of a basemap. */\nexport const EXPORT_OVERLAY_DEVICE_PROPS = {\n  type: 'webgl' as const,\n  webgl: {stencil: true},\n  debug: false\n};\n\nconst linear: (p: number) => number = p => p;\nconst hold: (p: number) => number = p => (p === 1 ? 1 : 0);\n\ntype TimeRangeFilterKeyframes = {\n  keyframes: {value: number | [number, number]}[];\n  easings: (p: number) => number;\n  timings?: number[];\n};\n\nfunction getKeyFramesFree(filter: TimeRangeFilter): TimeRangeFilterKeyframes {\n  const delta = filter.value[1] - filter.value[0];\n  return {\n    keyframes: [\n      {value: [filter.domain[0], filter.domain[0] + delta]},\n      {value: [filter.domain[1] - delta, filter.domain[1]]}\n    ],\n    easings: linear\n  };\n}\n\nexport function getTimeRangeFilterKeyframes({\n  filter,\n  timings\n}: {\n  filter: TimeRangeFilter;\n  timings: number[];\n}): TimeRangeFilterKeyframes {\n  if (filter.type !== FILTER_TYPES.timeRange) {\n    throw new Error(\"filter type must be 'timeRange'.\");\n  }\n\n  const duration = timings[1] - timings[0];\n\n  switch (filter.animationWindow) {\n    default:\n    case 'free': {\n      return getKeyFramesFree(filter);\n    }\n    case 'incremental': {\n      return {\n        keyframes: [\n          {value: [filter.value[0], filter.value[0] + 1]},\n          {value: [filter.value[0], filter.domain[1]]}\n        ],\n        easings: linear\n      };\n    }\n    case 'point': {\n      return {\n        keyframes: [{value: filter.domain[0]}, {value: filter.domain[1]}],\n        easings: linear\n      };\n    }\n    case 'interval': {\n      const {plotType, timeBins, dataId} = filter;\n      const {interval} = plotType;\n\n      const bins = timeBins?.[dataId[0]]?.[interval];\n\n      if (!interval || !bins || bins.length === 0) {\n        return getKeyFramesFree(filter);\n      }\n\n      const delta = Math.round(duration / bins.length);\n\n      return {\n        timings: bins.map((_, idx) => timings[0] + delta * idx),\n        keyframes: bins.map(bin => ({value: [bin.x0, bin.x1]})),\n        easings: hold\n      };\n    }\n  }\n}\n\nexport function getBeforeLayerId(topMapStyle: any, bottomMapStyle: any): MapboxLayerRef | null {\n  if (topMapStyle?.layers?.length && bottomMapStyle?.layers?.length) {\n    const firstTopLayer = topMapStyle.layers[0];\n    const firstTopLayerIdx = bottomMapStyle.layers.findIndex(\n      (layer: MapboxLayerRef) => layer.id === firstTopLayer.id\n    );\n    const beforeIdx = firstTopLayerIdx - 1;\n    return beforeIdx > -1 ? bottomMapStyle.layers[beforeIdx] : null;\n  }\n  return null;\n}\n\nexport function getStaticMapProps(\n  keplerState: KeplerState,\n  onViewChange: (viewState: Record<string, any>) => void,\n  mapboxApiAccessToken: string,\n  mapboxApiUrl: string = DEFAULT_MAPBOX_API_URL\n): Record<string, any> {\n  const currentStyle = keplerState.mapStyle?.mapStyles?.[keplerState.mapStyle.styleType];\n  const accessToken = currentStyle?.accessToken || mapboxApiAccessToken;\n  const isMapbox = getBaseMapLibrary(currentStyle) === 'mapbox';\n  const isGlobe = Boolean(keplerState.mapState?.globe?.enabled);\n\n  const mapboxTransformRequest = (url: string, resourceType: string) => {\n    if (isMapboxURL(url)) {\n      return transformMapboxUrl(url, resourceType, accessToken);\n    }\n    return {url};\n  };\n\n  // In globe mode the deck.gl GlobeView renders the planet + basemap tiles as\n  // deck layers on a transparent canvas, so the flat maplibre base map must be\n  // suppressed (otherwise a 2D Mercator basemap would render behind the globe).\n  const bottomMapStyle = isGlobe\n    ? EMPTY_MAPBOX_STYLE\n    : isMapbox\n    ? convertMapboxStyleUrls(keplerState.mapStyle?.bottomMapStyle, accessToken)\n    : keplerState.mapStyle?.bottomMapStyle;\n\n  return {\n    ...keplerState.mapState,\n    preserveDrawingBuffer: true,\n    mapboxApiAccessToken: accessToken,\n    mapboxApiUrl,\n    transformRequest: mapboxTransformRequest,\n    mapStyle: bottomMapStyle,\n    onViewportChange: onViewChange,\n    mapLib: import('maplibre-gl')\n  };\n}\n\n/**\n * Convert mapbox:// URLs inside a Mapbox style object to HTTPS API URLs\n * so that maplibre-gl can fetch them directly.\n */\nfunction convertMapboxStyleUrls(style: any, accessToken: string): any {\n  if (!style || typeof style !== 'object') return style;\n\n  const converted = {...style};\n\n  if (typeof converted.sprite === 'string' && isMapboxURL(converted.sprite)) {\n    converted.sprite = transformMapboxUrl(converted.sprite, 'Sprite', accessToken)?.url;\n  }\n\n  if (typeof converted.glyphs === 'string' && isMapboxURL(converted.glyphs)) {\n    converted.glyphs = transformMapboxUrl(converted.glyphs, 'Glyphs', accessToken)?.url;\n  }\n\n  if (converted.sources) {\n    const newSources: Record<string, any> = {};\n    for (const [key, source] of Object.entries<any>(converted.sources)) {\n      if (source?.url && isMapboxURL(source.url)) {\n        newSources[key] = {\n          ...source,\n          url: transformMapboxUrl(source.url, 'Source', accessToken)?.url\n        };\n      } else {\n        newSources[key] = source;\n      }\n    }\n    converted.sources = newSources;\n  }\n\n  return converted;\n}\n\nfunction getHubbleParameters(keplerState: KeplerState): Record<string, any> {\n  return getLayerBlendingParameters(keplerState.visState.layerBlending);\n}\n\nexport function getHubbleDeckGlProps(\n  keplerState: KeplerState,\n  mapboxApiAccessToken: string,\n  mapboxApiUrl: string = DEFAULT_MAPBOX_API_URL\n): Record<string, any> {\n  const globe = keplerState.mapState?.globe;\n  const isGlobe = Boolean(globe?.enabled);\n\n  if (!isGlobe) {\n    return {\n      parameters: getHubbleParameters(keplerState),\n      controller: true,\n      views: new MapView({\n        id: 'mapbox',\n        farZMultiplier: 1.2\n      })\n    };\n  }\n\n  // Globe video export: mirror the interactive globe render path in map-container.\n  // - Use a GlobeView so the camera/projection curve data around the sphere.\n  // - Provide layers explicitly (globe base layers + kepler data layers + globe\n  //   top layers). When `deckProps.layers` is set, hubble's preview uses them\n  //   verbatim (skipping its internal 2D-only createKeplerLayers path), and the\n  //   kepler layers are built from `mapState.globe`, so composite layers (e.g.\n  //   the heatmap) emit their globe-conforming sublayers.\n  const globeBaseLayers = getGlobeBaseLayers({\n    mapboxApiAccessToken: mapboxApiAccessToken || '',\n    globe,\n    mapStyleType: keplerState.mapStyle?.styleType\n  });\n  const globeTopLayers = getGlobeTopLayers({globe});\n  const dataLayers = computeDeckLayers(keplerState, {\n    primaryMap: true,\n    mapboxApiAccessToken,\n    mapboxApiUrl\n  });\n\n  // hubble's video-export preview renders a bare <DeckGL> in the disableBaseMap\n  // (globe) branch and — unlike its mapbox branch — never forwards a viewState.\n  // With `controller: true` deck.gl then constructs a controller state from an\n  // empty view state, and GlobeState/MapState assert on the missing\n  // latitude/longitude/zoom (\"assertion failed at new MapState/GlobeState\").\n  // That degenerate viewport also leaves tile/MVT base layers permanently\n  // \"not loaded\", so hubble's `layers.every(l => l.isLoaded)` capture gate never\n  // fires and the export hangs. Provide an explicit initialViewState (deck.gl\n  // uses it to seed the controller when no controlled viewState is supplied) so\n  // the globe camera is valid, tiles resolve, and interaction works.\n  const {longitude, latitude, zoom, pitch, bearing} = keplerState.mapState || {};\n  const initialViewState = {\n    longitude,\n    latitude,\n    zoom,\n    pitch: pitch || 0,\n    bearing: bearing || 0,\n    minZoom: GLOBE_MIN_ZOOM,\n    maxZoom: GLOBE_MAX_ZOOM\n  };\n\n  return {\n    parameters: {\n      ...getHubbleParameters(keplerState),\n      cull: true\n    },\n    // Match the interactive globe controller bounds so panning/zoom feels the\n    // same in the preview as on the main map.\n    controller: {\n      minZoom: GLOBE_MIN_ZOOM,\n      maxZoom: GLOBE_MAX_ZOOM\n    },\n    initialViewState,\n    views: new KeplerGlobeView({\n      resolution: 5,\n      // clearColor:false (not a solid color) is deliberate and mirrors the\n      // interactive map: deck.gl applies a View's clearColor in EVERY pass\n      // including the picking pass, forcing alpha to 255. In the picking buffer\n      // the alpha byte encodes the layer index, so a solid clear makes deck.gl\n      // decode every pixel as a non-existent layer (\"Picked non-existent layer.\n      // Is picking buffer corrupt?\") whenever the controller picks on hover.\n      // Skipping the color clear keeps the picking buffer's 0 alpha intact; the\n      // sphere itself stays opaque via the globe-background SolidPolygonLayer.\n      clear: true,\n      clearColor: false\n    }),\n    layers: [...globeBaseLayers, ...dataLayers, ...globeTopLayers]\n  };\n}\n\n/**\n * Build a fresh set of globe layers (base + data + top) for a given split-map\n * index. Used by the swipe export preview, which mounts two independent Deck\n * instances: each side needs its OWN layer instances (deck.gl Layer objects are\n * stateful and bound to a single Deck) and its own `mapIndex` so the split-map\n * layer visibility is respected on each half of the swipe.\n */\nexport function getGlobeExportLayers(\n  keplerState: KeplerState,\n  {\n    mapIndex,\n    mapboxApiAccessToken,\n    mapboxApiUrl\n  }: {mapIndex: number; mapboxApiAccessToken?: string; mapboxApiUrl?: string}\n) {\n  const globe = keplerState.mapState?.globe;\n  const globeBaseLayers = getGlobeBaseLayers({\n    mapboxApiAccessToken: mapboxApiAccessToken || '',\n    globe,\n    mapStyleType: keplerState.mapStyle?.styleType\n  });\n  const globeTopLayers = getGlobeTopLayers({globe});\n  const dataLayers = computeDeckLayers(keplerState, {\n    mapIndex,\n    primaryMap: mapIndex === 0,\n    mapboxApiAccessToken,\n    mapboxApiUrl\n  });\n  return [...globeBaseLayers, ...dataLayers, ...globeTopLayers];\n}\n\nexport function getAnimatableFilters(keplerState: KeplerState): TimeRangeFilter[] {\n  const filters = keplerState.visState?.filters || [];\n  return filters.filter(\n    (f: any) =>\n      f.type === FILTER_TYPES.timeRange &&\n      (f.view === FILTER_VIEW_TYPES.enlarged || f.syncedWithLayerTimeline)\n  );\n}\n\n// --- Video export utilities (inlined from @hubble.gl internals) ---\n\nexport function scaleToVideoExport(\n  viewState: MapViewState,\n  container: {width: number; height: number}\n): MapViewState & {width: number; height: number} {\n  // In globe mode (and at extreme zooms) the WebMercatorViewport used below can\n  // produce a non-invertible projection matrix, making `unproject` throw. The\n  // Mercator fit-bounds rescaling only makes sense for the flat MapView anyway,\n  // so fall back to simply resizing the viewport to the export container.\n  try {\n    const viewport = new WebMercatorViewport(viewState);\n    const nw = viewport.unproject([0, 0]) as [number, number];\n    const se = viewport.unproject([viewport.width, viewport.height]) as [number, number];\n    const videoViewport = new WebMercatorViewport({\n      ...viewState,\n      width: container.width,\n      height: container.height\n    }).fitBounds([nw, se]);\n    const {height, width, latitude, longitude, zoom, altitude} = videoViewport;\n    return {\n      height,\n      width,\n      latitude,\n      longitude,\n      pitch: viewState.pitch,\n      zoom,\n      bearing: viewState.bearing,\n      altitude\n    } as any;\n  } catch (e) {\n    return {\n      ...viewState,\n      width: container.width,\n      height: container.height\n    } as any;\n  }\n}\n\nexport function parseSetCameraType(strCameraType: string, viewState: MapViewState): MapViewState {\n  const modifiedViewState: any = {...viewState};\n  const match = strCameraType.match(/\\b(?!to)\\b\\S+\\w/g);\n  if (!match) return modifiedViewState;\n\n  const turfPoint = point([modifiedViewState.longitude, modifiedViewState.latitude]);\n\n  if (match[0] === 'Orbit') {\n    modifiedViewState.bearing = modifiedViewState.bearing + parseInt(match[1], 10);\n  }\n\n  const directions = new Set(['East', 'South', 'West', 'North']);\n  if (directions.has(match[0])) {\n    const directionMap: Record<string, number> = {East: 270, South: 0, West: 90, North: 180};\n    const translatedPoly = transformTranslate(turfPoint, 10, directionMap[match[0]]);\n    if (match[0] === 'East' || match[0] === 'West') {\n      modifiedViewState.longitude = translatedPoly.geometry.coordinates[0];\n    } else {\n      modifiedViewState.latitude = translatedPoly.geometry.coordinates[1];\n    }\n  }\n\n  if (match[0] === 'Zoom') {\n    modifiedViewState.zoom += match[1] === 'In' ? 3 : -3;\n  }\n\n  return modifiedViewState;\n}\n\ntype Resolution = {value: string; label: string; width: number; height: number};\n\nconst RESOLUTIONS: Resolution[] = [\n  {value: '960x540', label: 'Good (540p)', width: 960, height: 540},\n  {value: '1280x720', label: 'High (720p)', width: 1280, height: 720},\n  {value: '1920x1080', label: 'Highest (1080p)', width: 1920, height: 1080},\n  {value: '640x480', label: 'Good (480p)', width: 640, height: 480},\n  {value: '1280x960', label: 'High (960p)', width: 1280, height: 960},\n  {value: '1920x1440', label: 'Highest (1440p)', width: 1920, height: 1440}\n];\n\nexport function getResolutionSetting(value: string): Resolution {\n  return RESOLUTIONS.find(r => r.value === value) || RESOLUTIONS[0];\n}\n"],"mappings":"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","ignoreList":[]}