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

package/dist/cjs/modals/export-video-modal.spec.js

@@ -0,0 +1,732 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _styledComponents = require("styled-components");
+var _reactIntl = require("react-intl");
+var _react2 = require("@testing-library/react");
+var _styles = require("@kepler.gl/styles");
+var _localization = require("@kepler.gl/localization");
+var _exportVideoModal = _interopRequireDefault(require("./export-video-modal"));
+var _effects = require("@kepler.gl/effects");
+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
+// @ts-nocheck
+var mockExportVideoPanelContainer = jest.fn(function () {
+  return /*#__PURE__*/_react["default"].createElement("div", {
+    "data-testid": "export-video-panel"
+  }, "Mock Panel");
+});
+var MockKeplerUIContext = /*#__PURE__*/_react["default"].createContext(null);
+jest.mock('@hubble.gl/react', function () {
+  return {
+    ExportVideoPanelContainer: function ExportVideoPanelContainer(props) {
+      return mockExportVideoPanelContainer(props);
+    },
+    KeplerUIContext: MockKeplerUIContext
+  };
+});
+var mockComputeDeckEffects = jest.fn(function () {
+  return [];
+});
+jest.mock('@kepler.gl/utils', function () {
+  var actual = jest.requireActual('@kepler.gl/utils');
+  return _objectSpread(_objectSpread({}, actual), {}, {
+    computeDeckEffects: function computeDeckEffects() {
+      return mockComputeDeckEffects.apply(void 0, arguments);
+    },
+    patchDeckRendererForPostProcessing: jest.fn()
+  });
+});
+jest.mock('@kepler.gl/effects', function () {
+  return {
+    DeckShadowCompositingEffect: jest.fn().mockImplementation(function () {
+      return {
+        id: 'shadow-compositing-effect',
+        postRender: jest.fn(),
+        cleanup: jest.fn()
+      };
+    })
+  };
+});
+jest.mock('./hubble-utils', function () {
+  return {
+    getStaticMapProps: jest.fn(function (_state, _onChange, _token) {
+      return {
+        latitude: 37.7,
+        longitude: -122.4,
+        preserveDrawingBuffer: true,
+        mapboxApiAccessToken: 'style-token',
+        mapStyle: {
+          id: 'dark-style'
+        },
+        mapLib: Promise.resolve({})
+      };
+    }),
+    getBeforeLayerId: jest.fn(function () {
+      return null;
+    }),
+    getHubbleDeckGlProps: jest.fn(function () {
+      return {
+        parameters: {
+          blend: true
+        },
+        controller: true,
+        views: {}
+      };
+    }),
+    getTimeRangeFilterKeyframes: jest.fn(),
+    getAnimatableFilters: jest.fn(function () {
+      return [];
+    }),
+    getResolutionSetting: jest.fn(function (value) {
+      var _String$split$map = String(value || '1280x720').split('x').map(Number),
+        _String$split$map2 = (0, _slicedToArray2["default"])(_String$split$map, 2),
+        width = _String$split$map2[0],
+        height = _String$split$map2[1];
+      return {
+        value: value,
+        width: width,
+        height: height,
+        label: value
+      };
+    })
+  };
+});
+function renderWithThemeLocal(component) {
+  return (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_styledComponents.ThemeProvider, {
+    theme: _styles.theme
+  }, /*#__PURE__*/_react["default"].createElement(_reactIntl.IntlProvider, {
+    locale: "en",
+    messages: _localization.messages
+  }, component)));
+}
+var ExportVideoModal = (0, _exportVideoModal["default"])();
+var DEFAULT_PROPS = {
+  mapboxApiAccessToken: 'test-token',
+  mapboxApiUrl: 'https://api.mapbox.com',
+  mapState: {
+    latitude: 37.7,
+    longitude: -122.4,
+    zoom: 10
+  },
+  mapStyle: {
+    styleType: 'dark',
+    mapStyles: {
+      dark: {
+        accessToken: 'style-token'
+      }
+    },
+    bottomMapStyle: {
+      id: 'dark-style'
+    },
+    topMapStyle: null
+  },
+  visState: {
+    filters: [],
+    layers: [],
+    layerBlending: 'normal',
+    layerOrder: []
+  },
+  exportVideo: {
+    mediaType: 'webm',
+    cameraPreset: 'None',
+    fileName: 'kepler.gl',
+    resolution: '1280x720',
+    durationMs: 1000
+  },
+  containerW: 800,
+  visStateActions: {
+    setFilterAnimationTime: jest.fn(),
+    setLayerAnimationTime: jest.fn()
+  },
+  uiStateActions: {
+    setExportVideoSetting: jest.fn()
+  },
+  onClose: jest.fn()
+};
+function renderAndWaitForPanel() {
+  return _renderAndWaitForPanel.apply(this, arguments);
+}
+function _renderAndWaitForPanel() {
+  _renderAndWaitForPanel = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee19() {
+    var props,
+      result,
+      _args19 = arguments;
+    return _regenerator["default"].wrap(function _callee19$(_context19) {
+      while (1) switch (_context19.prev = _context19.next) {
+        case 0:
+          props = _args19.length > 0 && _args19[0] !== undefined ? _args19[0] : DEFAULT_PROPS;
+          result = renderWithThemeLocal(/*#__PURE__*/_react["default"].createElement(ExportVideoModal, props));
+          _context19.next = 4;
+          return (0, _react2.waitFor)(function () {
+            expect(mockExportVideoPanelContainer).toHaveBeenCalled();
+          });
+        case 4:
+          return _context19.abrupt("return", result);
+        case 5:
+        case "end":
+          return _context19.stop();
+      }
+    }, _callee19);
+  }));
+  return _renderAndWaitForPanel.apply(this, arguments);
+}
+describe('ExportVideoModal', function () {
+  beforeEach(function () {
+    jest.clearAllMocks();
+    mockComputeDeckEffects.mockReturnValue([]);
+  });
+  test('renders without crashing', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    var _yield$renderAndWaitF, container;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return renderAndWaitForPanel();
+        case 2:
+          _yield$renderAndWaitF = _context.sent;
+          container = _yield$renderAndWaitF.container;
+          expect(container.querySelector('.export-video-modal')).toBeInTheDocument();
+        case 5:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  test('provides KeplerUI context with expected components', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 2;
+          return renderAndWaitForPanel();
+        case 2:
+          expect(mockExportVideoPanelContainer).toHaveBeenCalledTimes(1);
+        case 3:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  test('passes correct props to ExportVideoPanelContainer', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+    var panelProps;
+    return _regenerator["default"].wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.next = 2;
+          return renderAndWaitForPanel();
+        case 2:
+          expect(mockExportVideoPanelContainer).toHaveBeenCalledTimes(1);
+          panelProps = mockExportVideoPanelContainer.mock.calls[0][0];
+          expect(panelProps.header).toBe(false);
+          expect(panelProps.disableBaseMap).toBe(false);
+          expect(panelProps.defaultFileName).toBe('kepler.gl');
+          expect(panelProps.exportVideoWidth).toBeLessThanOrEqual(540);
+          expect(panelProps.exportVideoWidth).toBeGreaterThanOrEqual(320);
+          expect(panelProps.handleClose).toBe(DEFAULT_PROPS.onClose);
+          expect(panelProps.initialState).toEqual(DEFAULT_PROPS.exportVideo);
+          expect(panelProps.mapData).toEqual({
+            visState: DEFAULT_PROPS.visState,
+            mapState: DEFAULT_PROPS.mapState,
+            mapStyle: DEFAULT_PROPS.mapStyle
+          });
+        case 12:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  test('passes deckProps from getHubbleDeckGlProps', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+    var panelProps;
+    return _regenerator["default"].wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          _context4.next = 2;
+          return renderAndWaitForPanel();
+        case 2:
+          panelProps = mockExportVideoPanelContainer.mock.calls[0][0];
+          expect(panelProps.deckProps).toEqual({
+            parameters: {
+              blend: true
+            },
+            controller: true,
+            views: {},
+            _isExport: true,
+            effects: []
+          });
+        case 4:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  test('passes mapProps from getStaticMapProps', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5() {
+    var panelProps;
+    return _regenerator["default"].wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          _context5.next = 2;
+          return renderAndWaitForPanel();
+        case 2:
+          panelProps = mockExportVideoPanelContainer.mock.calls[0][0];
+          expect(panelProps.mapProps.latitude).toBe(37.7);
+          expect(panelProps.mapProps.longitude).toBe(-122.4);
+          expect(panelProps.mapProps.preserveDrawingBuffer).toBe(true);
+          expect(panelProps.mapProps.mapboxApiAccessToken).toBe('style-token');
+          expect(panelProps.mapProps.mapStyle).toEqual({
+            id: 'dark-style'
+          });
+          expect(panelProps.mapProps.mapLib).toBeDefined();
+        case 9:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  })));
+  test('passes empty animatableFilters when no matching filters', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee6() {
+    var panelProps;
+    return _regenerator["default"].wrap(function _callee6$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          _context6.next = 2;
+          return renderAndWaitForPanel();
+        case 2:
+          panelProps = mockExportVideoPanelContainer.mock.calls[0][0];
+          expect(panelProps.animatableFilters).toEqual([]);
+        case 4:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+  test('provides getTimeRangeFilterKeyframes callback', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee7() {
+    var panelProps;
+    return _regenerator["default"].wrap(function _callee7$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          _context7.next = 2;
+          return renderAndWaitForPanel();
+        case 2:
+          panelProps = mockExportVideoPanelContainer.mock.calls[0][0];
+          expect((0, _typeof2["default"])(panelProps.getTimeRangeFilterKeyframes)).toBe('function');
+        case 4:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7);
+  })));
+  test('provides onFilterFrameUpdate that calls visStateActions', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee8() {
+    var panelProps;
+    return _regenerator["default"].wrap(function _callee8$(_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          _context8.next = 2;
+          return renderAndWaitForPanel();
+        case 2:
+          panelProps = mockExportVideoPanelContainer.mock.calls[0][0];
+          panelProps.onFilterFrameUpdate(0, 'value', [100, 200]);
+          expect(DEFAULT_PROPS.visStateActions.setFilterAnimationTime).toHaveBeenCalledWith(0, 'value', [100, 200]);
+        case 5:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee8);
+  })));
+  test('provides onTripFrameUpdate that calls visStateActions', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee9() {
+    var panelProps;
+    return _regenerator["default"].wrap(function _callee9$(_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
+        case 0:
+          _context9.next = 2;
+          return renderAndWaitForPanel();
+        case 2:
+          panelProps = mockExportVideoPanelContainer.mock.calls[0][0];
+          panelProps.onTripFrameUpdate(42);
+          expect(DEFAULT_PROPS.visStateActions.setLayerAnimationTime).toHaveBeenCalledWith(42);
+        case 5:
+        case "end":
+          return _context9.stop();
+      }
+    }, _callee9);
+  })));
+  describe('NO_MAP_ID handling', function () {
+    var NO_MAP_PROPS = _objectSpread(_objectSpread({}, DEFAULT_PROPS), {}, {
+      mapStyle: {
+        styleType: 'no_map',
+        mapStyles: {
+          no_map: {
+            id: 'no_map',
+            label: 'No Basemap',
+            // url is intentionally missing to exercise the data-URI patch
+            icon: '',
+            layerGroups: [],
+            colorMode: 'NONE',
+            style: {
+              version: 8,
+              sources: {},
+              layers: []
+            }
+          }
+        },
+        bottomMapStyle: null,
+        topMapStyle: null
+      }
+    });
+    test('renders without crashing when styleType is NO_MAP_ID', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee0() {
+      var _yield$renderAndWaitF2, container;
+      return _regenerator["default"].wrap(function _callee0$(_context0) {
+        while (1) switch (_context0.prev = _context0.next) {
+          case 0:
+            _context0.next = 2;
+            return renderAndWaitForPanel(NO_MAP_PROPS);
+          case 2:
+            _yield$renderAndWaitF2 = _context0.sent;
+            container = _yield$renderAndWaitF2.container;
+            expect(container.querySelector('.export-video-modal')).toBeInTheDocument();
+          case 5:
+          case "end":
+            return _context0.stop();
+        }
+      }, _callee0);
+    })));
+    test('injects data-URI empty style URL into mapData when NO_MAP_ID entry has no url', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee1() {
+      var panelProps, noMapEntry, encoded, decoded;
+      return _regenerator["default"].wrap(function _callee1$(_context1) {
+        while (1) switch (_context1.prev = _context1.next) {
+          case 0:
+            _context1.next = 2;
+            return renderAndWaitForPanel(NO_MAP_PROPS);
+          case 2:
+            panelProps = mockExportVideoPanelContainer.mock.calls[0][0];
+            noMapEntry = panelProps.mapData.mapStyle.mapStyles.no_map;
+            expect(noMapEntry.url).toBeDefined();
+            expect(noMapEntry.url).toMatch(/^data:application\/json,/);
+            encoded = noMapEntry.url.replace('data:application/json,', '');
+            decoded = JSON.parse(decodeURIComponent(encoded));
+            expect(decoded).toEqual({
+              version: 8,
+              sources: {},
+              layers: []
+            });
+          case 9:
+          case "end":
+            return _context1.stop();
+        }
+      }, _callee1);
+    })));
+    test('preserves original mapStyle when NO_MAP_ID entry already has a url', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee10() {
+      var propsWithUrl, panelProps;
+      return _regenerator["default"].wrap(function _callee10$(_context10) {
+        while (1) switch (_context10.prev = _context10.next) {
+          case 0:
+            propsWithUrl = _objectSpread(_objectSpread({}, DEFAULT_PROPS), {}, {
+              mapStyle: {
+                styleType: 'no_map',
+                mapStyles: {
+                  no_map: {
+                    id: 'no_map',
+                    url: 'https://existing-style.json'
+                  }
+                },
+                bottomMapStyle: null,
+                topMapStyle: null
+              }
+            });
+            _context10.next = 3;
+            return renderAndWaitForPanel(propsWithUrl);
+          case 3:
+            panelProps = mockExportVideoPanelContainer.mock.calls[0][0];
+            expect(panelProps.mapData.mapStyle).toBe(propsWithUrl.mapStyle);
+          case 5:
+          case "end":
+            return _context10.stop();
+        }
+      }, _callee10);
+    })));
+  });
+  describe('surface fog height animation', function () {
+    function makeFogDeckEffect() {
+      var effect = {
+        id: 'surface-fog-deck',
+        props: {
+          height: 50
+        },
+        postRender: jest.fn(),
+        setProps: jest.fn(function (newProps) {
+          Object.assign(effect.props, newProps);
+        })
+      };
+      return effect;
+    }
+    function makeSurfaceFogEffect(deckEffect) {
+      var overrides = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var effect = {
+        id: 'fog-1',
+        type: 'surfaceFog',
+        isEnabled: true,
+        parameters: _objectSpread({
+          height: 50,
+          animateHeight: true,
+          heightEnd: 200,
+          linearEasing: false
+        }, overrides),
+        deckEffect: deckEffect,
+        clone: jest.fn()
+      };
+      // clone returns a fresh reference that still points to the same deckEffect
+      effect.clone.mockImplementation(function () {
+        return _objectSpread(_objectSpread({}, effect), {}, {
+          clone: effect.clone
+        });
+      });
+      return effect;
+    }
+    function propsWithFogEffect(fogEffect) {
+      return _objectSpread(_objectSpread({}, DEFAULT_PROPS), {}, {
+        visState: _objectSpread(_objectSpread({}, DEFAULT_PROPS.visState), {}, {
+          effects: [fogEffect],
+          effectOrder: [fogEffect.id]
+        })
+      });
+    }
+    test('patches deckEffect.postRender when animateHeight is enabled', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee11() {
+      var deckEffect, originalPostRender, fogEffect;
+      return _regenerator["default"].wrap(function _callee11$(_context11) {
+        while (1) switch (_context11.prev = _context11.next) {
+          case 0:
+            deckEffect = makeFogDeckEffect();
+            originalPostRender = deckEffect.postRender;
+            fogEffect = makeSurfaceFogEffect(deckEffect);
+            mockComputeDeckEffects.mockReturnValue([deckEffect]);
+            _context11.next = 6;
+            return renderAndWaitForPanel(propsWithFogEffect(fogEffect));
+          case 6:
+            expect(deckEffect.postRender).not.toBe(originalPostRender);
+          case 7:
+          case "end":
+            return _context11.stop();
+        }
+      }, _callee11);
+    })));
+    test('restores original height when hubble is not playing', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee12() {
+      var deckEffect, fogEffect;
+      return _regenerator["default"].wrap(function _callee12$(_context12) {
+        while (1) switch (_context12.prev = _context12.next) {
+          case 0:
+            deckEffect = makeFogDeckEffect();
+            deckEffect.props.height = 75;
+            fogEffect = makeSurfaceFogEffect(deckEffect, {
+              height: 75
+            });
+            mockComputeDeckEffects.mockReturnValue([deckEffect]);
+            _context12.next = 6;
+            return renderAndWaitForPanel(propsWithFogEffect(fogEffect));
+          case 6:
+            // Call the patched postRender without hubble playing
+            deckEffect.postRender.call(deckEffect, {});
+
+            // Not playing → height resets to originalHeight
+            expect(deckEffect.props.height).toBe(75);
+          case 8:
+          case "end":
+            return _context12.stop();
+        }
+      }, _callee12);
+    })));
+    test('does not mutate height when animateHeight is disabled', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee13() {
+      var deckEffect, fogEffect;
+      return _regenerator["default"].wrap(function _callee13$(_context13) {
+        while (1) switch (_context13.prev = _context13.next) {
+          case 0:
+            deckEffect = makeFogDeckEffect();
+            fogEffect = makeSurfaceFogEffect(deckEffect, {
+              animateHeight: false
+            });
+            mockComputeDeckEffects.mockReturnValue([deckEffect]);
+            _context13.next = 5;
+            return renderAndWaitForPanel(propsWithFogEffect(fogEffect));
+          case 5:
+            deckEffect.props.height = 42;
+            deckEffect.postRender.call(deckEffect, {});
+
+            // ref.active is false so height should not be touched
+            expect(deckEffect.props.height).toBe(42);
+          case 8:
+          case "end":
+            return _context13.stop();
+        }
+      }, _callee13);
+    })));
+    test('restores original postRender on unmount', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee14() {
+      var deckEffect, fogEffect, _yield$renderAndWaitF3, unmount, patchedPostRender;
+      return _regenerator["default"].wrap(function _callee14$(_context14) {
+        while (1) switch (_context14.prev = _context14.next) {
+          case 0:
+            deckEffect = makeFogDeckEffect();
+            fogEffect = makeSurfaceFogEffect(deckEffect);
+            mockComputeDeckEffects.mockReturnValue([deckEffect]);
+            _context14.next = 5;
+            return renderAndWaitForPanel(propsWithFogEffect(fogEffect));
+          case 5:
+            _yield$renderAndWaitF3 = _context14.sent;
+            unmount = _yield$renderAndWaitF3.unmount;
+            // postRender was patched (the wrapper function drives animation)
+            patchedPostRender = deckEffect.postRender; // Verify it's not the original mock (component binds and wraps it)
+            expect(patchedPostRender).not.toBe(deckEffect.postRender.bind(deckEffect));
+            unmount();
+
+            // After unmount, postRender no longer drives animation.
+            // The restored function is a bound copy of the original mock.
+            deckEffect.props.height = 99;
+            deckEffect.postRender.call(deckEffect, {});
+            // Height should NOT be mutated by animation logic anymore
+            expect(deckEffect.props.height).toBe(99);
+          case 13:
+          case "end":
+            return _context14.stop();
+        }
+      }, _callee14);
+    })));
+  });
+  describe('shadow compositing fallback', function () {
+    var mockEffect = {
+      id: 'light-shadow-1',
+      type: 'light-and-shadow',
+      isEnabled: true,
+      clone: jest.fn(function () {
+        return _objectSpread(_objectSpread({}, mockEffect), {}, {
+          clone: mockEffect.clone
+        });
+      })
+    };
+    function propsWithEffects(effects) {
+      return _objectSpread(_objectSpread({}, DEFAULT_PROPS), {}, {
+        visState: _objectSpread(_objectSpread({}, DEFAULT_PROPS.visState), {}, {
+          effects: effects,
+          effectOrder: effects.map(function (e) {
+            return e.id;
+          })
+        })
+      });
+    }
+    test('adds DeckShadowCompositingEffect when shadows exist but no postRender effect', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee15() {
+      var shadowDeckEffect, panelProps, effects;
+      return _regenerator["default"].wrap(function _callee15$(_context15) {
+        while (1) switch (_context15.prev = _context15.next) {
+          case 0:
+            shadowDeckEffect = {
+              id: 'lighting',
+              shadow: true
+            };
+            mockComputeDeckEffects.mockReturnValue([shadowDeckEffect]);
+            _context15.next = 4;
+            return renderAndWaitForPanel(propsWithEffects([mockEffect]));
+          case 4:
+            panelProps = mockExportVideoPanelContainer.mock.calls[0][0];
+            effects = panelProps.deckProps.effects;
+            expect(effects.length).toBe(2);
+            expect(effects[0]).toBe(shadowDeckEffect);
+            expect(effects[1].id).toBe('shadow-compositing-effect');
+            expect(_effects.DeckShadowCompositingEffect).toHaveBeenCalled();
+          case 10:
+          case "end":
+            return _context15.stop();
+        }
+      }, _callee15);
+    })));
+    test('does not add DeckShadowCompositingEffect when a postRender effect already exists', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee16() {
+      var shadowDeckEffect, postProcessEffect, panelProps, effects;
+      return _regenerator["default"].wrap(function _callee16$(_context16) {
+        while (1) switch (_context16.prev = _context16.next) {
+          case 0:
+            shadowDeckEffect = {
+              id: 'lighting',
+              shadow: true
+            };
+            postProcessEffect = {
+              id: 'fog',
+              postRender: jest.fn()
+            };
+            mockComputeDeckEffects.mockReturnValue([shadowDeckEffect, postProcessEffect]);
+            _context16.next = 5;
+            return renderAndWaitForPanel(propsWithEffects([mockEffect]));
+          case 5:
+            panelProps = mockExportVideoPanelContainer.mock.calls[0][0];
+            effects = panelProps.deckProps.effects;
+            expect(effects.length).toBe(2);
+            expect(effects[0]).toBe(shadowDeckEffect);
+            expect(effects[1]).toBe(postProcessEffect);
+            expect(effects.every(function (e) {
+              return e.id !== 'shadow-compositing-effect';
+            })).toBe(true);
+          case 11:
+          case "end":
+            return _context16.stop();
+        }
+      }, _callee16);
+    })));
+    test('does not add DeckShadowCompositingEffect when no shadow effect exists', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee17() {
+      var nonShadowEffect, panelProps, effects;
+      return _regenerator["default"].wrap(function _callee17$(_context17) {
+        while (1) switch (_context17.prev = _context17.next) {
+          case 0:
+            nonShadowEffect = {
+              id: 'lighting',
+              shadow: false
+            };
+            mockComputeDeckEffects.mockReturnValue([nonShadowEffect]);
+            _context17.next = 4;
+            return renderAndWaitForPanel(propsWithEffects([mockEffect]));
+          case 4:
+            panelProps = mockExportVideoPanelContainer.mock.calls[0][0];
+            effects = panelProps.deckProps.effects;
+            expect(effects.length).toBe(1);
+            expect(effects[0]).toBe(nonShadowEffect);
+          case 8:
+          case "end":
+            return _context17.stop();
+        }
+      }, _callee17);
+    })));
+  });
+  describe('devicePixelRatio freeze', function () {
+    var originalDpr = window.devicePixelRatio;
+    afterEach(function () {
+      Object.defineProperty(window, 'devicePixelRatio', {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value: originalDpr
+      });
+    });
+    test('pins devicePixelRatio to export scale and restores it on unmount', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee18() {
+      var _yield$renderAndWaitF4, unmount, exportVideoWidth;
+      return _regenerator["default"].wrap(function _callee18$(_context18) {
+        while (1) switch (_context18.prev = _context18.next) {
+          case 0:
+            _context18.next = 2;
+            return renderAndWaitForPanel();
+          case 2:
+            _yield$renderAndWaitF4 = _context18.sent;
+            unmount = _yield$renderAndWaitF4.unmount;
+            exportVideoWidth = mockExportVideoPanelContainer.mock.calls[0][0].exportVideoWidth;
+            expect(window.devicePixelRatio).toBe(1280 / exportVideoWidth);
+            window.devicePixelRatio = 1;
+            expect(window.devicePixelRatio).toBe(1280 / exportVideoWidth);
+            unmount();
+            expect(window.devicePixelRatio).toBe(originalDpr);
+          case 10:
+          case "end":
+            return _context18.stop();
+        }
+      }, _callee18);
+    })));
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_styledComponents","_reactIntl","_react2","_styles","_localization","_exportVideoModal","_effects","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","mockExportVideoPanelContainer","jest","fn","createElement","MockKeplerUIContext","React","createContext","mock","ExportVideoPanelContainer","props","KeplerUIContext","mockComputeDeckEffects","actual","requireActual","computeDeckEffects","patchDeckRendererForPostProcessing","DeckShadowCompositingEffect","mockImplementation","id","postRender","cleanup","getStaticMapProps","_state","_onChange","_token","latitude","longitude","preserveDrawingBuffer","mapboxApiAccessToken","mapStyle","mapLib","Promise","resolve","getBeforeLayerId","getHubbleDeckGlProps","parameters","blend","controller","views","getTimeRangeFilterKeyframes","getAnimatableFilters","getResolutionSetting","value","_String$split$map","String","split","map","Number","_String$split$map2","_slicedToArray2","width","height","label","renderWithThemeLocal","component","render","ThemeProvider","theme","IntlProvider","locale","messages","ExportVideoModal","ExportVideoModalFactory","DEFAULT_PROPS","mapboxApiUrl","mapState","zoom","styleType","mapStyles","dark","accessToken","bottomMapStyle","topMapStyle","visState","filters","layers","layerBlending","layerOrder","exportVideo","mediaType","cameraPreset","fileName","resolution","durationMs","containerW","visStateActions","setFilterAnimationTime","setLayerAnimationTime","uiStateActions","setExportVideoSetting","onClose","renderAndWaitForPanel","_renderAndWaitForPanel","_asyncToGenerator2","_regenerator","mark","_callee19","result","_args19","wrap","_callee19$","_context19","prev","next","undefined","waitFor","expect","toHaveBeenCalled","abrupt","stop","describe","beforeEach","clearAllMocks","mockReturnValue","test","_callee","_yield$renderAndWaitF","container","_callee$","_context","sent","querySelector","toBeInTheDocument","_callee2","_callee2$","_context2","toHaveBeenCalledTimes","_callee3","panelProps","_callee3$","_context3","calls","header","toBe","disableBaseMap","defaultFileName","exportVideoWidth","toBeLessThanOrEqual","toBeGreaterThanOrEqual","handleClose","initialState","toEqual","mapData","_callee4","_callee4$","_context4","deckProps","_isExport","effects","_callee5","_callee5$","_context5","mapProps","toBeDefined","_callee6","_callee6$","_context6","animatableFilters","_callee7","_callee7$","_context7","_typeof2","_callee8","_callee8$","_context8","onFilterFrameUpdate","toHaveBeenCalledWith","_callee9","_callee9$","_context9","onTripFrameUpdate","NO_MAP_PROPS","no_map","icon","layerGroups","colorMode","style","version","sources","_callee0","_yield$renderAndWaitF2","_callee0$","_context0","_callee1","noMapEntry","encoded","decoded","_callee1$","_context1","url","toMatch","replace","JSON","parse","decodeURIComponent","_callee10","propsWithUrl","_callee10$","_context10","makeFogDeckEffect","effect","setProps","newProps","assign","makeSurfaceFogEffect","deckEffect","overrides","type","isEnabled","animateHeight","heightEnd","linearEasing","clone","propsWithFogEffect","fogEffect","effectOrder","_callee11","originalPostRender","_callee11$","_context11","not","_callee12","_callee12$","_context12","call","_callee13","_callee13$","_context13","_callee14","_yield$renderAndWaitF3","unmount","patchedPostRender","_callee14$","_context14","bind","mockEffect","propsWithEffects","_callee15","shadowDeckEffect","_callee15$","_context15","shadow","_callee16","postProcessEffect","_callee16$","_context16","every","_callee17","nonShadowEffect","_callee17$","_context17","originalDpr","window","devicePixelRatio","afterEach","configurable","writable","_callee18","_yield$renderAndWaitF4","_callee18$","_context18"],"sources":["../../../src/modals/export-video-modal.spec.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n// @ts-nocheck\nimport React from 'react';\nimport {ThemeProvider} from 'styled-components';\nimport {IntlProvider} from 'react-intl';\nimport {render, waitFor} from '@testing-library/react';\nimport {theme} from '@kepler.gl/styles';\nimport {messages} from '@kepler.gl/localization';\n\nconst mockExportVideoPanelContainer = jest.fn(() => (\n  <div data-testid=\"export-video-panel\">Mock Panel</div>\n));\nconst MockKeplerUIContext = React.createContext(null);\n\njest.mock('@hubble.gl/react', () => ({\n  ExportVideoPanelContainer: props => mockExportVideoPanelContainer(props),\n  KeplerUIContext: MockKeplerUIContext\n}));\n\nconst mockComputeDeckEffects = jest.fn(() => []);\n\njest.mock('@kepler.gl/utils', () => {\n  const actual = jest.requireActual('@kepler.gl/utils');\n  return {\n    ...actual,\n    computeDeckEffects: (...args) => mockComputeDeckEffects(...args),\n    patchDeckRendererForPostProcessing: jest.fn()\n  };\n});\n\njest.mock('@kepler.gl/effects', () => ({\n  DeckShadowCompositingEffect: jest.fn().mockImplementation(() => ({\n    id: 'shadow-compositing-effect',\n    postRender: jest.fn(),\n    cleanup: jest.fn()\n  }))\n}));\n\njest.mock('./hubble-utils', () => ({\n  getStaticMapProps: jest.fn((_state, _onChange, _token) => ({\n    latitude: 37.7,\n    longitude: -122.4,\n    preserveDrawingBuffer: true,\n    mapboxApiAccessToken: 'style-token',\n    mapStyle: {id: 'dark-style'},\n    mapLib: Promise.resolve({})\n  })),\n  getBeforeLayerId: jest.fn(() => null),\n  getHubbleDeckGlProps: jest.fn(() => ({\n    parameters: {blend: true},\n    controller: true,\n    views: {}\n  })),\n  getTimeRangeFilterKeyframes: jest.fn(),\n  getAnimatableFilters: jest.fn(() => []),\n  getResolutionSetting: jest.fn(value => {\n    const [width, height] = String(value || '1280x720').split('x').map(Number);\n    return {value, width, height, label: value};\n  })\n}));\n\nimport ExportVideoModalFactory from './export-video-modal';\nimport {DeckShadowCompositingEffect} from '@kepler.gl/effects';\n\nfunction renderWithThemeLocal(component) {\n  return render(\n    <ThemeProvider theme={theme}>\n      <IntlProvider locale=\"en\" messages={messages}>\n        {component}\n      </IntlProvider>\n    </ThemeProvider>\n  );\n}\n\nconst ExportVideoModal = ExportVideoModalFactory();\n\nconst DEFAULT_PROPS = {\n  mapboxApiAccessToken: 'test-token',\n  mapboxApiUrl: 'https://api.mapbox.com',\n  mapState: {latitude: 37.7, longitude: -122.4, zoom: 10},\n  mapStyle: {\n    styleType: 'dark',\n    mapStyles: {dark: {accessToken: 'style-token'}},\n    bottomMapStyle: {id: 'dark-style'},\n    topMapStyle: null\n  },\n  visState: {\n    filters: [],\n    layers: [],\n    layerBlending: 'normal',\n    layerOrder: []\n  },\n  exportVideo: {\n    mediaType: 'webm',\n    cameraPreset: 'None',\n    fileName: 'kepler.gl',\n    resolution: '1280x720',\n    durationMs: 1000\n  },\n  containerW: 800,\n  visStateActions: {\n    setFilterAnimationTime: jest.fn(),\n    setLayerAnimationTime: jest.fn()\n  },\n  uiStateActions: {\n    setExportVideoSetting: jest.fn()\n  },\n  onClose: jest.fn()\n};\n\nasync function renderAndWaitForPanel(props = DEFAULT_PROPS) {\n  const result = renderWithThemeLocal(<ExportVideoModal {...props} />);\n  await waitFor(() => {\n    expect(mockExportVideoPanelContainer).toHaveBeenCalled();\n  });\n  return result;\n}\n\ndescribe('ExportVideoModal', () => {\n  beforeEach(() => {\n    jest.clearAllMocks();\n    mockComputeDeckEffects.mockReturnValue([]);\n  });\n\n  test('renders without crashing', async () => {\n    const {container} = await renderAndWaitForPanel();\n    expect(container.querySelector('.export-video-modal')).toBeInTheDocument();\n  });\n\n  test('provides KeplerUI context with expected components', async () => {\n    await renderAndWaitForPanel();\n    expect(mockExportVideoPanelContainer).toHaveBeenCalledTimes(1);\n  });\n\n  test('passes correct props to ExportVideoPanelContainer', async () => {\n    await renderAndWaitForPanel();\n\n    expect(mockExportVideoPanelContainer).toHaveBeenCalledTimes(1);\n    const panelProps = mockExportVideoPanelContainer.mock.calls[0][0];\n\n    expect(panelProps.header).toBe(false);\n    expect(panelProps.disableBaseMap).toBe(false);\n    expect(panelProps.defaultFileName).toBe('kepler.gl');\n    expect(panelProps.exportVideoWidth).toBeLessThanOrEqual(540);\n    expect(panelProps.exportVideoWidth).toBeGreaterThanOrEqual(320);\n    expect(panelProps.handleClose).toBe(DEFAULT_PROPS.onClose);\n    expect(panelProps.initialState).toEqual(DEFAULT_PROPS.exportVideo);\n    expect(panelProps.mapData).toEqual({\n      visState: DEFAULT_PROPS.visState,\n      mapState: DEFAULT_PROPS.mapState,\n      mapStyle: DEFAULT_PROPS.mapStyle\n    });\n  });\n\n  test('passes deckProps from getHubbleDeckGlProps', async () => {\n    await renderAndWaitForPanel();\n\n    const panelProps = mockExportVideoPanelContainer.mock.calls[0][0];\n    expect(panelProps.deckProps).toEqual({\n      parameters: {blend: true},\n      controller: true,\n      views: {},\n      _isExport: true,\n      effects: []\n    });\n  });\n\n  test('passes mapProps from getStaticMapProps', async () => {\n    await renderAndWaitForPanel();\n\n    const panelProps = mockExportVideoPanelContainer.mock.calls[0][0];\n    expect(panelProps.mapProps.latitude).toBe(37.7);\n    expect(panelProps.mapProps.longitude).toBe(-122.4);\n    expect(panelProps.mapProps.preserveDrawingBuffer).toBe(true);\n    expect(panelProps.mapProps.mapboxApiAccessToken).toBe('style-token');\n    expect(panelProps.mapProps.mapStyle).toEqual({id: 'dark-style'});\n    expect(panelProps.mapProps.mapLib).toBeDefined();\n  });\n\n  test('passes empty animatableFilters when no matching filters', async () => {\n    await renderAndWaitForPanel();\n\n    const panelProps = mockExportVideoPanelContainer.mock.calls[0][0];\n    expect(panelProps.animatableFilters).toEqual([]);\n  });\n\n  test('provides getTimeRangeFilterKeyframes callback', async () => {\n    await renderAndWaitForPanel();\n\n    const panelProps = mockExportVideoPanelContainer.mock.calls[0][0];\n    expect(typeof panelProps.getTimeRangeFilterKeyframes).toBe('function');\n  });\n\n  test('provides onFilterFrameUpdate that calls visStateActions', async () => {\n    await renderAndWaitForPanel();\n\n    const panelProps = mockExportVideoPanelContainer.mock.calls[0][0];\n    panelProps.onFilterFrameUpdate(0, 'value', [100, 200]);\n    expect(DEFAULT_PROPS.visStateActions.setFilterAnimationTime).toHaveBeenCalledWith(\n      0,\n      'value',\n      [100, 200]\n    );\n  });\n\n  test('provides onTripFrameUpdate that calls visStateActions', async () => {\n    await renderAndWaitForPanel();\n\n    const panelProps = mockExportVideoPanelContainer.mock.calls[0][0];\n    panelProps.onTripFrameUpdate(42);\n    expect(DEFAULT_PROPS.visStateActions.setLayerAnimationTime).toHaveBeenCalledWith(42);\n  });\n\n  describe('NO_MAP_ID handling', () => {\n    const NO_MAP_PROPS = {\n      ...DEFAULT_PROPS,\n      mapStyle: {\n        styleType: 'no_map',\n        mapStyles: {\n          no_map: {\n            id: 'no_map',\n            label: 'No Basemap',\n            // url is intentionally missing to exercise the data-URI patch\n            icon: '',\n            layerGroups: [],\n            colorMode: 'NONE',\n            style: {version: 8, sources: {}, layers: []}\n          }\n        },\n        bottomMapStyle: null,\n        topMapStyle: null\n      }\n    };\n\n    test('renders without crashing when styleType is NO_MAP_ID', async () => {\n      const {container} = await renderAndWaitForPanel(NO_MAP_PROPS);\n      expect(container.querySelector('.export-video-modal')).toBeInTheDocument();\n    });\n\n    test('injects data-URI empty style URL into mapData when NO_MAP_ID entry has no url', async () => {\n      await renderAndWaitForPanel(NO_MAP_PROPS);\n\n      const panelProps = mockExportVideoPanelContainer.mock.calls[0][0];\n      const noMapEntry = panelProps.mapData.mapStyle.mapStyles.no_map;\n\n      expect(noMapEntry.url).toBeDefined();\n      expect(noMapEntry.url).toMatch(/^data:application\\/json,/);\n\n      const encoded = noMapEntry.url.replace('data:application/json,', '');\n      const decoded = JSON.parse(decodeURIComponent(encoded));\n      expect(decoded).toEqual({version: 8, sources: {}, layers: []});\n    });\n\n    test('preserves original mapStyle when NO_MAP_ID entry already has a url', async () => {\n      const propsWithUrl = {\n        ...DEFAULT_PROPS,\n        mapStyle: {\n          styleType: 'no_map',\n          mapStyles: {\n            no_map: {\n              id: 'no_map',\n              url: 'https://existing-style.json'\n            }\n          },\n          bottomMapStyle: null,\n          topMapStyle: null\n        }\n      };\n\n      await renderAndWaitForPanel(propsWithUrl);\n\n      const panelProps = mockExportVideoPanelContainer.mock.calls[0][0];\n      expect(panelProps.mapData.mapStyle).toBe(propsWithUrl.mapStyle);\n    });\n  });\n\n  describe('surface fog height animation', () => {\n    function makeFogDeckEffect() {\n      const effect = {\n        id: 'surface-fog-deck',\n        props: {height: 50},\n        postRender: jest.fn(),\n        setProps: jest.fn(function (newProps) {\n          Object.assign(effect.props, newProps);\n        })\n      };\n      return effect;\n    }\n\n    function makeSurfaceFogEffect(deckEffect, overrides = {}) {\n      const effect = {\n        id: 'fog-1',\n        type: 'surfaceFog',\n        isEnabled: true,\n        parameters: {\n          height: 50,\n          animateHeight: true,\n          heightEnd: 200,\n          linearEasing: false,\n          ...overrides\n        },\n        deckEffect,\n        clone: jest.fn()\n      };\n      // clone returns a fresh reference that still points to the same deckEffect\n      effect.clone.mockImplementation(() => ({...effect, clone: effect.clone}));\n      return effect;\n    }\n\n    function propsWithFogEffect(fogEffect) {\n      return {\n        ...DEFAULT_PROPS,\n        visState: {\n          ...DEFAULT_PROPS.visState,\n          effects: [fogEffect],\n          effectOrder: [fogEffect.id]\n        }\n      };\n    }\n\n    test('patches deckEffect.postRender when animateHeight is enabled', async () => {\n      const deckEffect = makeFogDeckEffect();\n      const originalPostRender = deckEffect.postRender;\n      const fogEffect = makeSurfaceFogEffect(deckEffect);\n      mockComputeDeckEffects.mockReturnValue([deckEffect]);\n\n      await renderAndWaitForPanel(propsWithFogEffect(fogEffect));\n\n      expect(deckEffect.postRender).not.toBe(originalPostRender);\n    });\n\n    test('restores original height when hubble is not playing', async () => {\n      const deckEffect = makeFogDeckEffect();\n      deckEffect.props.height = 75;\n      const fogEffect = makeSurfaceFogEffect(deckEffect, {height: 75});\n      mockComputeDeckEffects.mockReturnValue([deckEffect]);\n\n      await renderAndWaitForPanel(propsWithFogEffect(fogEffect));\n\n      // Call the patched postRender without hubble playing\n      deckEffect.postRender.call(deckEffect, {});\n\n      // Not playing → height resets to originalHeight\n      expect(deckEffect.props.height).toBe(75);\n    });\n\n    test('does not mutate height when animateHeight is disabled', async () => {\n      const deckEffect = makeFogDeckEffect();\n      const fogEffect = makeSurfaceFogEffect(deckEffect, {animateHeight: false});\n      mockComputeDeckEffects.mockReturnValue([deckEffect]);\n\n      await renderAndWaitForPanel(propsWithFogEffect(fogEffect));\n\n      deckEffect.props.height = 42;\n      deckEffect.postRender.call(deckEffect, {});\n\n      // ref.active is false so height should not be touched\n      expect(deckEffect.props.height).toBe(42);\n    });\n\n    test('restores original postRender on unmount', async () => {\n      const deckEffect = makeFogDeckEffect();\n      const fogEffect = makeSurfaceFogEffect(deckEffect);\n      mockComputeDeckEffects.mockReturnValue([deckEffect]);\n\n      const {unmount} = await renderAndWaitForPanel(propsWithFogEffect(fogEffect));\n\n      // postRender was patched (the wrapper function drives animation)\n      const patchedPostRender = deckEffect.postRender;\n      // Verify it's not the original mock (component binds and wraps it)\n      expect(patchedPostRender).not.toBe(deckEffect.postRender.bind(deckEffect));\n\n      unmount();\n\n      // After unmount, postRender no longer drives animation.\n      // The restored function is a bound copy of the original mock.\n      deckEffect.props.height = 99;\n      deckEffect.postRender.call(deckEffect, {});\n      // Height should NOT be mutated by animation logic anymore\n      expect(deckEffect.props.height).toBe(99);\n    });\n  });\n\n  describe('shadow compositing fallback', () => {\n    const mockEffect = {\n      id: 'light-shadow-1',\n      type: 'light-and-shadow',\n      isEnabled: true,\n      clone: jest.fn(() => ({...mockEffect, clone: mockEffect.clone}))\n    };\n\n    function propsWithEffects(effects) {\n      return {\n        ...DEFAULT_PROPS,\n        visState: {\n          ...DEFAULT_PROPS.visState,\n          effects,\n          effectOrder: effects.map(e => e.id)\n        }\n      };\n    }\n\n    test('adds DeckShadowCompositingEffect when shadows exist but no postRender effect', async () => {\n      const shadowDeckEffect = {id: 'lighting', shadow: true};\n      mockComputeDeckEffects.mockReturnValue([shadowDeckEffect]);\n\n      await renderAndWaitForPanel(propsWithEffects([mockEffect]));\n\n      const panelProps = mockExportVideoPanelContainer.mock.calls[0][0];\n      const effects = panelProps.deckProps.effects;\n\n      expect(effects.length).toBe(2);\n      expect(effects[0]).toBe(shadowDeckEffect);\n      expect(effects[1].id).toBe('shadow-compositing-effect');\n      expect(DeckShadowCompositingEffect).toHaveBeenCalled();\n    });\n\n    test('does not add DeckShadowCompositingEffect when a postRender effect already exists', async () => {\n      const shadowDeckEffect = {id: 'lighting', shadow: true};\n      const postProcessEffect = {id: 'fog', postRender: jest.fn()};\n      mockComputeDeckEffects.mockReturnValue([shadowDeckEffect, postProcessEffect]);\n\n      await renderAndWaitForPanel(propsWithEffects([mockEffect]));\n\n      const panelProps = mockExportVideoPanelContainer.mock.calls[0][0];\n      const effects = panelProps.deckProps.effects;\n\n      expect(effects.length).toBe(2);\n      expect(effects[0]).toBe(shadowDeckEffect);\n      expect(effects[1]).toBe(postProcessEffect);\n      expect(effects.every(e => e.id !== 'shadow-compositing-effect')).toBe(true);\n    });\n\n    test('does not add DeckShadowCompositingEffect when no shadow effect exists', async () => {\n      const nonShadowEffect = {id: 'lighting', shadow: false};\n      mockComputeDeckEffects.mockReturnValue([nonShadowEffect]);\n\n      await renderAndWaitForPanel(propsWithEffects([mockEffect]));\n\n      const panelProps = mockExportVideoPanelContainer.mock.calls[0][0];\n      const effects = panelProps.deckProps.effects;\n\n      expect(effects.length).toBe(1);\n      expect(effects[0]).toBe(nonShadowEffect);\n    });\n  });\n\n  describe('devicePixelRatio freeze', () => {\n    const originalDpr = window.devicePixelRatio;\n\n    afterEach(() => {\n      Object.defineProperty(window, 'devicePixelRatio', {\n        configurable: true,\n        enumerable: true,\n        writable: true,\n        value: originalDpr\n      });\n    });\n\n    test('pins devicePixelRatio to export scale and restores it on unmount', async () => {\n      const {unmount} = await renderAndWaitForPanel();\n      const {exportVideoWidth} = mockExportVideoPanelContainer.mock.calls[0][0];\n\n      expect(window.devicePixelRatio).toBe(1280 / exportVideoWidth);\n\n      window.devicePixelRatio = 1;\n      expect(window.devicePixelRatio).toBe(1280 / exportVideoWidth);\n\n      unmount();\n      expect(window.devicePixelRatio).toBe(originalDpr);\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}