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

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

@@ -0,0 +1,159 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+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;
+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 } from 'react';
+import DeckGL from '@deck.gl/react';
+import styled from 'styled-components';
+import { EXPORT_DECK_DEVICE_PROPS, getGlobeExportLayers } from './hubble-utils';
+var PreviewContainer = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  width: ", "px;\n  height: ", "px;\n  position: relative;\n  background-color: ", ";\n  ", "\n"])), function (props) {
+  return props.$width;
+}, function (props) {
+  return props.$height;
+}, function (props) {
+  return props.$background;
+}, function (props) {
+  return props.$starsImage ? "background-image: url('".concat(props.$starsImage, "'); background-repeat: repeat;") : '';
+});
+/**
+ * Single-canvas video export preview for globe mode.
+ *
+ * hubble's built-in preview cannot be used for globe mode: in its
+ * `disableBaseMap` branch it renders a bare <DeckGL> without a viewState and
+ * never wires up the frame-capture loop (that loop is driven by the mapbox
+ * 'render' event, which does not exist without a base map). This component
+ * renders the globe deck directly with a valid, controlled viewState so the
+ * GlobeView controller initializes correctly (no MapState/GlobeState assert),
+ * stays interactive, and exposes the deck canvas so the parent container can
+ * drive its own capture loop (mirrors the swipe export approach).
+ */
+export var GlobeExportVideoPreview = /*#__PURE__*/function (_Component) {
+  function GlobeExportVideoPreview() {
+    var _this;
+    _classCallCheck(this, GlobeExportVideoPreview);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, GlobeExportVideoPreview, [].concat(args));
+    _defineProperty(_this, "deckRef", /*#__PURE__*/React.createRef());
+    return _this;
+  }
+  _inherits(GlobeExportVideoPreview, _Component);
+  return _createClass(GlobeExportVideoPreview, [{
+    key: "_getContainer",
+    value: function _getContainer() {
+      var _this$props = this.props,
+        exportVideoWidth = _this$props.exportVideoWidth,
+        resolution = _this$props.resolution;
+      var aspectRatio = resolution[0] / resolution[1];
+      return {
+        height: exportVideoWidth / aspectRatio,
+        width: exportVideoWidth
+      };
+    }
+
+    /** Expose the deck canvas so the parent container can capture frames. */
+  }, {
+    key: "getCanvas",
+    value: function getCanvas() {
+      var _deck$getCanvas;
+      var deck = this.deckRef.current;
+      return deck && ((_deck$getCanvas = deck.getCanvas) === null || _deck$getCanvas === void 0 ? void 0 : _deck$getCanvas.call(deck)) || null;
+    }
+
+    /** All layers loaded — used to gate the first capture frame. */
+  }, {
+    key: "areLayersLoaded",
+    value: function areLayersLoaded() {
+      var deck = this.deckRef.current;
+      if (!deck) return false;
+      var layers = deck.props.layers || [];
+      return layers.length > 0 && layers.every(function (layer) {
+        return layer.isLoaded;
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var _this$props2 = this.props,
+        adapter = _this$props2.adapter,
+        deckProps = _this$props2.deckProps,
+        viewState = _this$props2.viewState,
+        setViewState = _this$props2.setViewState,
+        resolution = _this$props2.resolution,
+        exportVideoWidth = _this$props2.exportVideoWidth,
+        backgroundColor = _this$props2.backgroundColor,
+        mapData = _this$props2.mapData,
+        mapProps = _this$props2.mapProps,
+        starsImage = _this$props2.starsImage;
+      var _this$_getContainer = this._getContainer(),
+        width = _this$_getContainer.width,
+        height = _this$_getContainer.height;
+      var deck = this.deckRef.current;
+
+      // Rebuild layers from the animated camera (hubble 2D: createKeplerLayers(mapData, viewState)).
+      var layers = getGlobeExportLayers(mapData, {
+        mapIndex: 0,
+        mapboxApiAccessToken: mapProps === null || mapProps === void 0 ? void 0 : mapProps.mapboxApiAccessToken,
+        mapboxApiUrl: mapProps === null || mapProps === void 0 ? void 0 : mapProps.mapboxApiUrl,
+        viewState: viewState
+      });
+
+      // adapter.getProps injects `_animate` (and toggles `controller` off while
+      // recording) so hubble's KeplerAnimation can drive the camera. Views,
+      // controller bounds and initialViewState come from `deckProps`
+      // (see getHubbleDeckGlProps). A controlled `viewState` keeps the preview in
+      // sync with the animated camera and prevents the GlobeState assert.
+      var adapterProps = adapter.getProps({
+        deck: deck,
+        extraProps: _objectSpread(_objectSpread({}, deckProps), {}, {
+          layers: layers
+        })
+      });
+
+      // Render the drawing buffer at the true export resolution regardless of the
+      // small CSS preview size. deck.gl's MSAA (antialias defaults to true when
+      // deck owns the canvas) only smooths edges at the drawing-buffer resolution,
+      // so if the buffer were the small preview size the globe silhouette would
+      // look pixelated once the captured frame is scaled up to the output size.
+      // Passing an explicit numeric `useDevicePixels` sizes the buffer to
+      // width * ratio === exportVideoWidth * (resolution / exportVideoWidth) ===
+      // resolution, and is far more reliable than mutating window.devicePixelRatio.
+      var pixelRatio = Math.max(1, resolution[0] / exportVideoWidth);
+      return /*#__PURE__*/React.createElement(PreviewContainer, {
+        $width: width,
+        $height: height,
+        $background: backgroundColor,
+        $starsImage: starsImage
+      }, /*#__PURE__*/React.createElement(DeckGL, _extends({
+        ref: function ref(_ref2) {
+          _this2.deckRef.current = (_ref2 === null || _ref2 === void 0 ? void 0 : _ref2.deck) || null;
+        },
+        deviceProps: EXPORT_DECK_DEVICE_PROPS
+      }, adapterProps, {
+        viewState: viewState,
+        onViewStateChange: function onViewStateChange(_ref) {
+          var vs = _ref.viewState;
+          return setViewState(vs);
+        },
+        useDevicePixels: pixelRatio,
+        width: width,
+        height: height
+      })));
+    }
+  }]);
+}(Component);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","Component","DeckGL","styled","EXPORT_DECK_DEVICE_PROPS","getGlobeExportLayers","PreviewContainer","div","_templateObject","_taggedTemplateLiteral","props","$width","$height","$background","$starsImage","concat","GlobeExportVideoPreview","_Component","_this","_classCallCheck","_len","arguments","length","args","Array","_key","_callSuper","_defineProperty","createRef","_inherits","_createClass","key","value","_getContainer","_this$props","exportVideoWidth","resolution","aspectRatio","height","width","getCanvas","_deck$getCanvas","deck","deckRef","current","call","areLayersLoaded","layers","every","layer","isLoaded","render","_this2","_this$props2","adapter","deckProps","viewState","setViewState","backgroundColor","mapData","mapProps","starsImage","_this$_getContainer","mapIndex","mapboxApiAccessToken","mapboxApiUrl","adapterProps","getProps","extraProps","_objectSpread","pixelRatio","Math","max","createElement","_extends","ref","deviceProps","onViewStateChange","_ref","vs","useDevicePixels"],"sources":["../../../src/modals/globe-export-video-preview.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {Component, RefObject} from 'react';\nimport DeckGL from '@deck.gl/react';\nimport type {Deck, DeckProps, MapViewState} from '@deck.gl/core';\nimport styled from 'styled-components';\n\nimport {DeckAdapter} from '@hubble.gl/core';\nimport {EXPORT_DECK_DEVICE_PROPS, getGlobeExportLayers} from './hubble-utils';\n\nconst PreviewContainer = styled.div<{\n  $width: number;\n  $height: number;\n  $background: string;\n  $starsImage?: string | null;\n}>`\n  width: ${props => props.$width}px;\n  height: ${props => props.$height}px;\n  position: relative;\n  background-color: ${props => props.$background};\n  ${props =>\n    props.$starsImage\n      ? `background-image: url('${props.$starsImage}'); background-repeat: repeat;`\n      : ''}\n`;\n\nexport type GlobeExportVideoPreviewProps = {\n  mapData: any;\n  resolution: [number, number];\n  exportVideoWidth: number;\n  deckProps?: DeckProps;\n  viewState: MapViewState;\n  adapter: DeckAdapter;\n  rendering: boolean;\n  saving: boolean;\n  setViewState: (viewState: MapViewState) => void;\n  durationMs: number;\n  /** CSS color string for the area the globe does not cover. */\n  backgroundColor: string;\n  mapProps?: Record<string, any>;\n  /** Tileable star-field data URL, matching the live globe map CSS background. */\n  starsImage?: string | null;\n};\n\n/**\n * Single-canvas video export preview for globe mode.\n *\n * hubble's built-in preview cannot be used for globe mode: in its\n * `disableBaseMap` branch it renders a bare <DeckGL> without a viewState and\n * never wires up the frame-capture loop (that loop is driven by the mapbox\n * 'render' event, which does not exist without a base map). This component\n * renders the globe deck directly with a valid, controlled viewState so the\n * GlobeView controller initializes correctly (no MapState/GlobeState assert),\n * stays interactive, and exposes the deck canvas so the parent container can\n * drive its own capture loop (mirrors the swipe export approach).\n */\nexport class GlobeExportVideoPreview extends Component<GlobeExportVideoPreviewProps> {\n  deckRef: RefObject<Deck | null> = React.createRef<Deck | null>();\n\n  _getContainer() {\n    const {exportVideoWidth, resolution} = this.props;\n    const aspectRatio = resolution[0] / resolution[1];\n    return {height: exportVideoWidth / aspectRatio, width: exportVideoWidth};\n  }\n\n  /** Expose the deck canvas so the parent container can capture frames. */\n  getCanvas(): HTMLCanvasElement | null {\n    const deck = this.deckRef.current as any;\n    return (deck && deck.getCanvas?.()) || null;\n  }\n\n  /** All layers loaded — used to gate the first capture frame. */\n  areLayersLoaded(): boolean {\n    const deck = this.deckRef.current;\n    if (!deck) return false;\n    const layers = deck.props.layers || [];\n    return layers.length > 0 && layers.every((layer: any) => layer.isLoaded);\n  }\n\n  render() {\n    const {\n      adapter,\n      deckProps,\n      viewState,\n      setViewState,\n      resolution,\n      exportVideoWidth,\n      backgroundColor,\n      mapData,\n      mapProps,\n      starsImage\n    } = this.props;\n    const {width, height} = this._getContainer();\n    const deck = this.deckRef.current;\n\n    // Rebuild layers from the animated camera (hubble 2D: createKeplerLayers(mapData, viewState)).\n    const layers = getGlobeExportLayers(mapData, {\n      mapIndex: 0,\n      mapboxApiAccessToken: mapProps?.mapboxApiAccessToken,\n      mapboxApiUrl: mapProps?.mapboxApiUrl,\n      viewState\n    });\n\n    // adapter.getProps injects `_animate` (and toggles `controller` off while\n    // recording) so hubble's KeplerAnimation can drive the camera. Views,\n    // controller bounds and initialViewState come from `deckProps`\n    // (see getHubbleDeckGlProps). A controlled `viewState` keeps the preview in\n    // sync with the animated camera and prevents the GlobeState assert.\n    const adapterProps = adapter.getProps({\n      deck: deck as any,\n      extraProps: {...deckProps, layers} as any\n    }) as any;\n\n    // Render the drawing buffer at the true export resolution regardless of the\n    // small CSS preview size. deck.gl's MSAA (antialias defaults to true when\n    // deck owns the canvas) only smooths edges at the drawing-buffer resolution,\n    // so if the buffer were the small preview size the globe silhouette would\n    // look pixelated once the captured frame is scaled up to the output size.\n    // Passing an explicit numeric `useDevicePixels` sizes the buffer to\n    // width * ratio === exportVideoWidth * (resolution / exportVideoWidth) ===\n    // resolution, and is far more reliable than mutating window.devicePixelRatio.\n    const pixelRatio = Math.max(1, resolution[0] / exportVideoWidth);\n\n    return (\n      <PreviewContainer\n        $width={width}\n        $height={height}\n        $background={backgroundColor}\n        $starsImage={starsImage}\n      >\n        <DeckGL\n          ref={ref => {\n            this.deckRef.current = (ref?.deck as any) || null;\n          }}\n          deviceProps={EXPORT_DECK_DEVICE_PROPS}\n          {...adapterProps}\n          viewState={viewState}\n          onViewStateChange={({viewState: vs}: any) => setViewState(vs)}\n          useDevicePixels={pixelRatio}\n          width={width}\n          height={height}\n        />\n      </PreviewContainer>\n    );\n  }\n}\n"],"mappings":"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","ignoreList":[]}