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

package/dist/esm/modals/globe-export-video-container.js

@@ -0,0 +1,636 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { Component, createRef } from 'react';
+import { easeInOut } from 'popmotion';
+import download from 'downloadjs';
+import styled from 'styled-components';
+import { Button } from '../common';
+import { DeckAdapter, KeplerAnimation, WebMEncoder, JPEGSequenceEncoder, PNGSequenceEncoder, GifEncoder } from '@hubble.gl/core';
+import { FILTER_VIEW_TYPES } from '@kepler.gl/constants';
+import { parseSetCameraType, scaleToVideoExport, getResolutionSetting } from './hubble-utils';
+import { GlobeExportVideoPreview } from './globe-export-video-preview';
+import SwipeExportSettings from './swipe-export-settings';
+import { drawStarsBackground, getGlobeClearColor, getStarsBackgroundImage } from '@kepler.gl/deckgl-layers';
+
+// No-op for the swipe-specific settings callbacks that this single-map globe
+// exporter doesn't use (the swipe controls are hidden via `hideSwipe`).
+var noop = function noop() {
+  return undefined;
+};
+var ENCODERS = {
+  gif: GifEncoder,
+  webm: WebMEncoder,
+  jpeg: JPEGSequenceEncoder,
+  png: PNGSequenceEncoder
+};
+var PanelBody = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: grid;\n  grid-template-columns: ", "px 280px;\n  grid-template-rows: auto;\n  grid-column-gap: 24px;\n"])), function (props) {
+  return props.$exportVideoWidth;
+});
+var TimelineControls = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  position: relative;\n  display: flex;\n  justify-content: center;\n  padding-top: 16px;\n"])));
+var timelinePlayButtonStyle = {
+  cursor: 'pointer',
+  height: '32px',
+  width: '32px',
+  fill: '#FFF'
+};
+var ButtonGroup = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  display: flex;\n"])));
+var StatusText = styled.div(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  font-size: 11px;\n  color: ", ";\n  text-align: center;\n  margin-top: 4px;\n"])), function (props) {
+  return props.theme.subtextColorLT || '#6A7485';
+});
+var PlayIcon = function PlayIcon(_ref) {
+  var style = _ref.style,
+    onClick = _ref.onClick;
+  return /*#__PURE__*/React.createElement("svg", {
+    className: "data-ex-icons-play",
+    viewBox: "0 0 24 24",
+    style: style,
+    onClick: onClick
+  }, /*#__PURE__*/React.createElement("path", {
+    fill: "none",
+    d: "M0 0h24v24H0z"
+  }), /*#__PURE__*/React.createElement("path", {
+    d: "M19.376 12.416L8.777 19.482A.5.5 0 0 1 8 19.066V4.934a.5.5 0 0 1 .777-.416l10.599 7.066a.5.5 0 0 1 0 .832z"
+  }));
+};
+var StopIcon = function StopIcon(_ref2) {
+  var style = _ref2.style,
+    onClick = _ref2.onClick;
+  return /*#__PURE__*/React.createElement("svg", {
+    className: "data-ex-icons-stop",
+    viewBox: "0 0 24 24",
+    style: style,
+    onClick: onClick
+  }, /*#__PURE__*/React.createElement("path", {
+    fill: "none",
+    d: "M0 0h24v24H0z"
+  }), /*#__PURE__*/React.createElement("path", {
+    d: "M6 5h12a1 1 0 0 1 1 1v12a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1V6a1 1 0 0 1 1-1z"
+  }));
+};
+
+/**
+ * Video export container for globe mode.
+ *
+ * hubble's built-in ExportVideoPanelContainer only drives its frame-capture
+ * loop from the mapbox base map's 'render' event; in globe mode the base map is
+ * disabled so that loop never fires and the export hangs. This container mirrors
+ * the swipe-export approach: it owns a requestAnimationFrame capture loop and
+ * reads the globe deck canvas directly, so recording works without a base map.
+ */
+export var GlobeExportVideoPanelContainer = /*#__PURE__*/function (_Component) {
+  function GlobeExportVideoPanelContainer(props) {
+    var _this;
+    _classCallCheck(this, GlobeExportVideoPanelContainer);
+    _this = _callSuper(this, GlobeExportVideoPanelContainer, [props]);
+    _defineProperty(_this, "previewRef", /*#__PURE__*/createRef());
+    _defineProperty(_this, "animationFrameId", null);
+    _defineProperty(_this, "activeEncoder", null);
+    // Reused across all captured frames to avoid allocating a full-resolution
+    // canvas per frame (GC pressure/jank during a multi-second export).
+    _defineProperty(_this, "compositeCanvas", null);
+    _defineProperty(_this, "setViewState", function (viewState) {
+      _this.setState({
+        viewState: viewState
+      });
+    });
+    _defineProperty(_this, "setMediaType", function (mediaType) {
+      return _this.setStateAndNotify({
+        mediaType: mediaType
+      });
+    });
+    _defineProperty(_this, "setCameraPreset", function (cameraPreset) {
+      return _this.setStateAndNotify({
+        cameraPreset: cameraPreset
+      });
+    });
+    _defineProperty(_this, "setFileName", function (fileName) {
+      return _this.setStateAndNotify({
+        fileName: fileName
+      });
+    });
+    _defineProperty(_this, "setResolution", function (resolution) {
+      return _this.setStateAndNotify({
+        resolution: resolution
+      });
+    });
+    _defineProperty(_this, "setDuration", function (durationMs) {
+      return _this.setStateAndNotify({
+        durationMs: durationMs
+      });
+    });
+    /** Preview playback — animate the camera without encoding. */
+    _defineProperty(_this, "onPreviewVideo", function () {
+      var _this$state = _this.state,
+        adapter = _this$state.adapter,
+        durationMs = _this$state.durationMs;
+      _this.setState({
+        previewing: true,
+        currentTimeMs: 0,
+        memo: {
+          viewState: _objectSpread({}, _this.state.viewState)
+        }
+      });
+      adapter.animationManager.setKeyframes('kepler', _objectSpread(_objectSpread(_objectSpread({}, _this.getFilterKeyframes()), _this.getTripKeyframes()), {}, {
+        cameraKeyframe: _this.getCameraKeyframes()
+      }));
+      var startTime = performance.now();
+      var _animate = function animate() {
+        var elapsed = performance.now() - startTime;
+        var currentTimeMs = Math.min(elapsed, durationMs);
+        adapter.animationManager.timeline.setTime(currentTimeMs);
+        adapter.animationManager.draw();
+        _this.setState({
+          currentTimeMs: currentTimeMs
+        });
+        if (currentTimeMs >= durationMs) {
+          _this.setState({
+            previewing: false,
+            currentTimeMs: 0,
+            viewState: _objectSpread({}, _this.state.memo.viewState)
+          });
+          return;
+        }
+        _this.animationFrameId = requestAnimationFrame(_animate);
+      };
+      _this.animationFrameId = requestAnimationFrame(_animate);
+    });
+    /**
+     * Record — drive our own capture loop (hubble's built-in loop never fires
+     * without a base map) and encode the globe deck canvas frame by frame.
+     */
+    _defineProperty(_this, "onRenderVideo", function () {
+      var adapter = _this.state.adapter;
+      var filename = _this.getFileName();
+      var Encoder = _this.getEncoder();
+      var formatConfigs = _this.getFormatConfigs();
+      var timecode = _this.getTimecode();
+      var _this$getCanvasSize = _this.getCanvasSize(),
+        width = _this$getCanvasSize.width,
+        height = _this$getCanvasSize.height;
+      _this.setState({
+        rendering: true,
+        saving: false,
+        currentTimeMs: 0,
+        memo: {
+          viewState: _objectSpread({}, _this.state.viewState)
+        }
+      });
+      adapter.animationManager.setKeyframes('kepler', _objectSpread(_objectSpread(_objectSpread({}, _this.getFilterKeyframes()), _this.getTripKeyframes()), {}, {
+        cameraKeyframe: _this.getCameraKeyframes()
+      }));
+      var encoder = new Encoder(_objectSpread(_objectSpread({}, formatConfigs), {}, {
+        framerate: timecode.framerate
+      }));
+      _this.activeEncoder = encoder;
+      encoder.start();
+      var frameLengthMs = Math.floor(1000 / timecode.framerate);
+      var timeMs = timecode.start;
+      var retryCount = 0;
+      var MAX_RETRIES = 60;
+      var _captureNextFrame = function captureNextFrame() {
+        if (!_this.state.rendering || _this.activeEncoder !== encoder) return;
+        adapter.animationManager.timeline.setTime(timeMs);
+        adapter.animationManager.draw();
+        _this.setState({
+          currentTimeMs: timeMs
+        });
+
+        // Allow state update → preview re-render → deck redraw before capturing.
+        var _waitAndCapture = function waitAndCapture() {
+          requestAnimationFrame(function () {
+            if (_this.activeEncoder !== encoder) return;
+            requestAnimationFrame(function () {
+              if (_this.activeEncoder !== encoder) return;
+              var preview = _this.previewRef.current;
+              if (!preview) return;
+
+              // Wait for globe base/data layers (tiles included) to finish before
+              // the first frame so we don't record a half-loaded planet.
+              if (!preview.areLayersLoaded() && retryCount < MAX_RETRIES) {
+                retryCount++;
+                requestAnimationFrame(_waitAndCapture);
+                return;
+              }
+              retryCount = 0;
+              var deckCanvas = preview.getCanvas();
+              if (!deckCanvas) return;
+
+              // Reuse a single offscreen canvas across frames (resized only when
+              // the output dimensions change) instead of allocating one per frame.
+              var offscreen = _this.compositeCanvas;
+              if (!offscreen) {
+                offscreen = document.createElement('canvas');
+                _this.compositeCanvas = offscreen;
+              }
+              if (offscreen.width !== width || offscreen.height !== height) {
+                offscreen.width = width;
+                offscreen.height = height;
+              }
+              var offCtx = offscreen.getContext('2d');
+              if (offCtx) {
+                // deck's canvas is transparent where the globe isn't drawn
+                // (clearColor is disabled to keep picking intact), so fill the
+                // configured background first, tile the starfield (the live map
+                // paints stars as a CSS background, which canvas capture misses),
+                // then composite the deck frame.
+                offCtx.fillStyle = _this.getBackgroundColor();
+                offCtx.fillRect(0, 0, width, height);
+                if (_this.areStarsEnabled()) {
+                  drawStarsBackground(offCtx, width, height);
+                }
+                offCtx.drawImage(deckCanvas, 0, 0, width, height);
+              }
+              encoder.add(offscreen).then(function () {
+                if (_this.activeEncoder !== encoder) return;
+                timeMs += frameLengthMs;
+                if (timeMs > timecode.end) {
+                  _this.setState({
+                    saving: true
+                  });
+                  encoder.save().then(function (blob) {
+                    if (_this.activeEncoder !== encoder) return;
+                    if (blob) {
+                      download(blob, filename + encoder.extension, encoder.mimeType);
+                    }
+                    _this.setState({
+                      rendering: false,
+                      saving: false,
+                      currentTimeMs: 0,
+                      viewState: _objectSpread({}, _this.state.memo.viewState)
+                    });
+                  });
+                } else {
+                  _captureNextFrame();
+                }
+              });
+            });
+          });
+        };
+        _waitAndCapture();
+      };
+
+      // Give the deck a moment to mount/draw before the first capture.
+      setTimeout(function () {
+        return _captureNextFrame();
+      }, 500);
+    });
+    _defineProperty(_this, "onStop", function () {
+      var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        _ref3$abort = _ref3.abort,
+        abort = _ref3$abort === void 0 ? false : _ref3$abort;
+      if (_this.animationFrameId) {
+        cancelAnimationFrame(_this.animationFrameId);
+        _this.animationFrameId = null;
+      }
+      _this.activeEncoder = null;
+      if (!abort) {
+        var _this$state$memo;
+        _this.setState({
+          rendering: false,
+          previewing: false,
+          currentTimeMs: 0,
+          viewState: ((_this$state$memo = _this.state.memo) === null || _this$state$memo === void 0 ? void 0 : _this$state$memo.viewState) || _this.state.viewState
+        });
+      }
+    });
+    var initialState = props.initialState,
+      mapState = props.mapData.mapState,
+      glContext = props.glContext;
+    _this.state = _objectSpread({
+      mediaType: 'webm',
+      cameraPreset: 'None',
+      fileName: '',
+      resolution: '1280x720',
+      durationMs: 1000,
+      rendering: false,
+      previewing: false,
+      saving: false,
+      currentTimeMs: 0
+    }, initialState || {});
+    var _viewState = scaleToVideoExport(mapState, _this._getContainer());
+    _this.state = _objectSpread(_objectSpread({}, _this.state), {}, {
+      viewState: _viewState,
+      memo: {
+        viewState: _viewState
+      },
+      adapter: new DeckAdapter({
+        glContext: glContext
+      })
+    });
+    return _this;
+  }
+  _inherits(GlobeExportVideoPanelContainer, _Component);
+  return _createClass(GlobeExportVideoPanelContainer, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var _this$props = this.props,
+        onTripFrameUpdate = _this$props.onTripFrameUpdate,
+        onFilterFrameUpdate = _this$props.onFilterFrameUpdate,
+        getTimeRangeFilterKeyframes = _this$props.getTimeRangeFilterKeyframes;
+      var animation = new KeplerAnimation(_objectSpread(_objectSpread(_objectSpread({}, this.getFilterKeyframes()), this.getTripKeyframes()), {}, {
+        cameraKeyframe: this.getCameraKeyframes(),
+        onCameraFrameUpdate: this.setViewState,
+        onTripFrameUpdate: onTripFrameUpdate,
+        onFilterFrameUpdate: onFilterFrameUpdate,
+        getTimeRangeFilterKeyframes: getTimeRangeFilterKeyframes
+      }));
+      this.state.adapter.animationManager.attachAnimation(animation);
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.onStop({
+        abort: true
+      });
+      if (this.animationFrameId) {
+        cancelAnimationFrame(this.animationFrameId);
+      }
+    }
+  }, {
+    key: "getFileName",
+    value: function getFileName() {
+      var defaultFileName = this.props.defaultFileName;
+      var fileName = this.state.fileName;
+      return fileName || defaultFileName;
+    }
+  }, {
+    key: "getCanvasSize",
+    value: function getCanvasSize() {
+      var resolution = this.state.resolution;
+      var _getResolutionSetting = getResolutionSetting(resolution),
+        width = _getResolutionSetting.width,
+        height = _getResolutionSetting.height;
+      return {
+        width: width,
+        height: height
+      };
+    }
+  }, {
+    key: "_getContainer",
+    value: function _getContainer() {
+      var _this$getCanvasSize2 = this.getCanvasSize(),
+        width = _this$getCanvasSize2.width,
+        height = _this$getCanvasSize2.height;
+      var exportVideoWidth = this.props.exportVideoWidth;
+      var aspectRatio = width / height;
+      return {
+        height: exportVideoWidth / aspectRatio,
+        width: exportVideoWidth
+      };
+    }
+  }, {
+    key: "getFormatConfigs",
+    value: function getFormatConfigs() {
+      var _this$getCanvasSize3 = this.getCanvasSize(),
+        width = _this$getCanvasSize3.width,
+        height = _this$getCanvasSize3.height;
+      return {
+        webm: {
+          quality: 0.8
+        },
+        jpeg: {
+          quality: 0.8
+        },
+        png: {},
+        gif: {
+          sampleInterval: 1000,
+          width: width,
+          height: height
+        }
+      };
+    }
+  }, {
+    key: "getTimecode",
+    value: function getTimecode() {
+      var durationMs = this.state.durationMs;
+      return {
+        start: 0,
+        end: durationMs,
+        framerate: 30
+      };
+    }
+  }, {
+    key: "getEncoder",
+    value: function getEncoder() {
+      var mediaType = this.state.mediaType;
+      return ENCODERS[mediaType];
+    }
+  }, {
+    key: "getCameraKeyframes",
+    value: function getCameraKeyframes() {
+      var _this$state2 = this.state,
+        viewState = _this$state2.viewState,
+        cameraPreset = _this$state2.cameraPreset,
+        durationMs = _this$state2.durationMs;
+      var _ref4 = viewState,
+        longitude = _ref4.longitude,
+        latitude = _ref4.latitude,
+        zoom = _ref4.zoom,
+        pitch = _ref4.pitch,
+        bearing = _ref4.bearing;
+      var _this$getCanvasSize4 = this.getCanvasSize(),
+        width = _this$getCanvasSize4.width,
+        height = _this$getCanvasSize4.height;
+      return {
+        timings: [0, durationMs],
+        keyframes: [{
+          longitude: longitude,
+          latitude: latitude,
+          zoom: zoom,
+          pitch: pitch,
+          bearing: bearing
+        }, parseSetCameraType(cameraPreset, viewState)],
+        easings: [easeInOut],
+        width: width,
+        height: height
+      };
+    }
+  }, {
+    key: "getFilterKeyframes",
+    value: function getFilterKeyframes() {
+      var _this2 = this;
+      var _this$props2 = this.props,
+        filters = _this$props2.mapData.visState.filters,
+        animatableFilters = _this$props2.animatableFilters;
+      var filterKeyframes = (Array.isArray(animatableFilters) && animatableFilters.length ? animatableFilters : filters.filter(function (f) {
+        return f.type === 'timeRange' && f.view === FILTER_VIEW_TYPES.enlarged;
+      })).map(function (f) {
+        return {
+          id: f.id,
+          timings: [0, _this2.state.durationMs]
+        };
+      });
+      if (filterKeyframes.length) {
+        return {
+          filters: filters,
+          filterKeyframes: filterKeyframes
+        };
+      }
+      return {};
+    }
+  }, {
+    key: "getTripKeyframes",
+    value: function getTripKeyframes() {
+      var _this$props$mapData$v = this.props.mapData.visState,
+        layers = _this$props$mapData$v.layers,
+        animationConfig = _this$props$mapData$v.animationConfig;
+      var animatableLayer = layers.filter(function (l) {
+        return l.config.animation && l.config.animation.enabled && l.config.isVisible;
+      });
+      var readyToAnimation = Array.isArray(animationConfig.domain) && Number.isFinite(animationConfig.currentTime);
+      if (animatableLayer.length && readyToAnimation) {
+        return {
+          animationConfig: animationConfig,
+          tripKeyframe: {
+            timings: [0, this.state.durationMs]
+          }
+        };
+      }
+      return {};
+    }
+  }, {
+    key: "getBackgroundColor",
+    value: /** CSS background color (area the globe doesn't cover), from globe config. */
+    function getBackgroundColor() {
+      var _this$props$mapData;
+      var bg = (_this$props$mapData = this.props.mapData) === null || _this$props$mapData === void 0 || (_this$props$mapData = _this$props$mapData.mapState) === null || _this$props$mapData === void 0 || (_this$props$mapData = _this$props$mapData.globe) === null || _this$props$mapData === void 0 || (_this$props$mapData = _this$props$mapData.config) === null || _this$props$mapData === void 0 ? void 0 : _this$props$mapData.backgroundColor;
+      var _getGlobeClearColor = getGlobeClearColor(bg),
+        _getGlobeClearColor2 = _slicedToArray(_getGlobeClearColor, 3),
+        r = _getGlobeClearColor2[0],
+        g = _getGlobeClearColor2[1],
+        b = _getGlobeClearColor2[2];
+      return "rgb(".concat(r, ", ").concat(g, ", ").concat(b, ")");
+    }
+
+    /** Starfield behind the globe, matching the live map's CSS background. */
+  }, {
+    key: "areStarsEnabled",
+    value: function areStarsEnabled() {
+      var _this$props$mapData2, _globe$config;
+      var globe = (_this$props$mapData2 = this.props.mapData) === null || _this$props$mapData2 === void 0 || (_this$props$mapData2 = _this$props$mapData2.mapState) === null || _this$props$mapData2 === void 0 ? void 0 : _this$props$mapData2.globe;
+      return Boolean((globe === null || globe === void 0 ? void 0 : globe.enabled) && (globe === null || globe === void 0 || (_globe$config = globe.config) === null || _globe$config === void 0 ? void 0 : _globe$config.stars));
+    }
+  }, {
+    key: "setStateAndNotify",
+    value: function setStateAndNotify(update) {
+      var onSettingsChange = this.props.onSettingsChange;
+      var _this$state3 = this.state,
+        mediaType = _this$state3.mediaType,
+        cameraPreset = _this$state3.cameraPreset,
+        fileName = _this$state3.fileName,
+        resolution = _this$state3.resolution,
+        durationMs = _this$state3.durationMs;
+      this.setState(_objectSpread(_objectSpread({}, this.state), update));
+      if (onSettingsChange) {
+        onSettingsChange(_objectSpread({
+          mediaType: mediaType,
+          cameraPreset: cameraPreset,
+          fileName: fileName,
+          resolution: resolution,
+          durationMs: durationMs
+        }, update));
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this3 = this;
+      var _this$props3 = this.props,
+        exportVideoWidth = _this$props3.exportVideoWidth,
+        mapData = _this$props3.mapData,
+        deckProps = _this$props3.deckProps;
+      var _this$state4 = this.state,
+        adapter = _this$state4.adapter,
+        durationMs = _this$state4.durationMs,
+        mediaType = _this$state4.mediaType,
+        cameraPreset = _this$state4.cameraPreset,
+        fileName = _this$state4.fileName,
+        resolution = _this$state4.resolution,
+        viewState = _this$state4.viewState,
+        rendering = _this$state4.rendering,
+        previewing = _this$state4.previewing,
+        saving = _this$state4.saving,
+        currentTimeMs = _this$state4.currentTimeMs;
+      var timecode = this.getTimecode();
+      var canvasSize = this.getCanvasSize();
+      if (previewing) {
+        canvasSize = this._getContainer();
+      }
+      var isActive = rendering || previewing;
+      return /*#__PURE__*/React.createElement("div", {
+        className: "export-video-panel"
+      }, /*#__PURE__*/React.createElement(PanelBody, {
+        $exportVideoWidth: exportVideoWidth
+      }, /*#__PURE__*/React.createElement(GlobeExportVideoPreview, {
+        ref: this.previewRef,
+        mapData: mapData,
+        adapter: adapter,
+        setViewState: this.setViewState,
+        exportVideoWidth: exportVideoWidth,
+        resolution: [canvasSize.width, canvasSize.height],
+        viewState: viewState,
+        rendering: rendering,
+        saving: saving,
+        durationMs: durationMs,
+        deckProps: deckProps,
+        mapProps: this.props.mapProps,
+        backgroundColor: this.getBackgroundColor(),
+        starsImage: this.areStarsEnabled() ? getStarsBackgroundImage() : null
+      }), /*#__PURE__*/React.createElement(SwipeExportSettings, {
+        durationMs: durationMs,
+        mediaType: mediaType,
+        resolution: resolution,
+        fileName: fileName,
+        cameraPreset: cameraPreset,
+        frameRate: timecode.framerate,
+        onChangeDuration: this.setDuration,
+        onChangeMediaType: this.setMediaType,
+        onChangeResolution: this.setResolution,
+        onChangeFileName: this.setFileName,
+        onChangeCameraPreset: this.setCameraPreset,
+        swipeStartPct: 0,
+        swipeEndPct: 100,
+        swipeEasing: 'ease-in-out',
+        disabled: isActive,
+        onChangeStartPct: noop,
+        onChangeEndPct: noop,
+        onChangeEasing: noop,
+        hideSwipe: true
+      }), /*#__PURE__*/React.createElement(TimelineControls, {
+        className: "timeline-controls"
+      }, isActive ? /*#__PURE__*/React.createElement(StopIcon, {
+        style: timelinePlayButtonStyle,
+        onClick: function onClick() {
+          return _this3.onStop({});
+        }
+      }) : /*#__PURE__*/React.createElement(PlayIcon, {
+        style: timelinePlayButtonStyle,
+        onClick: this.onPreviewVideo
+      })), saving && /*#__PURE__*/React.createElement(StatusText, null, "Saving..."), rendering && !saving && /*#__PURE__*/React.createElement(StatusText, null, "Rendering... ", Math.round(currentTimeMs / durationMs * 100), "%"), /*#__PURE__*/React.createElement(ButtonGroup, null, /*#__PURE__*/React.createElement(Button, {
+        style: {
+          marginTop: '16px',
+          width: '100%',
+          height: '32px'
+        },
+        className: "export-video-button",
+        onClick: this.onRenderVideo,
+        disabled: isActive
+      }, "Render"))));
+    }
+  }]);
+}(Component);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Component","createRef","easeInOut","download","styled","Button","DeckAdapter","KeplerAnimation","WebMEncoder","JPEGSequenceEncoder","PNGSequenceEncoder","GifEncoder","FILTER_VIEW_TYPES","parseSetCameraType","scaleToVideoExport","getResolutionSetting","GlobeExportVideoPreview","SwipeExportSettings","drawStarsBackground","getGlobeClearColor","getStarsBackgroundImage","noop","undefined","ENCODERS","gif","webm","jpeg","png","PanelBody","div","_templateObject","_taggedTemplateLiteral","props","$exportVideoWidth","TimelineControls","_templateObject2","timelinePlayButtonStyle","cursor","height","width","fill","ButtonGroup","_templateObject3","StatusText","_templateObject4","theme","subtextColorLT","PlayIcon","_ref","style","onClick","createElement","className","viewBox","d","StopIcon","_ref2","GlobeExportVideoPanelContainer","_Component","_this","_classCallCheck","_callSuper","_defineProperty","viewState","setState","mediaType","setStateAndNotify","cameraPreset","fileName","resolution","durationMs","_this$state","state","adapter","previewing","currentTimeMs","memo","_objectSpread","animationManager","setKeyframes","getFilterKeyframes","getTripKeyframes","cameraKeyframe","getCameraKeyframes","startTime","performance","now","animate","elapsed","Math","min","timeline","setTime","draw","animationFrameId","requestAnimationFrame","filename","getFileName","Encoder","getEncoder","formatConfigs","getFormatConfigs","timecode","getTimecode","_this$getCanvasSize","getCanvasSize","rendering","saving","encoder","framerate","activeEncoder","start","frameLengthMs","floor","timeMs","retryCount","MAX_RETRIES","captureNextFrame","waitAndCapture","preview","previewRef","current","areLayersLoaded","deckCanvas","getCanvas","offscreen","compositeCanvas","document","offCtx","getContext","fillStyle","getBackgroundColor","fillRect","areStarsEnabled","drawImage","add","then","end","save","blob","extension","mimeType","setTimeout","_ref3","arguments","length","_ref3$abort","abort","cancelAnimationFrame","_this$state$memo","initialState","mapState","mapData","glContext","_getContainer","_inherits","_createClass","key","value","componentDidMount","_this$props","onTripFrameUpdate","onFilterFrameUpdate","getTimeRangeFilterKeyframes","animation","onCameraFrameUpdate","setViewState","attachAnimation","componentWillUnmount","onStop","defaultFileName","_getResolutionSetting","_this$getCanvasSize2","exportVideoWidth","aspectRatio","_this$getCanvasSize3","quality","sampleInterval","_this$state2","_ref4","longitude","latitude","zoom","pitch","bearing","_this$getCanvasSize4","timings","keyframes","easings","_this2","_this$props2","filters","visState","animatableFilters","filterKeyframes","Array","isArray","filter","f","type","view","enlarged","map","id","_this$props$mapData$v","layers","animationConfig","animatableLayer","l","config","enabled","isVisible","readyToAnimation","domain","Number","isFinite","currentTime","tripKeyframe","_this$props$mapData","bg","globe","backgroundColor","_getGlobeClearColor","_getGlobeClearColor2","_slicedToArray","r","g","b","concat","_this$props$mapData2","_globe$config","Boolean","stars","update","onSettingsChange","_this$state3","render","_this3","_this$props3","deckProps","_this$state4","canvasSize","isActive","ref","mapProps","starsImage","frameRate","onChangeDuration","setDuration","onChangeMediaType","setMediaType","onChangeResolution","setResolution","onChangeFileName","setFileName","onChangeCameraPreset","setCameraPreset","swipeStartPct","swipeEndPct","swipeEasing","disabled","onChangeStartPct","onChangeEndPct","onChangeEasing","hideSwipe","onPreviewVideo","round","marginTop","onRenderVideo"],"sources":["../../../src/modals/globe-export-video-container.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {Component, createRef} from 'react';\nimport {easeInOut} from 'popmotion';\nimport download from 'downloadjs';\nimport styled from 'styled-components';\nimport {Button} from '../common';\nimport {\n  DeckAdapter,\n  KeplerAnimation,\n  WebMEncoder,\n  JPEGSequenceEncoder,\n  PNGSequenceEncoder,\n  GifEncoder,\n  FormatConfigs,\n  Timecode\n} from '@hubble.gl/core';\nimport type {DeckProps, MapViewState} from '@deck.gl/core';\nimport {FILTER_VIEW_TYPES} from '@kepler.gl/constants';\n\nimport {parseSetCameraType, scaleToVideoExport, getResolutionSetting} from './hubble-utils';\nimport {GlobeExportVideoPreview} from './globe-export-video-preview';\nimport SwipeExportSettings from './swipe-export-settings';\nimport {drawStarsBackground, getGlobeClearColor, getStarsBackgroundImage} from '@kepler.gl/deckgl-layers';\n\n// No-op for the swipe-specific settings callbacks that this single-map globe\n// exporter doesn't use (the swipe controls are hidden via `hideSwipe`).\nconst noop = () => undefined;\n\nconst ENCODERS = {\n  gif: GifEncoder,\n  webm: WebMEncoder,\n  jpeg: JPEGSequenceEncoder,\n  png: PNGSequenceEncoder\n};\n\nexport type GlobeExportVideoSettings = {\n  mediaType?: string;\n  cameraPreset?: string;\n  fileName?: string;\n  resolution?: string;\n  durationMs?: number;\n};\n\ntype GlobeExportVideoPanelContainerProps = {\n  initialState?: Partial<GlobeExportVideoPanelContainerState>;\n  glContext?: WebGL2RenderingContext;\n  exportVideoWidth: number;\n  handleClose: () => void;\n  mapData: any;\n  header: boolean;\n  deckProps?: DeckProps;\n  mapProps: Record<string, any>;\n  defaultFileName: string;\n  animatableFilters: any;\n  onTripFrameUpdate: (value: any) => void;\n  onFilterFrameUpdate: (filterIdx: number, name: string, value: any) => void;\n  getTimeRangeFilterKeyframes: (args: any) => any;\n  onSettingsChange: (settings: GlobeExportVideoSettings) => void;\n};\n\ntype GlobeExportVideoPanelContainerState = {\n  adapter?: DeckAdapter;\n  durationMs: number;\n  mediaType: string;\n  cameraPreset: string;\n  fileName: string;\n  resolution: string;\n  viewState?: MapViewState;\n  rendering: boolean;\n  previewing: boolean;\n  saving: boolean;\n  currentTimeMs: number;\n  memo?: {viewState: MapViewState};\n};\n\nconst PanelBody = styled.div<{$exportVideoWidth: number}>`\n  display: grid;\n  grid-template-columns: ${props => props.$exportVideoWidth}px 280px;\n  grid-template-rows: auto;\n  grid-column-gap: 24px;\n`;\n\nconst TimelineControls = styled.div`\n  position: relative;\n  display: flex;\n  justify-content: center;\n  padding-top: 16px;\n`;\n\nconst timelinePlayButtonStyle = {\n  cursor: 'pointer',\n  height: '32px',\n  width: '32px',\n  fill: '#FFF'\n};\n\nconst ButtonGroup = styled.div`\n  display: flex;\n`;\n\nconst StatusText = styled.div`\n  font-size: 11px;\n  color: ${props => props.theme.subtextColorLT || '#6A7485'};\n  text-align: center;\n  margin-top: 4px;\n`;\n\nconst PlayIcon: React.FC<{style?: React.CSSProperties; onClick?: () => void}> = ({\n  style,\n  onClick\n}) => (\n  <svg className=\"data-ex-icons-play\" viewBox=\"0 0 24 24\" style={style} onClick={onClick}>\n    <path fill=\"none\" d=\"M0 0h24v24H0z\" />\n    <path d=\"M19.376 12.416L8.777 19.482A.5.5 0 0 1 8 19.066V4.934a.5.5 0 0 1 .777-.416l10.599 7.066a.5.5 0 0 1 0 .832z\" />\n  </svg>\n);\n\nconst StopIcon: React.FC<{style?: React.CSSProperties; onClick?: () => void}> = ({\n  style,\n  onClick\n}) => (\n  <svg className=\"data-ex-icons-stop\" viewBox=\"0 0 24 24\" style={style} onClick={onClick}>\n    <path fill=\"none\" d=\"M0 0h24v24H0z\" />\n    <path d=\"M6 5h12a1 1 0 0 1 1 1v12a1 1 0 0 1-1 1H6a1 1 0 0 1-1-1V6a1 1 0 0 1 1-1z\" />\n  </svg>\n);\n\n/**\n * Video export container for globe mode.\n *\n * hubble's built-in ExportVideoPanelContainer only drives its frame-capture\n * loop from the mapbox base map's 'render' event; in globe mode the base map is\n * disabled so that loop never fires and the export hangs. This container mirrors\n * the swipe-export approach: it owns a requestAnimationFrame capture loop and\n * reads the globe deck canvas directly, so recording works without a base map.\n */\nexport class GlobeExportVideoPanelContainer extends Component<\n  GlobeExportVideoPanelContainerProps,\n  GlobeExportVideoPanelContainerState\n> {\n  previewRef = createRef<GlobeExportVideoPreview>();\n  animationFrameId: number | null = null;\n  activeEncoder: any | null = null;\n  // Reused across all captured frames to avoid allocating a full-resolution\n  // canvas per frame (GC pressure/jank during a multi-second export).\n  compositeCanvas: HTMLCanvasElement | null = null;\n\n  constructor(props: GlobeExportVideoPanelContainerProps) {\n    super(props);\n\n    const {\n      initialState,\n      mapData: {mapState},\n      glContext\n    } = props;\n\n    this.state = {\n      mediaType: 'webm',\n      cameraPreset: 'None',\n      fileName: '',\n      resolution: '1280x720',\n      durationMs: 1000,\n      rendering: false,\n      previewing: false,\n      saving: false,\n      currentTimeMs: 0,\n      ...(initialState || {})\n    };\n\n    const viewState = scaleToVideoExport(mapState, this._getContainer());\n    this.state = {\n      ...this.state,\n      viewState,\n      memo: {viewState},\n      adapter: new DeckAdapter({glContext})\n    };\n  }\n\n  componentDidMount() {\n    const {onTripFrameUpdate, onFilterFrameUpdate, getTimeRangeFilterKeyframes} = this.props;\n    const animation = new KeplerAnimation({\n      ...this.getFilterKeyframes(),\n      ...this.getTripKeyframes(),\n      cameraKeyframe: this.getCameraKeyframes(),\n      onCameraFrameUpdate: this.setViewState as any,\n      onTripFrameUpdate,\n      onFilterFrameUpdate,\n      getTimeRangeFilterKeyframes\n    });\n    this.state.adapter!.animationManager.attachAnimation(animation);\n  }\n\n  componentWillUnmount() {\n    this.onStop({abort: true});\n    if (this.animationFrameId) {\n      cancelAnimationFrame(this.animationFrameId);\n    }\n  }\n\n  getFileName() {\n    const {defaultFileName} = this.props;\n    const {fileName} = this.state;\n    return fileName || defaultFileName;\n  }\n\n  getCanvasSize() {\n    const {resolution} = this.state;\n    const {width, height} = getResolutionSetting(resolution);\n    return {width, height};\n  }\n\n  _getContainer() {\n    const {width, height} = this.getCanvasSize();\n    const {exportVideoWidth} = this.props;\n    const aspectRatio = width / height;\n    return {height: exportVideoWidth / aspectRatio, width: exportVideoWidth};\n  }\n\n  getFormatConfigs(): Partial<FormatConfigs> {\n    const {width, height} = this.getCanvasSize();\n    return {\n      webm: {quality: 0.8},\n      jpeg: {quality: 0.8},\n      png: {},\n      gif: {sampleInterval: 1000, width, height}\n    };\n  }\n\n  getTimecode(): Timecode {\n    const {durationMs} = this.state;\n    return {start: 0, end: durationMs, framerate: 30};\n  }\n\n  getEncoder() {\n    const {mediaType} = this.state;\n    return ENCODERS[mediaType];\n  }\n\n  getCameraKeyframes() {\n    const {viewState, cameraPreset, durationMs} = this.state;\n    const {longitude, latitude, zoom, pitch, bearing} = viewState!;\n    const {width, height} = this.getCanvasSize();\n    return {\n      timings: [0, durationMs],\n      keyframes: [\n        {longitude, latitude, zoom, pitch, bearing},\n        parseSetCameraType(cameraPreset, viewState!)\n      ],\n      easings: [easeInOut],\n      width,\n      height\n    };\n  }\n\n  getFilterKeyframes() {\n    const {\n      mapData: {\n        visState: {filters}\n      },\n      animatableFilters\n    } = this.props;\n\n    const filterKeyframes = (\n      Array.isArray(animatableFilters) && animatableFilters.length\n        ? animatableFilters\n        : filters.filter(\n            (f: any) => f.type === 'timeRange' && f.view === FILTER_VIEW_TYPES.enlarged\n          )\n    ).map((f: any) => ({\n      id: f.id,\n      timings: [0, this.state.durationMs]\n    }));\n\n    if (filterKeyframes.length) {\n      return {filters, filterKeyframes};\n    }\n    return {};\n  }\n\n  getTripKeyframes() {\n    const {\n      mapData: {\n        visState: {layers, animationConfig}\n      }\n    } = this.props;\n\n    const animatableLayer = layers.filter(\n      (l: any) => l.config.animation && l.config.animation.enabled && l.config.isVisible\n    );\n    const readyToAnimation =\n      Array.isArray(animationConfig.domain) && Number.isFinite(animationConfig.currentTime);\n    if (animatableLayer.length && readyToAnimation) {\n      return {\n        animationConfig,\n        tripKeyframe: {timings: [0, this.state.durationMs]}\n      };\n    }\n    return {};\n  }\n\n  setViewState = (viewState: MapViewState) => {\n    this.setState({viewState});\n  };\n\n  /** CSS background color (area the globe doesn't cover), from globe config. */\n  getBackgroundColor(): string {\n    const bg = this.props.mapData?.mapState?.globe?.config?.backgroundColor;\n    const [r, g, b] = getGlobeClearColor(bg);\n    return `rgb(${r}, ${g}, ${b})`;\n  }\n\n  /** Starfield behind the globe, matching the live map's CSS background. */\n  areStarsEnabled(): boolean {\n    const globe = this.props.mapData?.mapState?.globe;\n    return Boolean(globe?.enabled && globe?.config?.stars);\n  }\n\n  setStateAndNotify(update: GlobeExportVideoSettings) {\n    const {onSettingsChange} = this.props;\n    const {mediaType, cameraPreset, fileName, resolution, durationMs} = this.state;\n    this.setState({...this.state, ...update} as any);\n    if (onSettingsChange) {\n      onSettingsChange({mediaType, cameraPreset, fileName, resolution, durationMs, ...update});\n    }\n  }\n\n  setMediaType = (mediaType: string) => this.setStateAndNotify({mediaType});\n  setCameraPreset = (cameraPreset: string) => this.setStateAndNotify({cameraPreset});\n  setFileName = (fileName: string) => this.setStateAndNotify({fileName});\n  setResolution = (resolution: string) => this.setStateAndNotify({resolution});\n  setDuration = (durationMs: number) => this.setStateAndNotify({durationMs});\n\n  /** Preview playback — animate the camera without encoding. */\n  onPreviewVideo = () => {\n    const {adapter, durationMs} = this.state;\n    this.setState({\n      previewing: true,\n      currentTimeMs: 0,\n      memo: {viewState: {...this.state.viewState!}}\n    });\n\n    adapter!.animationManager.setKeyframes('kepler', {\n      ...this.getFilterKeyframes(),\n      ...this.getTripKeyframes(),\n      cameraKeyframe: this.getCameraKeyframes()\n    });\n\n    const startTime = performance.now();\n    const animate = () => {\n      const elapsed = performance.now() - startTime;\n      const currentTimeMs = Math.min(elapsed, durationMs);\n\n      adapter!.animationManager.timeline.setTime(currentTimeMs);\n      adapter!.animationManager.draw();\n\n      this.setState({currentTimeMs});\n\n      if (currentTimeMs >= durationMs) {\n        this.setState({\n          previewing: false,\n          currentTimeMs: 0,\n          viewState: {...this.state.memo!.viewState}\n        });\n        return;\n      }\n      this.animationFrameId = requestAnimationFrame(animate);\n    };\n    this.animationFrameId = requestAnimationFrame(animate);\n  };\n\n  /**\n   * Record — drive our own capture loop (hubble's built-in loop never fires\n   * without a base map) and encode the globe deck canvas frame by frame.\n   */\n  onRenderVideo = () => {\n    const {adapter} = this.state;\n    const filename = this.getFileName();\n    const Encoder = this.getEncoder();\n    const formatConfigs = this.getFormatConfigs();\n    const timecode = this.getTimecode();\n    const {width, height} = this.getCanvasSize();\n\n    this.setState({\n      rendering: true,\n      saving: false,\n      currentTimeMs: 0,\n      memo: {viewState: {...this.state.viewState!}}\n    });\n\n    adapter!.animationManager.setKeyframes('kepler', {\n      ...this.getFilterKeyframes(),\n      ...this.getTripKeyframes(),\n      cameraKeyframe: this.getCameraKeyframes()\n    });\n\n    const encoder = new Encoder({...formatConfigs, framerate: timecode.framerate});\n    this.activeEncoder = encoder;\n    encoder.start();\n\n    const frameLengthMs = Math.floor(1000 / timecode.framerate);\n    let timeMs = timecode.start;\n    let retryCount = 0;\n    const MAX_RETRIES = 60;\n\n    const captureNextFrame = () => {\n      if (!this.state.rendering || this.activeEncoder !== encoder) return;\n\n      adapter!.animationManager.timeline.setTime(timeMs);\n      adapter!.animationManager.draw();\n      this.setState({currentTimeMs: timeMs});\n\n      // Allow state update → preview re-render → deck redraw before capturing.\n      const waitAndCapture = () => {\n        requestAnimationFrame(() => {\n          if (this.activeEncoder !== encoder) return;\n          requestAnimationFrame(() => {\n            if (this.activeEncoder !== encoder) return;\n            const preview = this.previewRef.current;\n            if (!preview) return;\n\n            // Wait for globe base/data layers (tiles included) to finish before\n            // the first frame so we don't record a half-loaded planet.\n            if (!preview.areLayersLoaded() && retryCount < MAX_RETRIES) {\n              retryCount++;\n              requestAnimationFrame(waitAndCapture);\n              return;\n            }\n            retryCount = 0;\n\n            const deckCanvas = preview.getCanvas();\n            if (!deckCanvas) return;\n\n            // Reuse a single offscreen canvas across frames (resized only when\n            // the output dimensions change) instead of allocating one per frame.\n            let offscreen = this.compositeCanvas;\n            if (!offscreen) {\n              offscreen = document.createElement('canvas');\n              this.compositeCanvas = offscreen;\n            }\n            if (offscreen.width !== width || offscreen.height !== height) {\n              offscreen.width = width;\n              offscreen.height = height;\n            }\n            const offCtx = offscreen.getContext('2d');\n            if (offCtx) {\n              // deck's canvas is transparent where the globe isn't drawn\n              // (clearColor is disabled to keep picking intact), so fill the\n              // configured background first, tile the starfield (the live map\n              // paints stars as a CSS background, which canvas capture misses),\n              // then composite the deck frame.\n              offCtx.fillStyle = this.getBackgroundColor();\n              offCtx.fillRect(0, 0, width, height);\n              if (this.areStarsEnabled()) {\n                drawStarsBackground(offCtx, width, height);\n              }\n              offCtx.drawImage(deckCanvas, 0, 0, width, height);\n            }\n\n            encoder.add(offscreen).then(() => {\n              if (this.activeEncoder !== encoder) return;\n              timeMs += frameLengthMs;\n              if (timeMs > timecode.end) {\n                this.setState({saving: true});\n                encoder.save().then((blob: Blob | null) => {\n                  if (this.activeEncoder !== encoder) return;\n                  if (blob) {\n                    download(blob, filename + encoder.extension, encoder.mimeType);\n                  }\n                  this.setState({\n                    rendering: false,\n                    saving: false,\n                    currentTimeMs: 0,\n                    viewState: {...this.state.memo!.viewState}\n                  });\n                });\n              } else {\n                captureNextFrame();\n              }\n            });\n          });\n        });\n      };\n\n      waitAndCapture();\n    };\n\n    // Give the deck a moment to mount/draw before the first capture.\n    setTimeout(() => captureNextFrame(), 500);\n  };\n\n  onStop = ({abort = false}: {abort?: boolean} = {}) => {\n    if (this.animationFrameId) {\n      cancelAnimationFrame(this.animationFrameId);\n      this.animationFrameId = null;\n    }\n    this.activeEncoder = null;\n    if (!abort) {\n      this.setState({\n        rendering: false,\n        previewing: false,\n        currentTimeMs: 0,\n        viewState: this.state.memo?.viewState || this.state.viewState\n      });\n    }\n  };\n\n  render() {\n    const {exportVideoWidth, mapData, deckProps} = this.props;\n\n    const {\n      adapter,\n      durationMs,\n      mediaType,\n      cameraPreset,\n      fileName,\n      resolution,\n      viewState,\n      rendering,\n      previewing,\n      saving,\n      currentTimeMs\n    } = this.state;\n\n    const timecode = this.getTimecode();\n    let canvasSize = this.getCanvasSize();\n    if (previewing) {\n      canvasSize = this._getContainer();\n    }\n\n    const isActive = rendering || previewing;\n\n    return (\n      <div className=\"export-video-panel\">\n        <PanelBody $exportVideoWidth={exportVideoWidth}>\n          <GlobeExportVideoPreview\n            ref={this.previewRef}\n            mapData={mapData}\n            adapter={adapter!}\n            setViewState={this.setViewState}\n            exportVideoWidth={exportVideoWidth}\n            resolution={[canvasSize.width, canvasSize.height]}\n            viewState={viewState!}\n            rendering={rendering}\n            saving={saving}\n            durationMs={durationMs}\n            deckProps={deckProps}\n            mapProps={this.props.mapProps}\n            backgroundColor={this.getBackgroundColor()}\n            starsImage={this.areStarsEnabled() ? getStarsBackgroundImage() : null}\n          />\n          <SwipeExportSettings\n            durationMs={durationMs}\n            mediaType={mediaType}\n            resolution={resolution}\n            fileName={fileName}\n            cameraPreset={cameraPreset}\n            frameRate={timecode.framerate}\n            onChangeDuration={this.setDuration}\n            onChangeMediaType={this.setMediaType}\n            onChangeResolution={this.setResolution}\n            onChangeFileName={this.setFileName}\n            onChangeCameraPreset={this.setCameraPreset}\n            swipeStartPct={0}\n            swipeEndPct={100}\n            swipeEasing={'ease-in-out'}\n            disabled={isActive}\n            onChangeStartPct={noop}\n            onChangeEndPct={noop}\n            onChangeEasing={noop}\n            hideSwipe\n          />\n          <TimelineControls className=\"timeline-controls\">\n            {isActive ? (\n              <StopIcon style={timelinePlayButtonStyle} onClick={() => this.onStop({})} />\n            ) : (\n              <PlayIcon style={timelinePlayButtonStyle} onClick={this.onPreviewVideo} />\n            )}\n          </TimelineControls>\n          {saving && <StatusText>Saving...</StatusText>}\n          {rendering && !saving && (\n            <StatusText>Rendering... {Math.round((currentTimeMs / durationMs) * 100)}%</StatusText>\n          )}\n          <ButtonGroup>\n            <Button\n              style={{marginTop: '16px', width: '100%', height: '32px'}}\n              className=\"export-video-button\"\n              onClick={this.onRenderVideo}\n              disabled={isActive}\n            >\n              Render\n            </Button>\n          </ButtonGroup>\n        </PanelBody>\n      </div>\n    );\n  }\n}\n"],"mappings":"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","ignoreList":[]}