@kepler.gl/components 3.3.0-alpha.5 → 3.3.0-alpha.6

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

@@ -0,0 +1,396 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// @ts-nocheck
+import { FILTER_TYPES, FILTER_VIEW_TYPES } from '@kepler.gl/constants';
+import { getTimeRangeFilterKeyframes, getBeforeLayerId, getStaticMapProps, getAnimatableFilters } from './hubble-utils';
+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: 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 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 = 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(_typeof(result.easings)).toBe('function');
+      expect(result.easings(0.5)).toBe(0.5);
+    });
+    test('returns incremental keyframes', function () {
+      var result = 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 = 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 = 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 = 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(getBeforeLayerId(null, {
+        layers: [{
+          id: 'a'
+        }]
+      })).toBeNull();
+    });
+    test('returns null when bottomMapStyle is null', function () {
+      expect(getBeforeLayerId({
+        layers: [{
+          id: 'a'
+        }]
+      }, null)).toBeNull();
+    });
+    test('returns null when either has empty layers', function () {
+      expect(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 = 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(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(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 = 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 = 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 = getStaticMapProps(state, onViewChange, 'global-token');
+      expect(result.mapboxApiAccessToken).toBe('global-token');
+    });
+    test('sets preserveDrawingBuffer to true', function () {
+      var result = getStaticMapProps(mockKeplerState, onViewChange, 'token');
+      expect(result.preserveDrawingBuffer).toBe(true);
+    });
+    test('passes bottomMapStyle as mapStyle', function () {
+      var result = getStaticMapProps(mockKeplerState, onViewChange, 'token');
+      expect(result.mapStyle).toEqual({
+        id: 'dark-map-style'
+      });
+    });
+    test('passes onViewChange as onViewportChange', function () {
+      var result = getStaticMapProps(mockKeplerState, onViewChange, 'token');
+      expect(result.onViewportChange).toBe(onViewChange);
+    });
+    test('includes mapLib as a Promise (always maplibre-gl)', function () {
+      var result = getStaticMapProps(mockKeplerState, onViewChange, 'token');
+      expect(result.mapLib).toBeDefined();
+      expect(result.mapLib).toBeInstanceOf(Promise);
+    });
+    test('provides transformRequest that handles mapbox:// URLs', function () {
+      var result = getStaticMapProps(mockKeplerState, onViewChange, 'global-token');
+      expect(_typeof(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 = 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 = 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(getAnimatableFilters(state)).toEqual([]);
+    });
+    test('returns empty array when visState.filters is undefined', function () {
+      var state = {
+        visState: {},
+        mapState: {},
+        mapStyle: {}
+      };
+      expect(getAnimatableFilters(state)).toEqual([]);
+    });
+    test('filters only timeRange filters with enlarged view', function () {
+      var filters = [{
+        type: FILTER_TYPES.timeRange,
+        view: FILTER_VIEW_TYPES.enlarged,
+        id: 'f1'
+      }, {
+        type: FILTER_TYPES.range,
+        view: FILTER_VIEW_TYPES.enlarged,
+        id: 'f2'
+      }, {
+        type: FILTER_TYPES.timeRange,
+        view: FILTER_VIEW_TYPES.side,
+        id: 'f3'
+      }];
+      var state = {
+        visState: {
+          filters: filters
+        },
+        mapState: {},
+        mapStyle: {}
+      };
+      var result = getAnimatableFilters(state);
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('f1');
+    });
+    test('includes timeRange filters synced with layer timeline', function () {
+      var filters = [{
+        type: FILTER_TYPES.timeRange,
+        view: FILTER_VIEW_TYPES.side,
+        syncedWithLayerTimeline: true,
+        id: 'synced'
+      }, {
+        type: FILTER_TYPES.timeRange,
+        view: FILTER_VIEW_TYPES.side,
+        syncedWithLayerTimeline: false,
+        id: 'not-synced'
+      }];
+      var state = {
+        visState: {
+          filters: filters
+        },
+        mapState: {},
+        mapStyle: {}
+      };
+      var result = getAnimatableFilters(state);
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('synced');
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["FILTER_TYPES","FILTER_VIEW_TYPES","getTimeRangeFilterKeyframes","getBeforeLayerId","getStaticMapProps","getAnimatableFilters","jest","mock","_objectSpread","requireActual","getBaseMapLibrary","fn","isMapboxURL","url","startsWith","transformMapboxUrl","_resourceType","token","concat","replace","describe","baseFilter","type","timeRange","domain","value","animationWindow","plotType","interval","timeBins","dataId","test","expect","filter","timings","toThrow","result","delta","keyframes","toEqual","_typeof","easings","toBe","bins","x0","x1","dataset1","day","layers","id","toBeNull","topMapStyle","bottomMapStyle","mockKeplerState","visState","mapState","latitude","longitude","zoom","mapStyle","styleType","mapStyles","dark","accessToken","onViewChange","mapboxApiAccessToken","state","preserveDrawingBuffer","onViewportChange","mapLib","toBeDefined","toBeInstanceOf","Promise","transformRequest","transformed","toContain","regular","_require","require","mockReturnValueOnce","sprite","glyphs","sources","composite","filters","view","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":";;;;AAAA;AACA;;AAEA;AACA,SAAQA,YAAY,EAAEC,iBAAiB,QAAO,sBAAsB;AACpE,SACEC,2BAA2B,EAC3BC,gBAAgB,EAChBC,iBAAiB,EACjBC,oBAAoB,QACf,gBAAgB;AAEvBC,IAAI,CAACC,IAAI,CAAC,kBAAkB,EAAE;EAAA,OAAAC,aAAA,CAAAA,aAAA,KACzBF,IAAI,CAACG,aAAa,CAAC,kBAAkB,CAAC;IACzCC,iBAAiB,EAAEJ,IAAI,CAACK,EAAE,CAAC;MAAA,OAAM,UAAU;IAAA;EAAC;AAAA,CAC5C,CAAC;AAEHL,IAAI,CAACC,IAAI,CAAC,uCAAuC,EAAE;EAAA,OAAO;IACxDK,WAAW,EAAEN,IAAI,CAACK,EAAE,CAAC,UAACE,GAAW;MAAA,OAAKA,GAAG,CAACC,UAAU,CAAC,SAAS,CAAC;IAAA,EAAC;IAChEC,kBAAkB,EAAET,IAAI,CAACK,EAAE,CAAC,UAACE,GAAW,EAAEG,aAAqB,EAAEC,KAAa;MAAA,OAAM;QAClFJ,GAAG,KAAAK,MAAA,CAAKL,GAAG,CAACM,OAAO,CAAC,WAAW,EAAE,yBAAyB,CAAC,oBAAAD,MAAA,CAAiBD,KAAK;MACnF,CAAC;IAAA,CAAC;EACJ,CAAC;AAAA,CAAC,CAAC;AAEHG,QAAQ,CAAC,cAAc,EAAE,YAAM;EAC7BA,QAAQ,CAAC,6BAA6B,EAAE,YAAM;IAC5C,IAAMC,UAAU,GAAG;MACjBC,IAAI,EAAEtB,YAAY,CAACuB,SAAS;MAC5BC,MAAM,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;MAClBC,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC;MACjBC,eAAe,EAAE,MAAM;MACvBC,QAAQ,EAAE;QAACC,QAAQ,EAAE;MAAI,CAAC;MAC1BC,QAAQ,EAAE,IAAI;MACdC,MAAM,EAAE,CAAC,UAAU;IACrB,CAAC;IAEDC,IAAI,CAAC,0CAA0C,EAAE,YAAM;MACrDC,MAAM,CAAC;QAAA,OACL9B,2BAA2B,CAAC;UAC1B+B,MAAM,EAAAzB,aAAA,CAAAA,aAAA,KAAMa,UAAU;YAAEC,IAAI,EAAE;UAAO,EAAC;UACtCY,OAAO,EAAE,CAAC,CAAC,EAAE,IAAI;QACnB,CAAC,CAAC;MAAA,CACJ,CAAC,CAACC,OAAO,CAAC,kCAAkC,CAAC;IAC/C,CAAC,CAAC;IAEFJ,IAAI,CAAC,mCAAmC,EAAE,YAAM;MAC9C,IAAMK,MAAM,GAAGlC,2BAA2B,CAAC;QACzC+B,MAAM,EAAEZ,UAAU;QAClBa,OAAO,EAAE,CAAC,CAAC,EAAE,IAAI;MACnB,CAAC,CAAC;MAEF,IAAMG,KAAK,GAAGhB,UAAU,CAACI,KAAK,CAAC,CAAC,CAAC,GAAGJ,UAAU,CAACI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;MACzDO,MAAM,CAACI,MAAM,CAACE,SAAS,CAAC,CAACC,OAAO,CAAC,CAAC;QAACd,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,GAAGY,KAAK;MAAC,CAAC,EAAE;QAACZ,KAAK,EAAE,CAAC,GAAG,GAAGY,KAAK,EAAE,GAAG;MAAC,CAAC,CAAC,CAAC;MAC5FL,MAAM,CAAAQ,OAAA,CAAQJ,MAAM,CAACK,OAAO,EAAC,CAACC,IAAI,CAAC,UAAU,CAAC;MAC9CV,MAAM,CAACI,MAAM,CAACK,OAAO,CAAC,GAAG,CAAC,CAAC,CAACC,IAAI,CAAC,GAAG,CAAC;IACvC,CAAC,CAAC;IAEFX,IAAI,CAAC,+BAA+B,EAAE,YAAM;MAC1C,IAAMK,MAAM,GAAGlC,2BAA2B,CAAC;QACzC+B,MAAM,EAAAzB,aAAA,CAAAA,aAAA,KAAMa,UAAU;UAAEK,eAAe,EAAE;QAAa,EAAC;QACvDQ,OAAO,EAAE,CAAC,CAAC,EAAE,IAAI;MACnB,CAAC,CAAC;MAEFF,MAAM,CAACI,MAAM,CAACE,SAAS,CAAC,CAACC,OAAO,CAAC,CAAC;QAACd,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG;MAAC,CAAC,EAAE;QAACA,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG;MAAC,CAAC,CAAC,CAAC;IAC9E,CAAC,CAAC;IAEFM,IAAI,CAAC,yBAAyB,EAAE,YAAM;MACpC,IAAMK,MAAM,GAAGlC,2BAA2B,CAAC;QACzC+B,MAAM,EAAAzB,aAAA,CAAAA,aAAA,KAAMa,UAAU;UAAEK,eAAe,EAAE;QAAO,EAAC;QACjDQ,OAAO,EAAE,CAAC,CAAC,EAAE,IAAI;MACnB,CAAC,CAAC;MAEFF,MAAM,CAACI,MAAM,CAACE,SAAS,CAAC,CAACC,OAAO,CAAC,CAAC;QAACd,KAAK,EAAE;MAAG,CAAC,EAAE;QAACA,KAAK,EAAE;MAAG,CAAC,CAAC,CAAC;IAChE,CAAC,CAAC;IAEFM,IAAI,CAAC,sCAAsC,EAAE,YAAM;MACjD,IAAMY,IAAI,GAAG,CACX;QAACC,EAAE,EAAE,GAAG;QAAEC,EAAE,EAAE;MAAG,CAAC,EAClB;QAACD,EAAE,EAAE,GAAG;QAAEC,EAAE,EAAE;MAAG,CAAC,EAClB;QAACD,EAAE,EAAE,GAAG;QAAEC,EAAE,EAAE;MAAG,CAAC,CACnB;MACD,IAAMZ,MAAM,GAAAzB,aAAA,CAAAA,aAAA,KACPa,UAAU;QACbK,eAAe,EAAE,UAAU;QAC3BC,QAAQ,EAAE;UAACC,QAAQ,EAAE;QAAK,CAAC;QAC3BC,QAAQ,EAAE;UAACiB,QAAQ,EAAE;YAACC,GAAG,EAAEJ;UAAI;QAAC,CAAC;QACjCb,MAAM,EAAE,CAAC,UAAU;MAAC,EACrB;MAED,IAAMM,MAAM,GAAGlC,2BAA2B,CAAC;QACzC+B,MAAM,EAANA,MAAM;QACNC,OAAO,EAAE,CAAC,CAAC,EAAE,GAAG;MAClB,CAAC,CAAC;MAEFF,MAAM,CAACI,MAAM,CAACE,SAAS,CAAC,CAACC,OAAO,CAAC,CAC/B;QAACd,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG;MAAC,CAAC,EACnB;QAACA,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG;MAAC,CAAC,EACnB;QAACA,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG;MAAC,CAAC,CACpB,CAAC;MACFO,MAAM,CAACI,MAAM,CAACF,OAAO,CAAC,CAACK,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;MAC7C;MACAP,MAAM,CAACI,MAAM,CAACK,OAAO,CAAC,CAAC,CAAC,CAAC,CAACC,IAAI,CAAC,CAAC,CAAC;MACjCV,MAAM,CAACI,MAAM,CAACK,OAAO,CAAC,GAAG,CAAC,CAAC,CAACC,IAAI,CAAC,CAAC,CAAC;MACnCV,MAAM,CAACI,MAAM,CAACK,OAAO,CAAC,CAAC,CAAC,CAAC,CAACC,IAAI,CAAC,CAAC,CAAC;IACnC,CAAC,CAAC;IAEFX,IAAI,CAAC,wDAAwD,EAAE,YAAM;MACnE,IAAME,MAAM,GAAAzB,aAAA,CAAAA,aAAA,KACPa,UAAU;QACbK,eAAe,EAAE,UAAU;QAC3BC,QAAQ,EAAE;UAACC,QAAQ,EAAE;QAAI,CAAC;QAC1BC,QAAQ,EAAE;MAAI,EACf;MAED,IAAMO,MAAM,GAAGlC,2BAA2B,CAAC;QACzC+B,MAAM,EAANA,MAAM;QACNC,OAAO,EAAE,CAAC,CAAC,EAAE,IAAI;MACnB,CAAC,CAAC;MAEF,IAAMG,KAAK,GAAGhB,UAAU,CAACI,KAAK,CAAC,CAAC,CAAC,GAAGJ,UAAU,CAACI,KAAK,CAAC,CAAC,CAAC;MACvDO,MAAM,CAACI,MAAM,CAACE,SAAS,CAAC,CAACC,OAAO,CAAC,CAAC;QAACd,KAAK,EAAE,CAAC,GAAG,EAAE,GAAG,GAAGY,KAAK;MAAC,CAAC,EAAE;QAACZ,KAAK,EAAE,CAAC,GAAG,GAAGY,KAAK,EAAE,GAAG;MAAC,CAAC,CAAC,CAAC;IAC9F,CAAC,CAAC;EACJ,CAAC,CAAC;EAEFjB,QAAQ,CAAC,kBAAkB,EAAE,YAAM;IACjCW,IAAI,CAAC,uCAAuC,EAAE,YAAM;MAClDC,MAAM,CAAC7B,gBAAgB,CAAC,IAAI,EAAE;QAAC6C,MAAM,EAAE,CAAC;UAACC,EAAE,EAAE;QAAG,CAAC;MAAC,CAAC,CAAC,CAAC,CAACC,QAAQ,CAAC,CAAC;IAClE,CAAC,CAAC;IAEFnB,IAAI,CAAC,0CAA0C,EAAE,YAAM;MACrDC,MAAM,CAAC7B,gBAAgB,CAAC;QAAC6C,MAAM,EAAE,CAAC;UAACC,EAAE,EAAE;QAAG,CAAC;MAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAACC,QAAQ,CAAC,CAAC;IAClE,CAAC,CAAC;IAEFnB,IAAI,CAAC,2CAA2C,EAAE,YAAM;MACtDC,MAAM,CAAC7B,gBAAgB,CAAC;QAAC6C,MAAM,EAAE;MAAE,CAAC,EAAE;QAACA,MAAM,EAAE,CAAC;UAACC,EAAE,EAAE;QAAG,CAAC;MAAC,CAAC,CAAC,CAAC,CAACC,QAAQ,CAAC,CAAC;IAC1E,CAAC,CAAC;IAEFnB,IAAI,CAAC,kEAAkE,EAAE,YAAM;MAC7E,IAAMoB,WAAW,GAAG;QAACH,MAAM,EAAE,CAAC;UAACC,EAAE,EAAE;QAAS,CAAC;MAAC,CAAC;MAC/C,IAAMG,cAAc,GAAG;QACrBJ,MAAM,EAAE,CAAC;UAACC,EAAE,EAAE;QAAS,CAAC,EAAE;UAACA,EAAE,EAAE;QAAS,CAAC,EAAE;UAACA,EAAE,EAAE;QAAS,CAAC;MAC5D,CAAC;MAED,IAAMb,MAAM,GAAGjC,gBAAgB,CAACgD,WAAW,EAAEC,cAAc,CAAC;MAC5DpB,MAAM,CAACI,MAAM,CAAC,CAACG,OAAO,CAAC;QAACU,EAAE,EAAE;MAAS,CAAC,CAAC;IACzC,CAAC,CAAC;IAEFlB,IAAI,CAAC,iEAAiE,EAAE,YAAM;MAC5E,IAAMoB,WAAW,GAAG;QAACH,MAAM,EAAE,CAAC;UAACC,EAAE,EAAE;QAAS,CAAC;MAAC,CAAC;MAC/C,IAAMG,cAAc,GAAG;QAACJ,MAAM,EAAE,CAAC;UAACC,EAAE,EAAE;QAAS,CAAC,EAAE;UAACA,EAAE,EAAE;QAAS,CAAC;MAAC,CAAC;MAEnEjB,MAAM,CAAC7B,gBAAgB,CAACgD,WAAW,EAAEC,cAAc,CAAC,CAAC,CAACF,QAAQ,CAAC,CAAC;IAClE,CAAC,CAAC;IAEFnB,IAAI,CAAC,gEAAgE,EAAE,YAAM;MAC3E,IAAMoB,WAAW,GAAG;QAACH,MAAM,EAAE,CAAC;UAACC,EAAE,EAAE;QAAS,CAAC;MAAC,CAAC;MAC/C,IAAMG,cAAc,GAAG;QAACJ,MAAM,EAAE,CAAC;UAACC,EAAE,EAAE;QAAS,CAAC,EAAE;UAACA,EAAE,EAAE;QAAS,CAAC;MAAC,CAAC;MAEnEjB,MAAM,CAAC7B,gBAAgB,CAACgD,WAAW,EAAEC,cAAc,CAAC,CAAC,CAACF,QAAQ,CAAC,CAAC;IAClE,CAAC,CAAC;EACJ,CAAC,CAAC;EAEF9B,QAAQ,CAAC,mBAAmB,EAAE,YAAM;IAClC,IAAMiC,eAAe,GAAG;MACtBC,QAAQ,EAAE,CAAC,CAAC;MACZC,QAAQ,EAAE;QAACC,QAAQ,EAAE,IAAI;QAAEC,SAAS,EAAE,CAAC,KAAK;QAAEC,IAAI,EAAE;MAAE,CAAC;MACvDC,QAAQ,EAAE;QACRC,SAAS,EAAE,MAAM;QACjBC,SAAS,EAAE;UACTC,IAAI,EAAE;YAACC,WAAW,EAAE;UAAa;QACnC,CAAC;QACDX,cAAc,EAAE;UAACH,EAAE,EAAE;QAAgB;MACvC;IACF,CAAC;IACD,IAAMe,YAAY,GAAG1D,IAAI,CAACK,EAAE,CAAC,CAAC;IAE9BoB,IAAI,CAAC,8BAA8B,EAAE,YAAM;MACzC,IAAMK,MAAM,GAAGhC,iBAAiB,CAACiD,eAAe,EAAEW,YAAY,EAAE,cAAc,CAAC;MAE/EhC,MAAM,CAACI,MAAM,CAACoB,QAAQ,CAAC,CAACd,IAAI,CAAC,IAAI,CAAC;MAClCV,MAAM,CAACI,MAAM,CAACqB,SAAS,CAAC,CAACf,IAAI,CAAC,CAAC,KAAK,CAAC;MACrCV,MAAM,CAACI,MAAM,CAACsB,IAAI,CAAC,CAAChB,IAAI,CAAC,EAAE,CAAC;IAC9B,CAAC,CAAC;IAEFX,IAAI,CAAC,uCAAuC,EAAE,YAAM;MAClD,IAAMK,MAAM,GAAGhC,iBAAiB,CAACiD,eAAe,EAAEW,YAAY,EAAE,cAAc,CAAC;MAC/EhC,MAAM,CAACI,MAAM,CAAC6B,oBAAoB,CAAC,CAACvB,IAAI,CAAC,aAAa,CAAC;IACzD,CAAC,CAAC;IAEFX,IAAI,CAAC,0DAA0D,EAAE,YAAM;MACrE,IAAMmC,KAAK,GAAA1D,aAAA,CAAAA,aAAA,KACN6C,eAAe;QAClBM,QAAQ,EAAAnD,aAAA,CAAAA,aAAA,KACH6C,eAAe,CAACM,QAAQ;UAC3BE,SAAS,EAAE;YAACC,IAAI,EAAE,CAAC;UAAC;QAAC;MACtB,EACF;MACD,IAAM1B,MAAM,GAAGhC,iBAAiB,CAAC8D,KAAK,EAAEF,YAAY,EAAE,cAAc,CAAC;MACrEhC,MAAM,CAACI,MAAM,CAAC6B,oBAAoB,CAAC,CAACvB,IAAI,CAAC,cAAc,CAAC;IAC1D,CAAC,CAAC;IAEFX,IAAI,CAAC,oCAAoC,EAAE,YAAM;MAC/C,IAAMK,MAAM,GAAGhC,iBAAiB,CAACiD,eAAe,EAAEW,YAAY,EAAE,OAAO,CAAC;MACxEhC,MAAM,CAACI,MAAM,CAAC+B,qBAAqB,CAAC,CAACzB,IAAI,CAAC,IAAI,CAAC;IACjD,CAAC,CAAC;IAEFX,IAAI,CAAC,mCAAmC,EAAE,YAAM;MAC9C,IAAMK,MAAM,GAAGhC,iBAAiB,CAACiD,eAAe,EAAEW,YAAY,EAAE,OAAO,CAAC;MACxEhC,MAAM,CAACI,MAAM,CAACuB,QAAQ,CAAC,CAACpB,OAAO,CAAC;QAACU,EAAE,EAAE;MAAgB,CAAC,CAAC;IACzD,CAAC,CAAC;IAEFlB,IAAI,CAAC,yCAAyC,EAAE,YAAM;MACpD,IAAMK,MAAM,GAAGhC,iBAAiB,CAACiD,eAAe,EAAEW,YAAY,EAAE,OAAO,CAAC;MACxEhC,MAAM,CAACI,MAAM,CAACgC,gBAAgB,CAAC,CAAC1B,IAAI,CAACsB,YAAY,CAAC;IACpD,CAAC,CAAC;IAEFjC,IAAI,CAAC,mDAAmD,EAAE,YAAM;MAC9D,IAAMK,MAAM,GAAGhC,iBAAiB,CAACiD,eAAe,EAAEW,YAAY,EAAE,OAAO,CAAC;MACxEhC,MAAM,CAACI,MAAM,CAACiC,MAAM,CAAC,CAACC,WAAW,CAAC,CAAC;MACnCtC,MAAM,CAACI,MAAM,CAACiC,MAAM,CAAC,CAACE,cAAc,CAACC,OAAO,CAAC;IAC/C,CAAC,CAAC;IAEFzC,IAAI,CAAC,uDAAuD,EAAE,YAAM;MAClE,IAAMK,MAAM,GAAGhC,iBAAiB,CAACiD,eAAe,EAAEW,YAAY,EAAE,cAAc,CAAC;MAC/EhC,MAAM,CAAAQ,OAAA,CAAQJ,MAAM,CAACqC,gBAAgB,EAAC,CAAC/B,IAAI,CAAC,UAAU,CAAC;MAEvD,IAAMgC,WAAW,GAAGtC,MAAM,CAACqC,gBAAgB,CAAC,6BAA6B,EAAE,OAAO,CAAC;MACnFzC,MAAM,CAAC0C,WAAW,CAAC7D,GAAG,CAAC,CAAC8D,SAAS,CAAC,gBAAgB,CAAC;MAEnD,IAAMC,OAAO,GAAGxC,MAAM,CAACqC,gBAAgB,CAAC,2BAA2B,EAAE,QAAQ,CAAC;MAC9EzC,MAAM,CAAC4C,OAAO,CAAC/D,GAAG,CAAC,CAAC6B,IAAI,CAAC,2BAA2B,CAAC;IACvD,CAAC,CAAC;IAEFX,IAAI,CAAC,2DAA2D,EAAE,YAAM;MACtE,IAAA8C,QAAA,GAA4BC,OAAO,CAAC,kBAAkB,CAAC;QAAhDpE,iBAAiB,GAAAmE,QAAA,CAAjBnE,iBAAiB;MACxBA,iBAAiB,CAACqE,mBAAmB,CAAC,QAAQ,CAAC;MAE/C,IAAMb,KAAK,GAAA1D,aAAA,CAAAA,aAAA,KACN6C,eAAe;QAClBM,QAAQ,EAAAnD,aAAA,CAAAA,aAAA,KACH6C,eAAe,CAACM,QAAQ;UAC3BP,cAAc,EAAE;YACdH,EAAE,EAAE,cAAc;YAClB+B,MAAM,EAAE,8BAA8B;YACtCC,MAAM,EAAE,6CAA6C;YACrDC,OAAO,EAAE;cACPC,SAAS,EAAE;gBAACtE,GAAG,EAAE;cAAmC;YACtD;UACF;QAAC;MACF,EACF;MAED,IAAMuB,MAAM,GAAGhC,iBAAiB,CAAC8D,KAAK,EAAEF,YAAY,EAAE,OAAO,CAAC;MAC9DhC,MAAM,CAACI,MAAM,CAACuB,QAAQ,CAACqB,MAAM,CAAC,CAACL,SAAS,CAAC,gBAAgB,CAAC;MAC1D3C,MAAM,CAACI,MAAM,CAACuB,QAAQ,CAACsB,MAAM,CAAC,CAACN,SAAS,CAAC,gBAAgB,CAAC;MAC1D3C,MAAM,CAACI,MAAM,CAACuB,QAAQ,CAACuB,OAAO,CAACC,SAAS,CAACtE,GAAG,CAAC,CAAC8D,SAAS,CAAC,gBAAgB,CAAC;IAC3E,CAAC,CAAC;IAEF5C,IAAI,CAAC,mDAAmD,EAAE,YAAM;MAC9D,IAAMK,MAAM,GAAGhC,iBAAiB,CAACiD,eAAe,EAAEW,YAAY,EAAE,OAAO,CAAC;MACxEhC,MAAM,CAACI,MAAM,CAACuB,QAAQ,CAAC,CAACpB,OAAO,CAAC;QAACU,EAAE,EAAE;MAAgB,CAAC,CAAC;IACzD,CAAC,CAAC;EACJ,CAAC,CAAC;EAEF7B,QAAQ,CAAC,sBAAsB,EAAE,YAAM;IACrCW,IAAI,CAAC,qCAAqC,EAAE,YAAM;MAChD,IAAMmC,KAAK,GAAG;QAACZ,QAAQ,EAAE;UAAC8B,OAAO,EAAE;QAAE,CAAC;QAAE7B,QAAQ,EAAE,CAAC,CAAC;QAAEI,QAAQ,EAAE,CAAC;MAAC,CAAC;MACnE3B,MAAM,CAAC3B,oBAAoB,CAAC6D,KAAK,CAAC,CAAC,CAAC3B,OAAO,CAAC,EAAE,CAAC;IACjD,CAAC,CAAC;IAEFR,IAAI,CAAC,wDAAwD,EAAE,YAAM;MACnE,IAAMmC,KAAK,GAAG;QAACZ,QAAQ,EAAE,CAAC,CAAC;QAAEC,QAAQ,EAAE,CAAC,CAAC;QAAEI,QAAQ,EAAE,CAAC;MAAC,CAAC;MACxD3B,MAAM,CAAC3B,oBAAoB,CAAC6D,KAAK,CAAC,CAAC,CAAC3B,OAAO,CAAC,EAAE,CAAC;IACjD,CAAC,CAAC;IAEFR,IAAI,CAAC,mDAAmD,EAAE,YAAM;MAC9D,IAAMqD,OAAO,GAAG,CACd;QAAC9D,IAAI,EAAEtB,YAAY,CAACuB,SAAS;QAAE8D,IAAI,EAAEpF,iBAAiB,CAACqF,QAAQ;QAAErC,EAAE,EAAE;MAAI,CAAC,EAC1E;QAAC3B,IAAI,EAAEtB,YAAY,CAACuF,KAAK;QAAEF,IAAI,EAAEpF,iBAAiB,CAACqF,QAAQ;QAAErC,EAAE,EAAE;MAAI,CAAC,EACtE;QAAC3B,IAAI,EAAEtB,YAAY,CAACuB,SAAS;QAAE8D,IAAI,EAAEpF,iBAAiB,CAACuF,IAAI;QAAEvC,EAAE,EAAE;MAAI,CAAC,CACvE;MACD,IAAMiB,KAAK,GAAG;QAACZ,QAAQ,EAAE;UAAC8B,OAAO,EAAPA;QAAO,CAAC;QAAE7B,QAAQ,EAAE,CAAC,CAAC;QAAEI,QAAQ,EAAE,CAAC;MAAC,CAAC;MAC/D,IAAMvB,MAAM,GAAG/B,oBAAoB,CAAC6D,KAAK,CAAC;MAE1ClC,MAAM,CAACI,MAAM,CAAC,CAACqD,YAAY,CAAC,CAAC,CAAC;MAC9BzD,MAAM,CAACI,MAAM,CAAC,CAAC,CAAC,CAACa,EAAE,CAAC,CAACP,IAAI,CAAC,IAAI,CAAC;IACjC,CAAC,CAAC;IAEFX,IAAI,CAAC,uDAAuD,EAAE,YAAM;MAClE,IAAMqD,OAAO,GAAG,CACd;QACE9D,IAAI,EAAEtB,YAAY,CAACuB,SAAS;QAC5B8D,IAAI,EAAEpF,iBAAiB,CAACuF,IAAI;QAC5BE,uBAAuB,EAAE,IAAI;QAC7BzC,EAAE,EAAE;MACN,CAAC,EACD;QACE3B,IAAI,EAAEtB,YAAY,CAACuB,SAAS;QAC5B8D,IAAI,EAAEpF,iBAAiB,CAACuF,IAAI;QAC5BE,uBAAuB,EAAE,KAAK;QAC9BzC,EAAE,EAAE;MACN,CAAC,CACF;MACD,IAAMiB,KAAK,GAAG;QAACZ,QAAQ,EAAE;UAAC8B,OAAO,EAAPA;QAAO,CAAC;QAAE7B,QAAQ,EAAE,CAAC,CAAC;QAAEI,QAAQ,EAAE,CAAC;MAAC,CAAC;MAC/D,IAAMvB,MAAM,GAAG/B,oBAAoB,CAAC6D,KAAK,CAAC;MAE1ClC,MAAM,CAACI,MAAM,CAAC,CAACqD,YAAY,CAAC,CAAC,CAAC;MAC9BzD,MAAM,CAACI,MAAM,CAAC,CAAC,CAAC,CAACa,EAAE,CAAC,CAACP,IAAI,CAAC,QAAQ,CAAC;IACrC,CAAC,CAAC;EACJ,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]}

package/dist/esm/modals/image-modal-container.js

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useEffect } from 'react';
+import get from 'lodash/get';
+import { MAP_THUMBNAIL_DIMENSION, EXPORT_IMG_RATIOS } from '@kepler.gl/constants';
+// TODO: this should be turned into a custom hook
+/**
+ * A wrapper component in modals contain a image preview of the map with cloud providers
+ * It sets export image size based on provider thumbnail size
+ * @type {React.FunctionComponent<ImageModalContainerProps>}
+ */
+var ImageModalContainer = function ImageModalContainer(_ref) {
+  var onUpdateImageSetting = _ref.onUpdateImageSetting,
+    cleanupExportImage = _ref.cleanupExportImage,
+    provider = _ref.provider,
+    children = _ref.children;
+  useEffect(function () {
+    onUpdateImageSetting({
+      exporting: true
+    });
+    return function () {
+      cleanupExportImage();
+    };
+  }, [onUpdateImageSetting, cleanupExportImage]);
+  useEffect(function () {
+    if (provider) {
+      if (provider.thumbnail) {
+        onUpdateImageSetting({
+          mapW: get(provider, ['thumbnail', 'width']) || MAP_THUMBNAIL_DIMENSION.width,
+          mapH: get(provider, ['thumbnail', 'height']) || MAP_THUMBNAIL_DIMENSION.height,
+          ratio: EXPORT_IMG_RATIOS.CUSTOM,
+          legend: false
+        });
+      }
+    } else {
+      onUpdateImageSetting({
+        mapW: MAP_THUMBNAIL_DIMENSION.width,
+        mapH: MAP_THUMBNAIL_DIMENSION.height,
+        ratio: EXPORT_IMG_RATIOS.CUSTOM,
+        legend: false
+      });
+    }
+  }, [provider, onUpdateImageSetting]);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, children);
+};
+export default ImageModalContainer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/modals/load-data-modal.js

@@ -0,0 +1,89 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _excluded = ["onFileUpload", "onTilesetAdded", "fileLoading", "loadingMethods", "isCloudMapLoading"];
+var _templateObject;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useState } from 'react';
+import styled from 'styled-components';
+import get from 'lodash/get';
+import { useIntl } from 'react-intl';
+import FileUploadFactory from '../common/file-uploader/file-upload';
+import LoadStorageMapFactory from './load-storage-map';
+import LoadTilesetFactory from './tilesets-modals/load-tileset';
+import ModalTabsFactory from './modal-tabs';
+import LoadingDialog from './loading-dialog';
+import { LOADING_METHODS } from '@kepler.gl/constants';
+var StyledLoadDataModal = styled.div.attrs({
+  className: 'load-data-modal'
+})(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  padding: ", ";\n  min-height: 440px;\n  display: flex;\n  flex-direction: column;\n"])), function (props) {
+  return props.theme.modalPadding;
+});
+var noop = function noop() {
+  return;
+};
+var getDefaultMethod = function getDefaultMethod() {
+  var methods = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return Array.isArray(methods) ? get(methods, [0]) : null;
+};
+LoadDataModalFactory.deps = [ModalTabsFactory, FileUploadFactory, LoadStorageMapFactory, LoadTilesetFactory];
+export function LoadDataModalFactory(ModalTabs, FileUpload, LoadStorageMap, LoadTileset) {
+  var defaultLoadingMethods = [{
+    id: LOADING_METHODS.upload,
+    label: 'modal.loadData.upload',
+    elementType: FileUpload
+  }, {
+    id: LOADING_METHODS.tileset,
+    label: 'modal.loadData.tileset',
+    elementType: LoadTileset
+  }, {
+    id: LOADING_METHODS.storage,
+    label: 'modal.loadData.storage',
+    elementType: LoadStorageMap
+  }];
+  var LoadDataModal = function LoadDataModal(_ref) {
+    var _ref$onFileUpload = _ref.onFileUpload,
+      onFileUpload = _ref$onFileUpload === void 0 ? noop : _ref$onFileUpload,
+      _ref$onTilesetAdded = _ref.onTilesetAdded,
+      onTilesetAdded = _ref$onTilesetAdded === void 0 ? noop : _ref$onTilesetAdded,
+      _ref$fileLoading = _ref.fileLoading,
+      fileLoading = _ref$fileLoading === void 0 ? false : _ref$fileLoading,
+      _ref$loadingMethods = _ref.loadingMethods,
+      loadingMethods = _ref$loadingMethods === void 0 ? defaultLoadingMethods : _ref$loadingMethods,
+      isCloudMapLoading = _ref.isCloudMapLoading,
+      restProps = _objectWithoutProperties(_ref, _excluded);
+    var intl = useIntl();
+    var currentModalProps = _objectSpread(_objectSpread({}, restProps), {}, {
+      onFileUpload: onFileUpload,
+      onTilesetAdded: onTilesetAdded,
+      fileLoading: fileLoading,
+      isCloudMapLoading: isCloudMapLoading
+    });
+    // const {loadingMethods, isCloudMapLoading} = props;
+    var _useState = useState(getDefaultMethod(loadingMethods)),
+      _useState2 = _slicedToArray(_useState, 2),
+      currentMethod = _useState2[0],
+      toggleMethod = _useState2[1];
+    var ElementType = currentMethod === null || currentMethod === void 0 ? void 0 : currentMethod.elementType;
+    return /*#__PURE__*/React.createElement(StyledLoadDataModal, null, /*#__PURE__*/React.createElement(ModalTabs, {
+      currentMethod: currentMethod === null || currentMethod === void 0 ? void 0 : currentMethod.id,
+      loadingMethods: loadingMethods,
+      toggleMethod: toggleMethod
+    }), isCloudMapLoading ? /*#__PURE__*/React.createElement(LoadingDialog, {
+      size: 64
+    }) : ElementType && /*#__PURE__*/React.createElement(ElementType, _extends({
+      key: currentMethod === null || currentMethod === void 0 ? void 0 : currentMethod.id,
+      intl: intl
+    }, currentModalProps)));
+  };
+  LoadDataModal.defaultLoadingMethods = defaultLoadingMethods;
+  return LoadDataModal;
+}
+export default LoadDataModalFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useState","styled","get","useIntl","FileUploadFactory","LoadStorageMapFactory","LoadTilesetFactory","ModalTabsFactory","LoadingDialog","LOADING_METHODS","StyledLoadDataModal","div","attrs","className","_templateObject","_taggedTemplateLiteral","props","theme","modalPadding","noop","getDefaultMethod","methods","arguments","length","undefined","Array","isArray","LoadDataModalFactory","deps","ModalTabs","FileUpload","LoadStorageMap","LoadTileset","defaultLoadingMethods","id","upload","label","elementType","tileset","storage","LoadDataModal","_ref","_ref$onFileUpload","onFileUpload","_ref$onTilesetAdded","onTilesetAdded","_ref$fileLoading","fileLoading","_ref$loadingMethods","loadingMethods","isCloudMapLoading","restProps","_objectWithoutProperties","_excluded","intl","currentModalProps","_objectSpread","_useState","_useState2","_slicedToArray","currentMethod","toggleMethod","ElementType","createElement","size","_extends","key"],"sources":["../../../src/modals/load-data-modal.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useState} from 'react';\nimport styled from 'styled-components';\nimport get from 'lodash/get';\nimport {IntlShape, useIntl} from 'react-intl';\n\nimport FileUploadFactory from '../common/file-uploader/file-upload';\nimport LoadStorageMapFactory from './load-storage-map';\nimport LoadTilesetFactory from './tilesets-modals/load-tileset';\nimport ModalTabsFactory from './modal-tabs';\nimport LoadingDialog from './loading-dialog';\n\nimport {LOADING_METHODS} from '@kepler.gl/constants';\nimport {FileLoading, FileLoadingProgress, LoadFiles} from '@kepler.gl/types';\n\nconst StyledLoadDataModal = styled.div.attrs({\n  className: 'load-data-modal'\n})`\n  padding: ${props => props.theme.modalPadding};\n  min-height: 440px;\n  display: flex;\n  flex-direction: column;\n`;\n\nconst noop = () => {\n  return;\n};\nconst getDefaultMethod = <T,>(methods: T[] = []) =>\n  Array.isArray(methods) ? get(methods, [0]) : null;\nexport interface LoadingMethod {\n  id: string;\n  label: string;\n  elementType: React.ComponentType<any>;\n  tabElementType?: React.ComponentType<{onClick: React.MouseEventHandler; intl: IntlShape}>;\n}\n\ntype LoadDataModalProps = {\n  // call backs\n  onFileUpload: (files: File[]) => void;\n  onLoadCloudMap: (provider: any, vis: any) => void;\n  onTilesetAdded: (\n    tileset: {name: string; type: string; metadata: Record<string, any>},\n    processedMetadata?: Record<string, any>\n  ) => void;\n  fileLoading: FileLoading | false;\n  loadingMethods?: LoadingMethod[];\n  /** A list of names of supported formats suitable to present to user */\n  fileFormatNames: string[];\n  /** A list of typically 3 letter extensions (without '.') for file matching */\n  fileExtensions: string[];\n  isCloudMapLoading: boolean;\n  /** Set to true if app wants to do its own file filtering */\n  disableExtensionFilter?: boolean;\n  onClose?: (...args: any) => any;\n\n  loadFiles: LoadFiles;\n  fileLoadingProgress: FileLoadingProgress;\n};\n\nLoadDataModalFactory.deps = [\n  ModalTabsFactory,\n  FileUploadFactory,\n  LoadStorageMapFactory,\n  LoadTilesetFactory\n];\n\nexport function LoadDataModalFactory(\n  ModalTabs: ReturnType<typeof ModalTabsFactory>,\n  FileUpload: ReturnType<typeof FileUploadFactory>,\n  LoadStorageMap: ReturnType<typeof LoadStorageMapFactory>,\n  LoadTileset: ReturnType<typeof LoadTilesetFactory>\n) {\n  const defaultLoadingMethods = [\n    {\n      id: LOADING_METHODS.upload,\n      label: 'modal.loadData.upload',\n      elementType: FileUpload\n    },\n    {\n      id: LOADING_METHODS.tileset,\n      label: 'modal.loadData.tileset',\n      elementType: LoadTileset\n    },\n    {\n      id: LOADING_METHODS.storage,\n      label: 'modal.loadData.storage',\n      elementType: LoadStorageMap\n    }\n  ];\n\n  const LoadDataModal: React.FC<LoadDataModalProps> & {\n    defaultLoadingMethods: LoadDataModalProps['loadingMethods'];\n  } = ({\n    onFileUpload = noop,\n    onTilesetAdded = noop,\n    fileLoading = false,\n    loadingMethods = defaultLoadingMethods,\n    isCloudMapLoading,\n    ...restProps\n  }) => {\n    const intl = useIntl();\n    const currentModalProps = {\n      ...restProps,\n      onFileUpload,\n      onTilesetAdded,\n      fileLoading,\n      isCloudMapLoading\n    };\n    // const {loadingMethods, isCloudMapLoading} = props;\n    const [currentMethod, toggleMethod] = useState(getDefaultMethod(loadingMethods));\n\n    const ElementType = currentMethod?.elementType;\n\n    return (\n      <StyledLoadDataModal>\n        <ModalTabs\n          currentMethod={currentMethod?.id}\n          loadingMethods={loadingMethods}\n          toggleMethod={toggleMethod}\n        />\n        {isCloudMapLoading ? (\n          <LoadingDialog size={64} />\n        ) : (\n          ElementType && <ElementType key={currentMethod?.id} intl={intl} {...currentModalProps} />\n        )}\n      </StyledLoadDataModal>\n    );\n  };\n\n  LoadDataModal.defaultLoadingMethods = defaultLoadingMethods;\n\n  return LoadDataModal;\n}\n\nexport default LoadDataModalFactory;\n"],"mappings":"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","ignoreList":[]}