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

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

@@ -0,0 +1,397 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _constants = require("@kepler.gl/constants");
+var _hubbleUtils = require("./hubble-utils");
+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
+jest.mock('@kepler.gl/utils', function () {
+  return _objectSpread(_objectSpread({}, jest.requireActual('@kepler.gl/utils')), {}, {
+    getBaseMapLibrary: jest.fn(function () {
+      return 'maplibre';
+    })
+  });
+});
+jest.mock('maplibregl-mapbox-request-transformer', function () {
+  return {
+    isMapboxURL: jest.fn(function (url) {
+      return url.startsWith('mapbox:');
+    }),
+    transformMapboxUrl: jest.fn(function (url, _resourceType, token) {
+      return {
+        url: "".concat(url.replace('mapbox://', 'https://api.mapbox.com/'), "?access_token=").concat(token)
+      };
+    })
+  };
+});
+describe('hubble-utils', function () {
+  describe('getTimeRangeFilterKeyframes', function () {
+    var baseFilter = {
+      type: _constants.FILTER_TYPES.timeRange,
+      domain: [100, 500],
+      value: [200, 300],
+      animationWindow: 'free',
+      plotType: {
+        interval: null
+      },
+      timeBins: null,
+      dataId: ['dataset1']
+    };
+    test('throws when filter type is not timeRange', function () {
+      expect(function () {
+        return (0, _hubbleUtils.getTimeRangeFilterKeyframes)({
+          filter: _objectSpread(_objectSpread({}, baseFilter), {}, {
+            type: 'range'
+          }),
+          timings: [0, 1000]
+        });
+      }).toThrow("filter type must be 'timeRange'.");
+    });
+    test('returns free keyframes by default', function () {
+      var result = (0, _hubbleUtils.getTimeRangeFilterKeyframes)({
+        filter: baseFilter,
+        timings: [0, 1000]
+      });
+      var delta = baseFilter.value[1] - baseFilter.value[0]; // 100
+      expect(result.keyframes).toEqual([{
+        value: [100, 100 + delta]
+      }, {
+        value: [500 - delta, 500]
+      }]);
+      expect((0, _typeof2["default"])(result.easings)).toBe('function');
+      expect(result.easings(0.5)).toBe(0.5);
+    });
+    test('returns incremental keyframes', function () {
+      var result = (0, _hubbleUtils.getTimeRangeFilterKeyframes)({
+        filter: _objectSpread(_objectSpread({}, baseFilter), {}, {
+          animationWindow: 'incremental'
+        }),
+        timings: [0, 1000]
+      });
+      expect(result.keyframes).toEqual([{
+        value: [200, 201]
+      }, {
+        value: [200, 500]
+      }]);
+    });
+    test('returns point keyframes', function () {
+      var result = (0, _hubbleUtils.getTimeRangeFilterKeyframes)({
+        filter: _objectSpread(_objectSpread({}, baseFilter), {}, {
+          animationWindow: 'point'
+        }),
+        timings: [0, 1000]
+      });
+      expect(result.keyframes).toEqual([{
+        value: 100
+      }, {
+        value: 500
+      }]);
+    });
+    test('returns interval keyframes with bins', function () {
+      var bins = [{
+        x0: 100,
+        x1: 200
+      }, {
+        x0: 200,
+        x1: 300
+      }, {
+        x0: 300,
+        x1: 400
+      }];
+      var filter = _objectSpread(_objectSpread({}, baseFilter), {}, {
+        animationWindow: 'interval',
+        plotType: {
+          interval: 'day'
+        },
+        timeBins: {
+          dataset1: {
+            day: bins
+          }
+        },
+        dataId: ['dataset1']
+      });
+      var result = (0, _hubbleUtils.getTimeRangeFilterKeyframes)({
+        filter: filter,
+        timings: [0, 900]
+      });
+      expect(result.keyframes).toEqual([{
+        value: [100, 200]
+      }, {
+        value: [200, 300]
+      }, {
+        value: [300, 400]
+      }]);
+      expect(result.timings).toEqual([0, 300, 600]);
+      // hold easing: returns 0 unless p === 1
+      expect(result.easings(0)).toBe(0);
+      expect(result.easings(0.5)).toBe(0);
+      expect(result.easings(1)).toBe(1);
+    });
+    test('falls back to free keyframes when interval has no bins', function () {
+      var filter = _objectSpread(_objectSpread({}, baseFilter), {}, {
+        animationWindow: 'interval',
+        plotType: {
+          interval: null
+        },
+        timeBins: null
+      });
+      var result = (0, _hubbleUtils.getTimeRangeFilterKeyframes)({
+        filter: filter,
+        timings: [0, 1000]
+      });
+      var delta = baseFilter.value[1] - baseFilter.value[0];
+      expect(result.keyframes).toEqual([{
+        value: [100, 100 + delta]
+      }, {
+        value: [500 - delta, 500]
+      }]);
+    });
+  });
+  describe('getBeforeLayerId', function () {
+    test('returns null when topMapStyle is null', function () {
+      expect((0, _hubbleUtils.getBeforeLayerId)(null, {
+        layers: [{
+          id: 'a'
+        }]
+      })).toBeNull();
+    });
+    test('returns null when bottomMapStyle is null', function () {
+      expect((0, _hubbleUtils.getBeforeLayerId)({
+        layers: [{
+          id: 'a'
+        }]
+      }, null)).toBeNull();
+    });
+    test('returns null when either has empty layers', function () {
+      expect((0, _hubbleUtils.getBeforeLayerId)({
+        layers: []
+      }, {
+        layers: [{
+          id: 'a'
+        }]
+      })).toBeNull();
+    });
+    test('returns the layer before the first top layer in the bottom style', function () {
+      var topMapStyle = {
+        layers: [{
+          id: 'layer-b'
+        }]
+      };
+      var bottomMapStyle = {
+        layers: [{
+          id: 'layer-a'
+        }, {
+          id: 'layer-b'
+        }, {
+          id: 'layer-c'
+        }]
+      };
+      var result = (0, _hubbleUtils.getBeforeLayerId)(topMapStyle, bottomMapStyle);
+      expect(result).toEqual({
+        id: 'layer-a'
+      });
+    });
+    test('returns null when first top layer is at index 0 in bottom style', function () {
+      var topMapStyle = {
+        layers: [{
+          id: 'layer-a'
+        }]
+      };
+      var bottomMapStyle = {
+        layers: [{
+          id: 'layer-a'
+        }, {
+          id: 'layer-b'
+        }]
+      };
+      expect((0, _hubbleUtils.getBeforeLayerId)(topMapStyle, bottomMapStyle)).toBeNull();
+    });
+    test('returns null when first top layer is not found in bottom style', function () {
+      var topMapStyle = {
+        layers: [{
+          id: 'missing'
+        }]
+      };
+      var bottomMapStyle = {
+        layers: [{
+          id: 'layer-a'
+        }, {
+          id: 'layer-b'
+        }]
+      };
+      expect((0, _hubbleUtils.getBeforeLayerId)(topMapStyle, bottomMapStyle)).toBeNull();
+    });
+  });
+  describe('getStaticMapProps', function () {
+    var mockKeplerState = {
+      visState: {},
+      mapState: {
+        latitude: 37.7,
+        longitude: -122.4,
+        zoom: 10
+      },
+      mapStyle: {
+        styleType: 'dark',
+        mapStyles: {
+          dark: {
+            accessToken: 'style-token'
+          }
+        },
+        bottomMapStyle: {
+          id: 'dark-map-style'
+        }
+      }
+    };
+    var onViewChange = jest.fn();
+    test('spreads mapState into result', function () {
+      var result = (0, _hubbleUtils.getStaticMapProps)(mockKeplerState, onViewChange, 'global-token');
+      expect(result.latitude).toBe(37.7);
+      expect(result.longitude).toBe(-122.4);
+      expect(result.zoom).toBe(10);
+    });
+    test('uses style accessToken when available', function () {
+      var result = (0, _hubbleUtils.getStaticMapProps)(mockKeplerState, onViewChange, 'global-token');
+      expect(result.mapboxApiAccessToken).toBe('style-token');
+    });
+    test('falls back to global token when style has no accessToken', function () {
+      var state = _objectSpread(_objectSpread({}, mockKeplerState), {}, {
+        mapStyle: _objectSpread(_objectSpread({}, mockKeplerState.mapStyle), {}, {
+          mapStyles: {
+            dark: {}
+          }
+        })
+      });
+      var result = (0, _hubbleUtils.getStaticMapProps)(state, onViewChange, 'global-token');
+      expect(result.mapboxApiAccessToken).toBe('global-token');
+    });
+    test('sets preserveDrawingBuffer to true', function () {
+      var result = (0, _hubbleUtils.getStaticMapProps)(mockKeplerState, onViewChange, 'token');
+      expect(result.preserveDrawingBuffer).toBe(true);
+    });
+    test('passes bottomMapStyle as mapStyle', function () {
+      var result = (0, _hubbleUtils.getStaticMapProps)(mockKeplerState, onViewChange, 'token');
+      expect(result.mapStyle).toEqual({
+        id: 'dark-map-style'
+      });
+    });
+    test('passes onViewChange as onViewportChange', function () {
+      var result = (0, _hubbleUtils.getStaticMapProps)(mockKeplerState, onViewChange, 'token');
+      expect(result.onViewportChange).toBe(onViewChange);
+    });
+    test('includes mapLib as a Promise (always maplibre-gl)', function () {
+      var result = (0, _hubbleUtils.getStaticMapProps)(mockKeplerState, onViewChange, 'token');
+      expect(result.mapLib).toBeDefined();
+      expect(result.mapLib).toBeInstanceOf(Promise);
+    });
+    test('provides transformRequest that handles mapbox:// URLs', function () {
+      var result = (0, _hubbleUtils.getStaticMapProps)(mockKeplerState, onViewChange, 'global-token');
+      expect((0, _typeof2["default"])(result.transformRequest)).toBe('function');
+      var transformed = result.transformRequest('mapbox://styles/user/style1', 'Style');
+      expect(transformed.url).toContain('api.mapbox.com');
+      var regular = result.transformRequest('https://example.com/tiles', 'Source');
+      expect(regular.url).toBe('https://example.com/tiles');
+    });
+    test('converts mapbox:// URLs in style object for mapbox styles', function () {
+      var _require = require('@kepler.gl/utils'),
+        getBaseMapLibrary = _require.getBaseMapLibrary;
+      getBaseMapLibrary.mockReturnValueOnce('mapbox');
+      var state = _objectSpread(_objectSpread({}, mockKeplerState), {}, {
+        mapStyle: _objectSpread(_objectSpread({}, mockKeplerState.mapStyle), {}, {
+          bottomMapStyle: {
+            id: 'mapbox-style',
+            sprite: 'mapbox://sprites/user/style1',
+            glyphs: 'mapbox://fonts/user/{fontstack}/{range}.pbf',
+            sources: {
+              composite: {
+                url: 'mapbox://mapbox.mapbox-streets-v8'
+              }
+            }
+          }
+        })
+      });
+      var result = (0, _hubbleUtils.getStaticMapProps)(state, onViewChange, 'token');
+      expect(result.mapStyle.sprite).toContain('api.mapbox.com');
+      expect(result.mapStyle.glyphs).toContain('api.mapbox.com');
+      expect(result.mapStyle.sources.composite.url).toContain('api.mapbox.com');
+    });
+    test('does not convert style URLs for non-mapbox styles', function () {
+      var result = (0, _hubbleUtils.getStaticMapProps)(mockKeplerState, onViewChange, 'token');
+      expect(result.mapStyle).toEqual({
+        id: 'dark-map-style'
+      });
+    });
+  });
+  describe('getAnimatableFilters', function () {
+    test('returns empty array when no filters', function () {
+      var state = {
+        visState: {
+          filters: []
+        },
+        mapState: {},
+        mapStyle: {}
+      };
+      expect((0, _hubbleUtils.getAnimatableFilters)(state)).toEqual([]);
+    });
+    test('returns empty array when visState.filters is undefined', function () {
+      var state = {
+        visState: {},
+        mapState: {},
+        mapStyle: {}
+      };
+      expect((0, _hubbleUtils.getAnimatableFilters)(state)).toEqual([]);
+    });
+    test('filters only timeRange filters with enlarged view', function () {
+      var filters = [{
+        type: _constants.FILTER_TYPES.timeRange,
+        view: _constants.FILTER_VIEW_TYPES.enlarged,
+        id: 'f1'
+      }, {
+        type: _constants.FILTER_TYPES.range,
+        view: _constants.FILTER_VIEW_TYPES.enlarged,
+        id: 'f2'
+      }, {
+        type: _constants.FILTER_TYPES.timeRange,
+        view: _constants.FILTER_VIEW_TYPES.side,
+        id: 'f3'
+      }];
+      var state = {
+        visState: {
+          filters: filters
+        },
+        mapState: {},
+        mapStyle: {}
+      };
+      var result = (0, _hubbleUtils.getAnimatableFilters)(state);
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('f1');
+    });
+    test('includes timeRange filters synced with layer timeline', function () {
+      var filters = [{
+        type: _constants.FILTER_TYPES.timeRange,
+        view: _constants.FILTER_VIEW_TYPES.side,
+        syncedWithLayerTimeline: true,
+        id: 'synced'
+      }, {
+        type: _constants.FILTER_TYPES.timeRange,
+        view: _constants.FILTER_VIEW_TYPES.side,
+        syncedWithLayerTimeline: false,
+        id: 'not-synced'
+      }];
+      var state = {
+        visState: {
+          filters: filters
+        },
+        mapState: {},
+        mapStyle: {}
+      };
+      var result = (0, _hubbleUtils.getAnimatableFilters)(state);
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('synced');
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_constants","require","_hubbleUtils","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","jest","mock","requireActual","getBaseMapLibrary","fn","isMapboxURL","url","startsWith","transformMapboxUrl","_resourceType","token","concat","replace","describe","baseFilter","type","FILTER_TYPES","timeRange","domain","value","animationWindow","plotType","interval","timeBins","dataId","test","expect","getTimeRangeFilterKeyframes","timings","toThrow","result","delta","keyframes","toEqual","_typeof2","easings","toBe","bins","x0","x1","dataset1","day","getBeforeLayerId","layers","id","toBeNull","topMapStyle","bottomMapStyle","mockKeplerState","visState","mapState","latitude","longitude","zoom","mapStyle","styleType","mapStyles","dark","accessToken","onViewChange","getStaticMapProps","mapboxApiAccessToken","state","preserveDrawingBuffer","onViewportChange","mapLib","toBeDefined","toBeInstanceOf","Promise","transformRequest","transformed","toContain","regular","_require","mockReturnValueOnce","sprite","glyphs","sources","composite","filters","getAnimatableFilters","view","FILTER_VIEW_TYPES","enlarged","range","side","toHaveLength","syncedWithLayerTimeline"],"sources":["../../src/modals/hubble-utils.spec.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n// @ts-nocheck\nimport {FILTER_TYPES, FILTER_VIEW_TYPES} from '@kepler.gl/constants';\nimport {\n  getTimeRangeFilterKeyframes,\n  getBeforeLayerId,\n  getStaticMapProps,\n  getAnimatableFilters\n} from './hubble-utils';\n\njest.mock('@kepler.gl/utils', () => ({\n  ...jest.requireActual('@kepler.gl/utils'),\n  getBaseMapLibrary: jest.fn(() => 'maplibre')\n}));\n\njest.mock('maplibregl-mapbox-request-transformer', () => ({\n  isMapboxURL: jest.fn((url: string) => url.startsWith('mapbox:')),\n  transformMapboxUrl: jest.fn((url: string, _resourceType: string, token: string) => ({\n    url: `${url.replace('mapbox://', 'https://api.mapbox.com/')}?access_token=${token}`\n  }))\n}));\n\ndescribe('hubble-utils', () => {\n  describe('getTimeRangeFilterKeyframes', () => {\n    const baseFilter = {\n      type: FILTER_TYPES.timeRange,\n      domain: [100, 500],\n      value: [200, 300],\n      animationWindow: 'free',\n      plotType: {interval: null},\n      timeBins: null,\n      dataId: ['dataset1']\n    };\n\n    test('throws when filter type is not timeRange', () => {\n      expect(() =>\n        getTimeRangeFilterKeyframes({\n          filter: {...baseFilter, type: 'range'},\n          timings: [0, 1000]\n        })\n      ).toThrow(\"filter type must be 'timeRange'.\");\n    });\n\n    test('returns free keyframes by default', () => {\n      const result = getTimeRangeFilterKeyframes({\n        filter: baseFilter,\n        timings: [0, 1000]\n      });\n\n      const delta = baseFilter.value[1] - baseFilter.value[0]; // 100\n      expect(result.keyframes).toEqual([{value: [100, 100 + delta]}, {value: [500 - delta, 500]}]);\n      expect(typeof result.easings).toBe('function');\n      expect(result.easings(0.5)).toBe(0.5);\n    });\n\n    test('returns incremental keyframes', () => {\n      const result = getTimeRangeFilterKeyframes({\n        filter: {...baseFilter, animationWindow: 'incremental'},\n        timings: [0, 1000]\n      });\n\n      expect(result.keyframes).toEqual([{value: [200, 201]}, {value: [200, 500]}]);\n    });\n\n    test('returns point keyframes', () => {\n      const result = getTimeRangeFilterKeyframes({\n        filter: {...baseFilter, animationWindow: 'point'},\n        timings: [0, 1000]\n      });\n\n      expect(result.keyframes).toEqual([{value: 100}, {value: 500}]);\n    });\n\n    test('returns interval keyframes with bins', () => {\n      const bins = [\n        {x0: 100, x1: 200},\n        {x0: 200, x1: 300},\n        {x0: 300, x1: 400}\n      ];\n      const filter = {\n        ...baseFilter,\n        animationWindow: 'interval',\n        plotType: {interval: 'day'},\n        timeBins: {dataset1: {day: bins}},\n        dataId: ['dataset1']\n      };\n\n      const result = getTimeRangeFilterKeyframes({\n        filter,\n        timings: [0, 900]\n      });\n\n      expect(result.keyframes).toEqual([\n        {value: [100, 200]},\n        {value: [200, 300]},\n        {value: [300, 400]}\n      ]);\n      expect(result.timings).toEqual([0, 300, 600]);\n      // hold easing: returns 0 unless p === 1\n      expect(result.easings(0)).toBe(0);\n      expect(result.easings(0.5)).toBe(0);\n      expect(result.easings(1)).toBe(1);\n    });\n\n    test('falls back to free keyframes when interval has no bins', () => {\n      const filter = {\n        ...baseFilter,\n        animationWindow: 'interval',\n        plotType: {interval: null},\n        timeBins: null\n      };\n\n      const result = getTimeRangeFilterKeyframes({\n        filter,\n        timings: [0, 1000]\n      });\n\n      const delta = baseFilter.value[1] - baseFilter.value[0];\n      expect(result.keyframes).toEqual([{value: [100, 100 + delta]}, {value: [500 - delta, 500]}]);\n    });\n  });\n\n  describe('getBeforeLayerId', () => {\n    test('returns null when topMapStyle is null', () => {\n      expect(getBeforeLayerId(null, {layers: [{id: 'a'}]})).toBeNull();\n    });\n\n    test('returns null when bottomMapStyle is null', () => {\n      expect(getBeforeLayerId({layers: [{id: 'a'}]}, null)).toBeNull();\n    });\n\n    test('returns null when either has empty layers', () => {\n      expect(getBeforeLayerId({layers: []}, {layers: [{id: 'a'}]})).toBeNull();\n    });\n\n    test('returns the layer before the first top layer in the bottom style', () => {\n      const topMapStyle = {layers: [{id: 'layer-b'}]};\n      const bottomMapStyle = {\n        layers: [{id: 'layer-a'}, {id: 'layer-b'}, {id: 'layer-c'}]\n      };\n\n      const result = getBeforeLayerId(topMapStyle, bottomMapStyle);\n      expect(result).toEqual({id: 'layer-a'});\n    });\n\n    test('returns null when first top layer is at index 0 in bottom style', () => {\n      const topMapStyle = {layers: [{id: 'layer-a'}]};\n      const bottomMapStyle = {layers: [{id: 'layer-a'}, {id: 'layer-b'}]};\n\n      expect(getBeforeLayerId(topMapStyle, bottomMapStyle)).toBeNull();\n    });\n\n    test('returns null when first top layer is not found in bottom style', () => {\n      const topMapStyle = {layers: [{id: 'missing'}]};\n      const bottomMapStyle = {layers: [{id: 'layer-a'}, {id: 'layer-b'}]};\n\n      expect(getBeforeLayerId(topMapStyle, bottomMapStyle)).toBeNull();\n    });\n  });\n\n  describe('getStaticMapProps', () => {\n    const mockKeplerState = {\n      visState: {},\n      mapState: {latitude: 37.7, longitude: -122.4, zoom: 10},\n      mapStyle: {\n        styleType: 'dark',\n        mapStyles: {\n          dark: {accessToken: 'style-token'}\n        },\n        bottomMapStyle: {id: 'dark-map-style'}\n      }\n    };\n    const onViewChange = jest.fn();\n\n    test('spreads mapState into result', () => {\n      const result = getStaticMapProps(mockKeplerState, onViewChange, 'global-token');\n\n      expect(result.latitude).toBe(37.7);\n      expect(result.longitude).toBe(-122.4);\n      expect(result.zoom).toBe(10);\n    });\n\n    test('uses style accessToken when available', () => {\n      const result = getStaticMapProps(mockKeplerState, onViewChange, 'global-token');\n      expect(result.mapboxApiAccessToken).toBe('style-token');\n    });\n\n    test('falls back to global token when style has no accessToken', () => {\n      const state = {\n        ...mockKeplerState,\n        mapStyle: {\n          ...mockKeplerState.mapStyle,\n          mapStyles: {dark: {}}\n        }\n      };\n      const result = getStaticMapProps(state, onViewChange, 'global-token');\n      expect(result.mapboxApiAccessToken).toBe('global-token');\n    });\n\n    test('sets preserveDrawingBuffer to true', () => {\n      const result = getStaticMapProps(mockKeplerState, onViewChange, 'token');\n      expect(result.preserveDrawingBuffer).toBe(true);\n    });\n\n    test('passes bottomMapStyle as mapStyle', () => {\n      const result = getStaticMapProps(mockKeplerState, onViewChange, 'token');\n      expect(result.mapStyle).toEqual({id: 'dark-map-style'});\n    });\n\n    test('passes onViewChange as onViewportChange', () => {\n      const result = getStaticMapProps(mockKeplerState, onViewChange, 'token');\n      expect(result.onViewportChange).toBe(onViewChange);\n    });\n\n    test('includes mapLib as a Promise (always maplibre-gl)', () => {\n      const result = getStaticMapProps(mockKeplerState, onViewChange, 'token');\n      expect(result.mapLib).toBeDefined();\n      expect(result.mapLib).toBeInstanceOf(Promise);\n    });\n\n    test('provides transformRequest that handles mapbox:// URLs', () => {\n      const result = getStaticMapProps(mockKeplerState, onViewChange, 'global-token');\n      expect(typeof result.transformRequest).toBe('function');\n\n      const transformed = result.transformRequest('mapbox://styles/user/style1', 'Style');\n      expect(transformed.url).toContain('api.mapbox.com');\n\n      const regular = result.transformRequest('https://example.com/tiles', 'Source');\n      expect(regular.url).toBe('https://example.com/tiles');\n    });\n\n    test('converts mapbox:// URLs in style object for mapbox styles', () => {\n      const {getBaseMapLibrary} = require('@kepler.gl/utils');\n      getBaseMapLibrary.mockReturnValueOnce('mapbox');\n\n      const state = {\n        ...mockKeplerState,\n        mapStyle: {\n          ...mockKeplerState.mapStyle,\n          bottomMapStyle: {\n            id: 'mapbox-style',\n            sprite: 'mapbox://sprites/user/style1',\n            glyphs: 'mapbox://fonts/user/{fontstack}/{range}.pbf',\n            sources: {\n              composite: {url: 'mapbox://mapbox.mapbox-streets-v8'}\n            }\n          }\n        }\n      };\n\n      const result = getStaticMapProps(state, onViewChange, 'token');\n      expect(result.mapStyle.sprite).toContain('api.mapbox.com');\n      expect(result.mapStyle.glyphs).toContain('api.mapbox.com');\n      expect(result.mapStyle.sources.composite.url).toContain('api.mapbox.com');\n    });\n\n    test('does not convert style URLs for non-mapbox styles', () => {\n      const result = getStaticMapProps(mockKeplerState, onViewChange, 'token');\n      expect(result.mapStyle).toEqual({id: 'dark-map-style'});\n    });\n  });\n\n  describe('getAnimatableFilters', () => {\n    test('returns empty array when no filters', () => {\n      const state = {visState: {filters: []}, mapState: {}, mapStyle: {}};\n      expect(getAnimatableFilters(state)).toEqual([]);\n    });\n\n    test('returns empty array when visState.filters is undefined', () => {\n      const state = {visState: {}, mapState: {}, mapStyle: {}};\n      expect(getAnimatableFilters(state)).toEqual([]);\n    });\n\n    test('filters only timeRange filters with enlarged view', () => {\n      const filters = [\n        {type: FILTER_TYPES.timeRange, view: FILTER_VIEW_TYPES.enlarged, id: 'f1'},\n        {type: FILTER_TYPES.range, view: FILTER_VIEW_TYPES.enlarged, id: 'f2'},\n        {type: FILTER_TYPES.timeRange, view: FILTER_VIEW_TYPES.side, id: 'f3'}\n      ];\n      const state = {visState: {filters}, mapState: {}, mapStyle: {}};\n      const result = getAnimatableFilters(state);\n\n      expect(result).toHaveLength(1);\n      expect(result[0].id).toBe('f1');\n    });\n\n    test('includes timeRange filters synced with layer timeline', () => {\n      const filters = [\n        {\n          type: FILTER_TYPES.timeRange,\n          view: FILTER_VIEW_TYPES.side,\n          syncedWithLayerTimeline: true,\n          id: 'synced'\n        },\n        {\n          type: FILTER_TYPES.timeRange,\n          view: FILTER_VIEW_TYPES.side,\n          syncedWithLayerTimeline: false,\n          id: 'not-synced'\n        }\n      ];\n      const state = {visState: {filters}, mapState: {}, mapStyle: {}};\n      const result = getAnimatableFilters(state);\n\n      expect(result).toHaveLength(1);\n      expect(result[0].id).toBe('synced');\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/modals/modal-dialog.d.ts

@@ -1,2 +1,2 @@
-declare const ModalDialogFactory: () => import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<import("../common/modal").ModalDialogOwnProps & Omit<import("react-modal").Props, "className" | "style" | "ariaHideApp"> & import("react").RefAttributes<import("../common/modal").ModalDialog>, never>> & Omit<typeof import("../common/modal").ModalDialog, keyof import("react").Component<any, {}, any>>;
+declare const ModalDialogFactory: () => import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("../common/modal").ModalDialogOwnProps & Omit<import("react-modal").Props, "className" | "style" | "ariaHideApp"> & import("react").RefAttributes<import("../common/modal").ModalDialog>, never> & Partial<Pick<import("../common/modal").ModalDialogOwnProps & Omit<import("react-modal").Props, "className" | "style" | "ariaHideApp"> & import("react").RefAttributes<import("../common/modal").ModalDialog>, never>>> & string & Omit<typeof import("../common/modal").ModalDialog, keyof import("react").Component<any, {}, any>>;
 export default ModalDialogFactory;

package/dist/modals/share-map-modal.d.ts

@@ -2,10 +2,8 @@ import React from 'react';
 import { ImageModalContainerProps } from './image-modal-container';
 import { Provider } from '@kepler.gl/cloud-providers';
 import { cleanupExportImage as cleanupExportImageAction } from '@kepler.gl/actions';
-export declare const StyledInputLabel: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, never>>;
-export declare const StyleSharingUrl: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<import("styled-components/dist/types").FastOmit<import("styled-components/dist/types").Substitute<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
-    ref?: ((instance: HTMLDivElement | null) => void | React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof React.DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | React.RefObject<HTMLDivElement> | null | undefined;
-}>, never>, never>>;
+export declare const StyledInputLabel: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, never>>> & string;
+export declare const StyleSharingUrl: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.ClassAttributes<HTMLDivElement> | keyof React.HTMLAttributes<HTMLDivElement>> & React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement>, "className"> & Partial<Pick<import("styled-components").FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, keyof React.ClassAttributes<HTMLDivElement> | keyof React.HTMLAttributes<HTMLDivElement>> & React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement>, "className">>> & string;
 interface SharingUrlProps {
     url: string;
     message?: string;

package/dist/modals/swipe-composite-utils.d.ts

@@ -0,0 +1,10 @@
+export type SwipeEasing = 'linear' | 'ease-in-out';
+/**
+ * Compute the swipe percentage at a given time.
+ */
+export declare function getSwipePercentageAtTime(timeMs: number, durationMs: number, startPct: number, endPct: number, easing?: SwipeEasing): number;
+/**
+ * Composite two canvases (left/right map views) with a swipe divider
+ * into a single output canvas.
+ */
+export declare function compositeSwipeFrame(leftCanvas: HTMLCanvasElement, rightCanvas: HTMLCanvasElement, outputCanvas: HTMLCanvasElement, percentage: number, showDivider?: boolean): void;

package/dist/modals/swipe-composite-utils.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.compositeSwipeFrame = compositeSwipeFrame;
+exports.getSwipePercentageAtTime = getSwipePercentageAtTime;
+var _popmotion = require("popmotion");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+var linear = function linear(p) {
+  return p;
+};
+var EASING_MAP = {
+  linear: linear,
+  'ease-in-out': _popmotion.easeInOut
+};
+
+/**
+ * Compute the swipe percentage at a given time.
+ */
+function getSwipePercentageAtTime(timeMs, durationMs, startPct, endPct) {
+  var easing = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'ease-in-out';
+  var progress = Math.max(0, Math.min(1, timeMs / durationMs));
+  var easedProgress = EASING_MAP[easing](progress);
+  return startPct + (endPct - startPct) * easedProgress;
+}
+var HANDLE_RADIUS = 14;
+var ARROW_SIZE = 6;
+
+/**
+ * Draw a swipe divider (line + circular handle with arrows) onto a 2D canvas context.
+ */
+function drawSwipeDivider(ctx, splitX, height) {
+  ctx.save();
+
+  // Divider line
+  ctx.strokeStyle = '#FFFFFF';
+  ctx.lineWidth = 2;
+  ctx.shadowColor = 'rgba(0, 0, 0, 0.5)';
+  ctx.shadowBlur = 4;
+  ctx.beginPath();
+  ctx.moveTo(splitX, 0);
+  ctx.lineTo(splitX, height);
+  ctx.stroke();
+
+  // Handle circle
+  var cy = height / 2;
+  ctx.shadowBlur = 6;
+  ctx.beginPath();
+  ctx.arc(splitX, cy, HANDLE_RADIUS, 0, Math.PI * 2);
+  ctx.fillStyle = '#29323C';
+  ctx.fill();
+  ctx.strokeStyle = '#FFFFFF';
+  ctx.lineWidth = 2;
+  ctx.stroke();
+  ctx.shadowBlur = 0;
+
+  // Left arrow
+  ctx.fillStyle = '#FFFFFF';
+  ctx.beginPath();
+  ctx.moveTo(splitX - ARROW_SIZE - 3, cy);
+  ctx.lineTo(splitX - 3, cy - ARROW_SIZE);
+  ctx.lineTo(splitX - 3, cy + ARROW_SIZE);
+  ctx.closePath();
+  ctx.fill();
+
+  // Right arrow
+  ctx.beginPath();
+  ctx.moveTo(splitX + ARROW_SIZE + 3, cy);
+  ctx.lineTo(splitX + 3, cy - ARROW_SIZE);
+  ctx.lineTo(splitX + 3, cy + ARROW_SIZE);
+  ctx.closePath();
+  ctx.fill();
+  ctx.restore();
+}
+
+/**
+ * Composite two canvases (left/right map views) with a swipe divider
+ * into a single output canvas.
+ */
+function compositeSwipeFrame(leftCanvas, rightCanvas, outputCanvas, percentage) {
+  var showDivider = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+  var ctx = outputCanvas.getContext('2d');
+  if (!ctx) return;
+  var w = outputCanvas.width;
+  var h = outputCanvas.height;
+  var splitX = Math.round(w * percentage / 100);
+  ctx.clearRect(0, 0, w, h);
+
+  // Draw right (background) canvas fully
+  ctx.drawImage(rightCanvas, 0, 0, w, h);
+
+  // Draw left (foreground) canvas clipped to 0..splitX
+  ctx.save();
+  ctx.beginPath();
+  ctx.rect(0, 0, splitX, h);
+  ctx.clip();
+  ctx.drawImage(leftCanvas, 0, 0, w, h);
+  ctx.restore();
+
+  // Draw the divider
+  if (showDivider) {
+    drawSwipeDivider(ctx, splitX, h);
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_popmotion","require","linear","p","EASING_MAP","easeInOut","getSwipePercentageAtTime","timeMs","durationMs","startPct","endPct","easing","arguments","length","undefined","progress","Math","max","min","easedProgress","HANDLE_RADIUS","ARROW_SIZE","drawSwipeDivider","ctx","splitX","height","save","strokeStyle","lineWidth","shadowColor","shadowBlur","beginPath","moveTo","lineTo","stroke","cy","arc","PI","fillStyle","fill","closePath","restore","compositeSwipeFrame","leftCanvas","rightCanvas","outputCanvas","percentage","showDivider","getContext","w","width","h","round","clearRect","drawImage","rect","clip"],"sources":["../../src/modals/swipe-composite-utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {easeInOut} from 'popmotion';\n\nexport type SwipeEasing = 'linear' | 'ease-in-out';\n\nconst linear = (p: number): number => p;\nconst EASING_MAP: Record<SwipeEasing, (p: number) => number> = {\n  linear,\n  'ease-in-out': easeInOut\n};\n\n/**\n * Compute the swipe percentage at a given time.\n */\nexport function getSwipePercentageAtTime(\n  timeMs: number,\n  durationMs: number,\n  startPct: number,\n  endPct: number,\n  easing: SwipeEasing = 'ease-in-out'\n): number {\n  const progress = Math.max(0, Math.min(1, timeMs / durationMs));\n  const easedProgress = EASING_MAP[easing](progress);\n  return startPct + (endPct - startPct) * easedProgress;\n}\n\nconst HANDLE_RADIUS = 14;\nconst ARROW_SIZE = 6;\n\n/**\n * Draw a swipe divider (line + circular handle with arrows) onto a 2D canvas context.\n */\nfunction drawSwipeDivider(\n  ctx: CanvasRenderingContext2D,\n  splitX: number,\n  height: number\n): void {\n  ctx.save();\n\n  // Divider line\n  ctx.strokeStyle = '#FFFFFF';\n  ctx.lineWidth = 2;\n  ctx.shadowColor = 'rgba(0, 0, 0, 0.5)';\n  ctx.shadowBlur = 4;\n  ctx.beginPath();\n  ctx.moveTo(splitX, 0);\n  ctx.lineTo(splitX, height);\n  ctx.stroke();\n\n  // Handle circle\n  const cy = height / 2;\n  ctx.shadowBlur = 6;\n  ctx.beginPath();\n  ctx.arc(splitX, cy, HANDLE_RADIUS, 0, Math.PI * 2);\n  ctx.fillStyle = '#29323C';\n  ctx.fill();\n  ctx.strokeStyle = '#FFFFFF';\n  ctx.lineWidth = 2;\n  ctx.stroke();\n  ctx.shadowBlur = 0;\n\n  // Left arrow\n  ctx.fillStyle = '#FFFFFF';\n  ctx.beginPath();\n  ctx.moveTo(splitX - ARROW_SIZE - 3, cy);\n  ctx.lineTo(splitX - 3, cy - ARROW_SIZE);\n  ctx.lineTo(splitX - 3, cy + ARROW_SIZE);\n  ctx.closePath();\n  ctx.fill();\n\n  // Right arrow\n  ctx.beginPath();\n  ctx.moveTo(splitX + ARROW_SIZE + 3, cy);\n  ctx.lineTo(splitX + 3, cy - ARROW_SIZE);\n  ctx.lineTo(splitX + 3, cy + ARROW_SIZE);\n  ctx.closePath();\n  ctx.fill();\n\n  ctx.restore();\n}\n\n/**\n * Composite two canvases (left/right map views) with a swipe divider\n * into a single output canvas.\n */\nexport function compositeSwipeFrame(\n  leftCanvas: HTMLCanvasElement,\n  rightCanvas: HTMLCanvasElement,\n  outputCanvas: HTMLCanvasElement,\n  percentage: number,\n  showDivider: boolean = true\n): void {\n  const ctx = outputCanvas.getContext('2d');\n  if (!ctx) return;\n\n  const w = outputCanvas.width;\n  const h = outputCanvas.height;\n  const splitX = Math.round((w * percentage) / 100);\n\n  ctx.clearRect(0, 0, w, h);\n\n  // Draw right (background) canvas fully\n  ctx.drawImage(rightCanvas, 0, 0, w, h);\n\n  // Draw left (foreground) canvas clipped to 0..splitX\n  ctx.save();\n  ctx.beginPath();\n  ctx.rect(0, 0, splitX, h);\n  ctx.clip();\n  ctx.drawImage(leftCanvas, 0, 0, w, h);\n  ctx.restore();\n\n  // Draw the divider\n  if (showDivider) {\n    drawSwipeDivider(ctx, splitX, h);\n  }\n}\n"],"mappings":";;;;;;;AAGA,IAAAA,UAAA,GAAAC,OAAA;AAHA;AACA;;AAMA,IAAMC,MAAM,GAAG,SAATA,MAAMA,CAAIC,CAAS;EAAA,OAAaA,CAAC;AAAA;AACvC,IAAMC,UAAsD,GAAG;EAC7DF,MAAM,EAANA,MAAM;EACN,aAAa,EAAEG;AACjB,CAAC;;AAED;AACA;AACA;AACO,SAASC,wBAAwBA,CACtCC,MAAc,EACdC,UAAkB,EAClBC,QAAgB,EAChBC,MAAc,EAEN;EAAA,IADRC,MAAmB,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,aAAa;EAEnC,IAAMG,QAAQ,GAAGC,IAAI,CAACC,GAAG,CAAC,CAAC,EAAED,IAAI,CAACE,GAAG,CAAC,CAAC,EAAEX,MAAM,GAAGC,UAAU,CAAC,CAAC;EAC9D,IAAMW,aAAa,GAAGf,UAAU,CAACO,MAAM,CAAC,CAACI,QAAQ,CAAC;EAClD,OAAON,QAAQ,GAAG,CAACC,MAAM,GAAGD,QAAQ,IAAIU,aAAa;AACvD;AAEA,IAAMC,aAAa,GAAG,EAAE;AACxB,IAAMC,UAAU,GAAG,CAAC;;AAEpB;AACA;AACA;AACA,SAASC,gBAAgBA,CACvBC,GAA6B,EAC7BC,MAAc,EACdC,MAAc,EACR;EACNF,GAAG,CAACG,IAAI,CAAC,CAAC;;EAEV;EACAH,GAAG,CAACI,WAAW,GAAG,SAAS;EAC3BJ,GAAG,CAACK,SAAS,GAAG,CAAC;EACjBL,GAAG,CAACM,WAAW,GAAG,oBAAoB;EACtCN,GAAG,CAACO,UAAU,GAAG,CAAC;EAClBP,GAAG,CAACQ,SAAS,CAAC,CAAC;EACfR,GAAG,CAACS,MAAM,CAACR,MAAM,EAAE,CAAC,CAAC;EACrBD,GAAG,CAACU,MAAM,CAACT,MAAM,EAAEC,MAAM,CAAC;EAC1BF,GAAG,CAACW,MAAM,CAAC,CAAC;;EAEZ;EACA,IAAMC,EAAE,GAAGV,MAAM,GAAG,CAAC;EACrBF,GAAG,CAACO,UAAU,GAAG,CAAC;EAClBP,GAAG,CAACQ,SAAS,CAAC,CAAC;EACfR,GAAG,CAACa,GAAG,CAACZ,MAAM,EAAEW,EAAE,EAAEf,aAAa,EAAE,CAAC,EAAEJ,IAAI,CAACqB,EAAE,GAAG,CAAC,CAAC;EAClDd,GAAG,CAACe,SAAS,GAAG,SAAS;EACzBf,GAAG,CAACgB,IAAI,CAAC,CAAC;EACVhB,GAAG,CAACI,WAAW,GAAG,SAAS;EAC3BJ,GAAG,CAACK,SAAS,GAAG,CAAC;EACjBL,GAAG,CAACW,MAAM,CAAC,CAAC;EACZX,GAAG,CAACO,UAAU,GAAG,CAAC;;EAElB;EACAP,GAAG,CAACe,SAAS,GAAG,SAAS;EACzBf,GAAG,CAACQ,SAAS,CAAC,CAAC;EACfR,GAAG,CAACS,MAAM,CAACR,MAAM,GAAGH,UAAU,GAAG,CAAC,EAAEc,EAAE,CAAC;EACvCZ,GAAG,CAACU,MAAM,CAACT,MAAM,GAAG,CAAC,EAAEW,EAAE,GAAGd,UAAU,CAAC;EACvCE,GAAG,CAACU,MAAM,CAACT,MAAM,GAAG,CAAC,EAAEW,EAAE,GAAGd,UAAU,CAAC;EACvCE,GAAG,CAACiB,SAAS,CAAC,CAAC;EACfjB,GAAG,CAACgB,IAAI,CAAC,CAAC;;EAEV;EACAhB,GAAG,CAACQ,SAAS,CAAC,CAAC;EACfR,GAAG,CAACS,MAAM,CAACR,MAAM,GAAGH,UAAU,GAAG,CAAC,EAAEc,EAAE,CAAC;EACvCZ,GAAG,CAACU,MAAM,CAACT,MAAM,GAAG,CAAC,EAAEW,EAAE,GAAGd,UAAU,CAAC;EACvCE,GAAG,CAACU,MAAM,CAACT,MAAM,GAAG,CAAC,EAAEW,EAAE,GAAGd,UAAU,CAAC;EACvCE,GAAG,CAACiB,SAAS,CAAC,CAAC;EACfjB,GAAG,CAACgB,IAAI,CAAC,CAAC;EAEVhB,GAAG,CAACkB,OAAO,CAAC,CAAC;AACf;;AAEA;AACA;AACA;AACA;AACO,SAASC,mBAAmBA,CACjCC,UAA6B,EAC7BC,WAA8B,EAC9BC,YAA+B,EAC/BC,UAAkB,EAEZ;EAAA,IADNC,WAAoB,GAAAnC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,IAAI;EAE3B,IAAMW,GAAG,GAAGsB,YAAY,CAACG,UAAU,CAAC,IAAI,CAAC;EACzC,IAAI,CAACzB,GAAG,EAAE;EAEV,IAAM0B,CAAC,GAAGJ,YAAY,CAACK,KAAK;EAC5B,IAAMC,CAAC,GAAGN,YAAY,CAACpB,MAAM;EAC7B,IAAMD,MAAM,GAAGR,IAAI,CAACoC,KAAK,CAAEH,CAAC,GAAGH,UAAU,GAAI,GAAG,CAAC;EAEjDvB,GAAG,CAAC8B,SAAS,CAAC,CAAC,EAAE,CAAC,EAAEJ,CAAC,EAAEE,CAAC,CAAC;;EAEzB;EACA5B,GAAG,CAAC+B,SAAS,CAACV,WAAW,EAAE,CAAC,EAAE,CAAC,EAAEK,CAAC,EAAEE,CAAC,CAAC;;EAEtC;EACA5B,GAAG,CAACG,IAAI,CAAC,CAAC;EACVH,GAAG,CAACQ,SAAS,CAAC,CAAC;EACfR,GAAG,CAACgC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE/B,MAAM,EAAE2B,CAAC,CAAC;EACzB5B,GAAG,CAACiC,IAAI,CAAC,CAAC;EACVjC,GAAG,CAAC+B,SAAS,CAACX,UAAU,EAAE,CAAC,EAAE,CAAC,EAAEM,CAAC,EAAEE,CAAC,CAAC;EACrC5B,GAAG,CAACkB,OAAO,CAAC,CAAC;;EAEb;EACA,IAAIM,WAAW,EAAE;IACfzB,gBAAgB,CAACC,GAAG,EAAEC,MAAM,EAAE2B,CAAC,CAAC;EAClC;AACF","ignoreList":[]}

package/dist/modals/swipe-export-settings.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import { SwipeEasing } from './swipe-composite-utils';
+export type SwipeExportSettingsProps = {
+    durationMs: number;
+    mediaType: string;
+    resolution: string;
+    fileName: string;
+    cameraPreset: string;
+    frameRate: number;
+    onChangeDuration: (value: number) => void;
+    onChangeMediaType: (value: string) => void;
+    onChangeResolution: (value: string) => void;
+    onChangeFileName: (value: string) => void;
+    onChangeCameraPreset: (value: string) => void;
+    swipeStartPct: number;
+    swipeEndPct: number;
+    swipeEasing: SwipeEasing;
+    disabled: boolean;
+    onChangeStartPct: (value: number) => void;
+    onChangeEndPct: (value: number) => void;
+    onChangeEasing: (value: SwipeEasing) => void;
+};
+declare const SwipeExportSettings: React.FC<SwipeExportSettingsProps>;
+export default SwipeExportSettings;