@kepler.gl/components 3.3.0-alpha.1 → 3.3.0-alpha.10

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

@@ -0,0 +1,452 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof3 = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EXPORT_OVERLAY_DEVICE_PROPS = exports.EXPORT_DECK_DEVICE_PROPS = void 0;
+exports.getAnimatableFilters = getAnimatableFilters;
+exports.getBeforeLayerId = getBeforeLayerId;
+exports.getGlobeExportLayers = getGlobeExportLayers;
+exports.getHubbleDeckGlProps = getHubbleDeckGlProps;
+exports.getResolutionSetting = getResolutionSetting;
+exports.getStaticMapProps = getStaticMapProps;
+exports.getTimeRangeFilterKeyframes = getTimeRangeFilterKeyframes;
+exports.parseSetCameraType = parseSetCameraType;
+exports.scaleToVideoExport = scaleToVideoExport;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _core = require("@deck.gl/core");
+var _constants = require("@kepler.gl/constants");
+var _utils = require("@kepler.gl/utils");
+var _deckglLayers = require("@kepler.gl/deckgl-layers");
+var _reducers = require("@kepler.gl/reducers");
+var _maplibreglMapboxRequestTransformer = require("maplibregl-mapbox-request-transformer");
+var _helpers = require("@turf/helpers");
+var _transformTranslate = require("@turf/transform-translate");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof3(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+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) { (0, _defineProperty2["default"])(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
+// 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. */
+var EXPORT_DECK_DEVICE_PROPS = exports.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. */
+var EXPORT_OVERLAY_DEVICE_PROPS = exports.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
+  };
+}
+function getTimeRangeFilterKeyframes(_ref) {
+  var filter = _ref.filter,
+    timings = _ref.timings;
+  if (filter.type !== _constants.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
+        };
+      }
+  }
+}
+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;
+}
+function getStaticMapProps(keplerState, onViewChange, mapboxApiAccessToken) {
+  var _keplerState$mapStyle, _keplerState$mapState, _keplerState$mapStyle2, _keplerState$mapStyle3;
+  var mapboxApiUrl = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _constants.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 = (0, _utils.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 ((0, _maplibreglMapboxRequestTransformer.isMapboxURL)(url)) {
+      return (0, _maplibreglMapboxRequestTransformer.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 ? _constants.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: Promise.resolve().then(function () {
+      return _interopRequireWildcard(require('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 || (0, _typeof2["default"])(style) !== 'object') return style;
+  var converted = _objectSpread({}, style);
+  if (typeof converted.sprite === 'string' && (0, _maplibreglMapboxRequestTransformer.isMapboxURL)(converted.sprite)) {
+    var _transformMapboxUrl;
+    converted.sprite = (_transformMapboxUrl = (0, _maplibreglMapboxRequestTransformer.transformMapboxUrl)(converted.sprite, 'Sprite', accessToken)) === null || _transformMapboxUrl === void 0 ? void 0 : _transformMapboxUrl.url;
+  }
+  if (typeof converted.glyphs === 'string' && (0, _maplibreglMapboxRequestTransformer.isMapboxURL)(converted.glyphs)) {
+    var _transformMapboxUrl2;
+    converted.glyphs = (_transformMapboxUrl2 = (0, _maplibreglMapboxRequestTransformer.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 = (0, _slicedToArray2["default"])(_Object$entries[_i], 2),
+        key = _Object$entries$_i[0],
+        source = _Object$entries$_i[1];
+      if (source !== null && source !== void 0 && source.url && (0, _maplibreglMapboxRequestTransformer.isMapboxURL)(source.url)) {
+        var _transformMapboxUrl3;
+        newSources[key] = _objectSpread(_objectSpread({}, source), {}, {
+          url: (_transformMapboxUrl3 = (0, _maplibreglMapboxRequestTransformer.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 (0, _utils.getLayerBlendingParameters)(keplerState.visState.layerBlending);
+}
+function getHubbleDeckGlProps(keplerState, mapboxApiAccessToken) {
+  var _keplerState$mapState2, _keplerState$mapStyle4;
+  var mapboxApiUrl = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _constants.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 _core.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 = (0, _deckglLayers.getGlobeBaseLayers)({
+    mapboxApiAccessToken: mapboxApiAccessToken || '',
+    globe: globe,
+    mapStyleType: (_keplerState$mapStyle4 = keplerState.mapStyle) === null || _keplerState$mapStyle4 === void 0 ? void 0 : _keplerState$mapStyle4.styleType
+  });
+  var globeTopLayers = (0, _deckglLayers.getGlobeTopLayers)({
+    globe: globe
+  });
+  var dataLayers = (0, _reducers.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: _constants.GLOBE_MIN_ZOOM,
+    maxZoom: _constants.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: _constants.GLOBE_MIN_ZOOM,
+      maxZoom: _constants.GLOBE_MAX_ZOOM
+    },
+    initialViewState: initialViewState,
+    views: new _deckglLayers.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((0, _toConsumableArray2["default"])(globeBaseLayers), (0, _toConsumableArray2["default"])(dataLayers), (0, _toConsumableArray2["default"])(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.
+ */
+function getGlobeExportLayers(keplerState, _ref3) {
+  var _keplerState$mapState3, _keplerState$mapStyle5;
+  var mapIndex = _ref3.mapIndex,
+    mapboxApiAccessToken = _ref3.mapboxApiAccessToken,
+    mapboxApiUrl = _ref3.mapboxApiUrl,
+    viewState = _ref3.viewState;
+  var globe = (_keplerState$mapState3 = keplerState.mapState) === null || _keplerState$mapState3 === void 0 ? void 0 : _keplerState$mapState3.globe;
+  var globeBaseLayers = (0, _deckglLayers.getGlobeBaseLayers)({
+    mapboxApiAccessToken: mapboxApiAccessToken || '',
+    globe: globe,
+    mapStyleType: (_keplerState$mapStyle5 = keplerState.mapStyle) === null || _keplerState$mapStyle5 === void 0 ? void 0 : _keplerState$mapStyle5.styleType
+  });
+  var globeTopLayers = (0, _deckglLayers.getGlobeTopLayers)({
+    globe: globe
+  });
+  // Same as hubble createKeplerLayers: fold the animated camera into mapState so
+  // zoom-dependent props (scatterplot radiusScale) update each frame.
+  var dataLayers = (0, _reducers.computeDeckLayers)(viewState ? _objectSpread(_objectSpread({}, keplerState), {}, {
+    mapState: _objectSpread(_objectSpread({}, keplerState.mapState), viewState)
+  }) : keplerState, {
+    mapIndex: mapIndex,
+    primaryMap: mapIndex === 0,
+    mapboxApiAccessToken: mapboxApiAccessToken,
+    mapboxApiUrl: mapboxApiUrl
+  });
+  return [].concat((0, _toConsumableArray2["default"])(globeBaseLayers), (0, _toConsumableArray2["default"])(dataLayers), (0, _toConsumableArray2["default"])(globeTopLayers));
+}
+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 === _constants.FILTER_TYPES.timeRange && (f.view === _constants.FILTER_VIEW_TYPES.enlarged || f.syncedWithLayerTimeline);
+  });
+}
+
+// --- Video export utilities (inlined from @hubble.gl internals) ---
+
+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 _core.WebMercatorViewport(viewState);
+    var nw = viewport.unproject([0, 0]);
+    var se = viewport.unproject([viewport.width, viewport.height]);
+    var videoViewport = new _core.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
+    });
+  }
+}
+function parseSetCameraType(strCameraType, viewState) {
+  var modifiedViewState = _objectSpread({}, viewState);
+  var match = strCameraType.match(/\b(?!to)\b\S+\w/g);
+  if (!match) return modifiedViewState;
+  var turfPoint = (0, _helpers.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 = (0, _transformTranslate.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
+}];
+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":["_core","require","_constants","_utils","_deckglLayers","_reducers","_maplibreglMapboxRequestTransformer","_helpers","_transformTranslate","_interopRequireWildcard","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","_typeof3","has","get","set","_t","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","ownKeys","keys","getOwnPropertySymbols","filter","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","EXPORT_DECK_DEVICE_PROPS","exports","type","webgl","preserveDrawingBuffer","debug","EXPORT_OVERLAY_DEVICE_PROPS","stencil","linear","p","hold","getKeyFramesFree","delta","value","keyframes","domain","easings","getTimeRangeFilterKeyframes","_ref","timings","FILTER_TYPES","timeRange","Error","duration","animationWindow","_timeBins$dataId$","plotType","timeBins","dataId","interval","bins","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","undefined","DEFAULT_MAPBOX_API_URL","currentStyle","mapStyle","mapStyles","styleType","accessToken","isMapbox","getBaseMapLibrary","isGlobe","Boolean","mapState","globe","enabled","mapboxTransformRequest","url","resourceType","isMapboxURL","transformMapboxUrl","EMPTY_MAPBOX_STYLE","convertMapboxStyleUrls","transformRequest","onViewportChange","mapLib","Promise","resolve","then","style","_typeof2","converted","sprite","_transformMapboxUrl","glyphs","_transformMapboxUrl2","sources","newSources","_i","_Object$entries","entries","_Object$entries$_i","_slicedToArray2","key","source","_transformMapboxUrl3","getHubbleParameters","getLayerBlendingParameters","visState","layerBlending","getHubbleDeckGlProps","_keplerState$mapState2","_keplerState$mapStyle4","parameters","controller","views","MapView","farZMultiplier","globeBaseLayers","getGlobeBaseLayers","mapStyleType","globeTopLayers","getGlobeTopLayers","dataLayers","computeDeckLayers","primaryMap","_ref2","longitude","latitude","zoom","pitch","bearing","initialViewState","minZoom","GLOBE_MIN_ZOOM","maxZoom","GLOBE_MAX_ZOOM","cull","KeplerGlobeView","resolution","clear","clearColor","concat","_toConsumableArray2","getGlobeExportLayers","_ref3","_keplerState$mapState3","_keplerState$mapStyle5","mapIndex","viewState","getAnimatableFilters","_keplerState$visState","filters","view","FILTER_VIEW_TYPES","enlarged","syncedWithLayerTimeline","scaleToVideoExport","container","viewport","WebMercatorViewport","nw","unproject","se","width","height","videoViewport","fitBounds","altitude","parseSetCameraType","strCameraType","modifiedViewState","match","turfPoint","point","parseInt","directions","Set","directionMap","East","South","West","North","translatedPoly","transformTranslate","geometry","coordinates","RESOLUTIONS","label","getResolutionSetting","find"],"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    viewState\n  }: {\n    mapIndex: number;\n    mapboxApiAccessToken?: string;\n    mapboxApiUrl?: string;\n    viewState?: MapViewState;\n  }\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  // Same as hubble createKeplerLayers: fold the animated camera into mapState so\n  // zoom-dependent props (scatterplot radiusScale) update each frame.\n  const dataLayers = computeDeckLayers(\n    viewState\n      ? {...keplerState, mapState: {...keplerState.mapState, ...viewState}}\n      : keplerState,\n    {\n      mapIndex,\n      primaryMap: mapIndex === 0,\n      mapboxApiAccessToken,\n      mapboxApiUrl\n    }\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":[]}