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

package/dist/esm/modals/load-storage-map.js

@@ -0,0 +1,70 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useState, useEffect } from 'react';
+import CloudHeaderFactory from './cloud-components/cloud-header';
+import { CloudMaps } from './cloud-components/cloud-maps';
+import { useCloudListProvider } from '../hooks/use-cloud-list-provider';
+import { ProviderSelect } from './cloud-components/provider-select';
+import { FlexColContainer } from '../common/flex-container';
+LoadStorageMapFactory.deps = [CloudHeaderFactory];
+function LoadStorageMapFactory(CloudHeader) {
+  var LoadStorageMap = function LoadStorageMap(_ref) {
+    var onLoadCloudMap = _ref.onLoadCloudMap;
+    var _useCloudListProvider = useCloudListProvider(),
+      currentProvider = _useCloudListProvider.provider,
+      setProvider = _useCloudListProvider.setProvider,
+      cloudProviders = _useCloudListProvider.cloudProviders;
+    var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      isLoading = _useState2[0],
+      setIsLoading = _useState2[1];
+    var _useState3 = useState(null),
+      _useState4 = _slicedToArray(_useState3, 2),
+      maps = _useState4[0],
+      setMaps = _useState4[1];
+    var _useState5 = useState(null),
+      _useState6 = _slicedToArray(_useState5, 2),
+      error = _useState6[0],
+      setError = _useState6[1];
+    var setProviderInfo = useCallback(function (provider) {
+      setMaps(null);
+      setError(null);
+      if (provider) {
+        setIsLoading(true);
+        provider.listMaps().then(setMaps)["catch"](setError)["finally"](function () {
+          return setIsLoading(false);
+        });
+      } else {
+        setIsLoading(false);
+      }
+    }, []);
+    useEffect(function () {
+      setProviderInfo(currentProvider);
+    }, [currentProvider, setProviderInfo]);
+    var onSelectMap = useCallback(function (provider, map) {
+      onLoadCloudMap({
+        loadParams: map.loadParams,
+        provider: provider
+      });
+    }, [onLoadCloudMap]);
+    return /*#__PURE__*/React.createElement(FlexColContainer, null, !currentProvider ? /*#__PURE__*/React.createElement(ProviderSelect, {
+      cloudProviders: cloudProviders
+    }) : /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(CloudHeader, {
+      provider: currentProvider,
+      onBack: function onBack() {
+        return setProvider(null);
+      }
+    }), /*#__PURE__*/React.createElement(CloudMaps, {
+      isLoading: isLoading,
+      onSelectMap: onSelectMap,
+      provider: currentProvider,
+      error: error,
+      maps: maps
+    })));
+  };
+  return LoadStorageMap;
+}
+export default LoadStorageMapFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/modals/load-storage-map.spec.js

@@ -0,0 +1,212 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// @ts-nocheck
+import React from 'react';
+import { fireEvent, waitFor } from '@testing-library/react';
+import InfoHelperFactory from '../common/info-helper';
+import CloudHeaderFactory from './cloud-components/cloud-header';
+import LoadStorageMapFactory from './load-storage-map';
+import { renderWithTheme } from 'test/helpers/component-jest-utils';
+import { useCloudListProvider } from '../hooks/use-cloud-list-provider';
+import { dataTestIds } from '@kepler.gl/constants';
+var InfoHelper = InfoHelperFactory();
+var CloudHeader = CloudHeaderFactory(InfoHelper);
+var LoadStorageMap = LoadStorageMapFactory(CloudHeader);
+var DEFAULT_MAPS = [{
+  id: '1234',
+  title: 'first map',
+  description: 'description 1',
+  loadParams: {
+    id: '1234'
+  }
+}, {
+  id: '5678',
+  title: 'second map',
+  description: 'description 2',
+  loadParams: {
+    id: '5678'
+  }
+}];
+var DEFAULT_PROVIDER = {
+  name: 'test provider',
+  icon: jest.fn(),
+  getManagementUrl: jest.fn().mockImplementation(function () {
+    return 'provider.url';
+  }),
+  listMaps: jest.fn().mockResolvedValue([])
+};
+var DEFAULT_PROPS = {
+  onLoadCloudMap: jest.fn()
+};
+jest.mock('../hooks/use-cloud-list-provider', function () {
+  return {
+    useCloudListProvider: jest.fn().mockImplementation(function () {
+      return {
+        provider: null,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    })
+  };
+});
+describe('LoadStorageMap', function () {
+  afterEach(function () {
+    jest.clearAllMocks();
+  });
+  test('renders provider select and no cloud components when provider is set to null', function () {
+    var _renderWithTheme = renderWithTheme(/*#__PURE__*/React.createElement(LoadStorageMap, DEFAULT_PROPS)),
+      getByTestId = _renderWithTheme.getByTestId;
+    expect(getByTestId(dataTestIds.providerSelect)).toBeInTheDocument();
+  });
+  test('renders empty map list because fetchmaps return empty array', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var _renderWithTheme2, getByText;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          useCloudListProvider.mockImplementation(function () {
+            return {
+              provider: DEFAULT_PROVIDER,
+              setProvider: jest.fn(),
+              cloudProviders: []
+            };
+          });
+          _renderWithTheme2 = renderWithTheme(/*#__PURE__*/React.createElement(LoadStorageMap, DEFAULT_PROPS)), getByText = _renderWithTheme2.getByText;
+          expect(DEFAULT_PROVIDER.listMaps).toHaveBeenCalled();
+
+          // first show loading icon
+          expect(getByText('modal.loadingDialog.loading')).toBeInTheDocument();
+
+          // show empty maps
+          _context.next = 6;
+          return waitFor(function () {
+            expect(getByText('modal.loadStorageMap.noSavedMaps')).toBeInTheDocument();
+          });
+        case 6:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  test('renders map list because', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var mapProvider, _renderWithTheme3, getByText;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          mapProvider = {
+            name: 'test provider',
+            icon: jest.fn(),
+            getManagementUrl: jest.fn().mockImplementation(function () {
+              return 'provider.url';
+            }),
+            listMaps: jest.fn().mockResolvedValue(DEFAULT_MAPS)
+          };
+          useCloudListProvider.mockImplementation(function () {
+            return {
+              provider: mapProvider,
+              setProvider: jest.fn(),
+              cloudProviders: []
+            };
+          });
+          _renderWithTheme3 = renderWithTheme(/*#__PURE__*/React.createElement(LoadStorageMap, DEFAULT_PROPS)), getByText = _renderWithTheme3.getByText;
+          expect(mapProvider.listMaps).toHaveBeenCalled();
+
+          // first show loading icon
+          expect(getByText('modal.loadingDialog.loading')).toBeInTheDocument();
+
+          // show empty maps
+          _context2.next = 7;
+          return waitFor(function () {
+            DEFAULT_MAPS.forEach(function (map) {
+              expect(getByText(map.title)).toBeInTheDocument();
+              expect(getByText(map.description)).toBeInTheDocument();
+            });
+          });
+        case 7:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  test('trigger onLoadCLoudMap when clicking on a map', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    var mapProvider, _renderWithTheme4, getByText;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          mapProvider = {
+            name: 'test provider',
+            icon: jest.fn(),
+            getManagementUrl: jest.fn().mockImplementation(function () {
+              return 'provider.url';
+            }),
+            listMaps: jest.fn().mockResolvedValue(DEFAULT_MAPS)
+          };
+          useCloudListProvider.mockImplementation(function () {
+            return {
+              provider: mapProvider,
+              setProvider: jest.fn(),
+              cloudProviders: []
+            };
+          });
+          _renderWithTheme4 = renderWithTheme(/*#__PURE__*/React.createElement(LoadStorageMap, DEFAULT_PROPS)), getByText = _renderWithTheme4.getByText;
+          expect(mapProvider.listMaps).toHaveBeenCalled();
+
+          // first show loading icon
+          expect(getByText('modal.loadingDialog.loading')).toBeInTheDocument();
+
+          // click on a map
+          _context3.next = 7;
+          return waitFor(function () {
+            var map = DEFAULT_MAPS[0];
+            // if the component doesn't exist this will throw an exception
+            var mapTitleComponent = getByText(map.title);
+            fireEvent.click(mapTitleComponent);
+            expect(DEFAULT_PROPS.onLoadCloudMap).toHaveBeenCalled();
+          });
+        case 7:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  test('renders errors because fetchmaps rejects', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var rejectableProvider, _renderWithTheme5, getByText;
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          rejectableProvider = {
+            name: 'test provider',
+            icon: jest.fn(),
+            getManagementUrl: jest.fn().mockImplementation(function () {
+              return 'provider.url';
+            }),
+            listMaps: jest.fn().mockRejectedValue(new Error('timeout'))
+          };
+          useCloudListProvider.mockImplementation(function () {
+            return {
+              provider: rejectableProvider,
+              setProvider: jest.fn(),
+              cloudProviders: []
+            };
+          });
+          _renderWithTheme5 = renderWithTheme(/*#__PURE__*/React.createElement(LoadStorageMap, DEFAULT_PROPS)), getByText = _renderWithTheme5.getByText;
+          expect(rejectableProvider.listMaps).toHaveBeenCalled();
+
+          // first show loading icon
+          expect(getByText('modal.loadingDialog.loading')).toBeInTheDocument();
+
+          // show empty maps
+          _context4.next = 7;
+          return waitFor(function () {
+            expect(getByText('Error while fetching maps: timeout')).toBeInTheDocument();
+          });
+        case 7:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","fireEvent","waitFor","InfoHelperFactory","CloudHeaderFactory","LoadStorageMapFactory","renderWithTheme","useCloudListProvider","dataTestIds","InfoHelper","CloudHeader","LoadStorageMap","DEFAULT_MAPS","id","title","description","loadParams","DEFAULT_PROVIDER","name","icon","jest","fn","getManagementUrl","mockImplementation","listMaps","mockResolvedValue","DEFAULT_PROPS","onLoadCloudMap","mock","provider","setProvider","cloudProviders","describe","afterEach","clearAllMocks","test","_renderWithTheme","createElement","getByTestId","expect","providerSelect","toBeInTheDocument","_asyncToGenerator","_regeneratorRuntime","mark","_callee","_renderWithTheme2","getByText","wrap","_callee$","_context","prev","next","toHaveBeenCalled","stop","_callee2","mapProvider","_renderWithTheme3","_callee2$","_context2","forEach","map","_callee3","_renderWithTheme4","_callee3$","_context3","mapTitleComponent","click","_callee4","rejectableProvider","_renderWithTheme5","_callee4$","_context4","mockRejectedValue","Error"],"sources":["../../../src/modals/load-storage-map.spec.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n// @ts-nocheck\nimport React from 'react';\nimport {fireEvent, waitFor} from '@testing-library/react';\nimport InfoHelperFactory from '../common/info-helper';\nimport CloudHeaderFactory from './cloud-components/cloud-header';\nimport LoadStorageMapFactory from './load-storage-map';\nimport {renderWithTheme} from 'test/helpers/component-jest-utils';\nimport {useCloudListProvider} from '../hooks/use-cloud-list-provider';\nimport {dataTestIds} from '@kepler.gl/constants';\n\nconst InfoHelper = InfoHelperFactory();\nconst CloudHeader = CloudHeaderFactory(InfoHelper);\nconst LoadStorageMap = LoadStorageMapFactory(CloudHeader);\n\nconst DEFAULT_MAPS = [\n  {\n    id: '1234',\n    title: 'first map',\n    description: 'description 1',\n    loadParams: {\n      id: '1234'\n    }\n  },\n  {\n    id: '5678',\n    title: 'second map',\n    description: 'description 2',\n    loadParams: {\n      id: '5678'\n    }\n  }\n];\n\nconst DEFAULT_PROVIDER = {\n  name: 'test provider',\n  icon: jest.fn(),\n  getManagementUrl: jest.fn().mockImplementation(() => 'provider.url'),\n  listMaps: jest.fn().mockResolvedValue([])\n};\n\nconst DEFAULT_PROPS = {\n  onLoadCloudMap: jest.fn()\n};\n\njest.mock('../hooks/use-cloud-list-provider', () => ({\n  useCloudListProvider: jest.fn().mockImplementation(() => ({\n    provider: null,\n    setProvider: jest.fn(),\n    cloudProviders: []\n  }))\n}));\n\ndescribe('LoadStorageMap', () => {\n  afterEach(() => {\n    jest.clearAllMocks();\n  });\n\n  test('renders provider select and no cloud components when provider is set to null', () => {\n    const {getByTestId} = renderWithTheme(<LoadStorageMap {...DEFAULT_PROPS} />);\n    expect(getByTestId(dataTestIds.providerSelect)).toBeInTheDocument();\n  });\n\n  test('renders empty map list because fetchmaps return empty array', async () => {\n    useCloudListProvider.mockImplementation(() => ({\n      provider: DEFAULT_PROVIDER,\n      setProvider: jest.fn(),\n      cloudProviders: []\n    }));\n\n    const {getByText} = renderWithTheme(<LoadStorageMap {...DEFAULT_PROPS} />);\n    expect(DEFAULT_PROVIDER.listMaps).toHaveBeenCalled();\n\n    // first show loading icon\n    expect(getByText('modal.loadingDialog.loading')).toBeInTheDocument();\n\n    // show empty maps\n    await waitFor(() => {\n      expect(getByText('modal.loadStorageMap.noSavedMaps')).toBeInTheDocument();\n    });\n  });\n\n  test('renders map list because', async () => {\n    const mapProvider = {\n      name: 'test provider',\n      icon: jest.fn(),\n      getManagementUrl: jest.fn().mockImplementation(() => 'provider.url'),\n      listMaps: jest.fn().mockResolvedValue(DEFAULT_MAPS)\n    };\n    useCloudListProvider.mockImplementation(() => ({\n      provider: mapProvider,\n      setProvider: jest.fn(),\n      cloudProviders: []\n    }));\n\n    const {getByText} = renderWithTheme(<LoadStorageMap {...DEFAULT_PROPS} />);\n    expect(mapProvider.listMaps).toHaveBeenCalled();\n\n    // first show loading icon\n    expect(getByText('modal.loadingDialog.loading')).toBeInTheDocument();\n\n    // show empty maps\n    await waitFor(() => {\n      DEFAULT_MAPS.forEach(map => {\n        expect(getByText(map.title)).toBeInTheDocument();\n        expect(getByText(map.description)).toBeInTheDocument();\n      });\n    });\n  });\n\n  test('trigger onLoadCLoudMap when clicking on a map', async () => {\n    const mapProvider = {\n      name: 'test provider',\n      icon: jest.fn(),\n      getManagementUrl: jest.fn().mockImplementation(() => 'provider.url'),\n      listMaps: jest.fn().mockResolvedValue(DEFAULT_MAPS)\n    };\n    useCloudListProvider.mockImplementation(() => ({\n      provider: mapProvider,\n      setProvider: jest.fn(),\n      cloudProviders: []\n    }));\n\n    const {getByText} = renderWithTheme(<LoadStorageMap {...DEFAULT_PROPS} />);\n    expect(mapProvider.listMaps).toHaveBeenCalled();\n\n    // first show loading icon\n    expect(getByText('modal.loadingDialog.loading')).toBeInTheDocument();\n\n    // click on a map\n    await waitFor(() => {\n      const map = DEFAULT_MAPS[0];\n      // if the component doesn't exist this will throw an exception\n      const mapTitleComponent = getByText(map.title);\n      fireEvent.click(mapTitleComponent);\n      expect(DEFAULT_PROPS.onLoadCloudMap).toHaveBeenCalled();\n    });\n  });\n\n  test('renders errors because fetchmaps rejects', async () => {\n    const rejectableProvider = {\n      name: 'test provider',\n      icon: jest.fn(),\n      getManagementUrl: jest.fn().mockImplementation(() => 'provider.url'),\n      listMaps: jest.fn().mockRejectedValue(new Error('timeout'))\n    };\n    useCloudListProvider.mockImplementation(() => ({\n      provider: rejectableProvider,\n      setProvider: jest.fn(),\n      cloudProviders: []\n    }));\n\n    const {getByText} = renderWithTheme(<LoadStorageMap {...DEFAULT_PROPS} />);\n    expect(rejectableProvider.listMaps).toHaveBeenCalled();\n\n    // first show loading icon\n    expect(getByText('modal.loadingDialog.loading')).toBeInTheDocument();\n\n    // show empty maps\n    await waitFor(() => {\n      expect(getByText('Error while fetching maps: timeout')).toBeInTheDocument();\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/modals/loading-dialog.js

@@ -0,0 +1,32 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import styled from 'styled-components';
+import LoadingSpinner from '../common/loading-spinner';
+import { FormattedMessage } from '@kepler.gl/localization';
+var StyledSpinner = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  text-align: center;\n\n  span {\n    margin: 0 auto;\n  }\n"])));
+var StyledLoadingDialog = styled.div.attrs({
+  className: 'data-loading-dialog'
+})(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  display: flex;\n  align-items: center;\n  justify-content: center;\n  flex-grow: 1;\n\n  .loading-content {\n    display: flex;\n    justify-content: center;\n    align-items: center;\n  }\n\n  .loading-message {\n    margin-left: 32px;\n    color: ", ";\n    font-weight: 500;\n    font-size: 14px;\n  }\n"])), function (props) {
+  return props.theme.titleColorLT;
+});
+var LoadingDialog = function LoadingDialog(_ref) {
+  var _ref$size = _ref.size,
+    size = _ref$size === void 0 ? 64 : _ref$size,
+    _ref$message = _ref.message,
+    message = _ref$message === void 0 ? 'modal.loadingDialog.loading' : _ref$message;
+  return /*#__PURE__*/React.createElement(StyledLoadingDialog, null, /*#__PURE__*/React.createElement("div", {
+    className: "loading-content"
+  }, /*#__PURE__*/React.createElement(StyledSpinner, null, /*#__PURE__*/React.createElement(LoadingSpinner, {
+    size: size
+  })), /*#__PURE__*/React.createElement("div", {
+    className: "loading-message"
+  }, /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: message
+  }))));
+};
+export default LoadingDialog;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/modals/modal-dialog.js

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import Modal from '../common/modal';
+var ModalDialogFactory = function ModalDialogFactory() {
+  return Modal;
+};
+export default ModalDialogFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJNb2RhbCIsIk1vZGFsRGlhbG9nRmFjdG9yeSJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9tb2RhbHMvbW9kYWwtZGlhbG9nLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUXG4vLyBDb3B5cmlnaHQgY29udHJpYnV0b3JzIHRvIHRoZSBrZXBsZXIuZ2wgcHJvamVjdFxuXG5pbXBvcnQgTW9kYWwgZnJvbSAnLi4vY29tbW9uL21vZGFsJztcblxuY29uc3QgTW9kYWxEaWFsb2dGYWN0b3J5ID0gKCkgPT4gTW9kYWw7XG5cbmV4cG9ydCBkZWZhdWx0IE1vZGFsRGlhbG9nRmFjdG9yeTtcbiJdLCJtYXBwaW5ncyI6IkFBQUE7QUFDQTs7QUFFQSxPQUFPQSxLQUFLLE1BQU0saUJBQWlCO0FBRW5DLElBQU1DLGtCQUFrQixHQUFHLFNBQXJCQSxrQkFBa0JBLENBQUE7RUFBQSxPQUFTRCxLQUFLO0FBQUE7QUFFdEMsZUFBZUMsa0JBQWtCIiwiaWdub3JlTGlzdCI6W119

package/dist/esm/modals/modal-tabs.js

@@ -0,0 +1,67 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback } from 'react';
+import classnames from 'classnames';
+import styled from 'styled-components';
+import { media } from '@kepler.gl/styles';
+import { FormattedMessage, useIntl } from 'react-intl';
+var ModalTab = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  align-items: flex-end;\n  display: flex;\n  border-bottom: 1px solid #d8d8d8;\n  margin-bottom: 32px;\n  justify-content: space-between;\n\n  .load-data-modal__tab__inner {\n    display: flex;\n    width: 100%;\n  }\n\n  .load-data-modal__tab__item.active {\n    color: ", ";\n    border-bottom: 3px solid ", ";\n    font-weight: 500;\n  }\n\n  ", ";\n"])), function (props) {
+  return props.theme.textColorLT;
+}, function (props) {
+  return props.theme.textColorLT;
+}, media.portable(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n    font-size: 12px;\n  "]))));
+var StyledLoadDataModalTabItem = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  border-bottom: 3px solid transparent;\n  cursor: pointer;\n  margin-left: 32px;\n  padding: 16px 0;\n  font-size: 14px;\n  font-weight: 400;\n  color: ", ";\n\n  ", ";\n\n  :first-child {\n    margin-left: 0;\n    padding-left: 0;\n  }\n\n  &:hover {\n    color: ", ";\n  }\n"])), function (props) {
+  return props.theme.subtextColorLT;
+}, media.portable(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n    margin-left: 16px;\n    font-size: 12px;\n  "]))), function (props) {
+  return props.theme.textColorLT;
+});
+var noop = function noop() {
+  return;
+};
+export var ModalTabItem = function ModalTabItem(_ref) {
+  var currentMethod = _ref.currentMethod,
+    method = _ref.method,
+    toggleMethod = _ref.toggleMethod;
+  var onClick = useCallback(function () {
+    return toggleMethod(method);
+  }, [method, toggleMethod]);
+  var intl = useIntl();
+  return method.tabElementType ? /*#__PURE__*/React.createElement(method.tabElementType, {
+    onClick: onClick,
+    intl: intl
+  }) : /*#__PURE__*/React.createElement(StyledLoadDataModalTabItem, {
+    className: classnames('load-data-modal__tab__item', {
+      active: currentMethod && method.id === currentMethod
+    }),
+    onClick: onClick
+  }, /*#__PURE__*/React.createElement("div", null, method.label ? /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: method.label
+  }) : method.id));
+};
+function ModalTabsFactory() {
+  var ModalTabs = function ModalTabs(_ref2) {
+    var currentMethod = _ref2.currentMethod,
+      _ref2$toggleMethod = _ref2.toggleMethod,
+      toggleMethod = _ref2$toggleMethod === void 0 ? noop : _ref2$toggleMethod,
+      _ref2$loadingMethods = _ref2.loadingMethods,
+      loadingMethods = _ref2$loadingMethods === void 0 ? [] : _ref2$loadingMethods;
+    return /*#__PURE__*/React.createElement(ModalTab, {
+      className: "load-data-modal__tab"
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "load-data-modal__tab__inner"
+    }, loadingMethods.map(function (method) {
+      return /*#__PURE__*/React.createElement(ModalTabItem, {
+        key: method.id,
+        method: method,
+        currentMethod: currentMethod,
+        toggleMethod: toggleMethod
+      });
+    })));
+  };
+  return ModalTabs;
+}
+export default ModalTabsFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/modals/overwrite-map-modal.js

@@ -0,0 +1,76 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useMemo } from 'react';
+import styled from 'styled-components';
+import { CenterVerticalFlexbox } from '../common/styled-components';
+import { UploadAnimation } from './status-panel';
+import { FormattedMessage } from '@kepler.gl/localization';
+import ImageModalContainer from './image-modal-container';
+import { useCloudListProvider } from '../hooks/use-cloud-list-provider';
+import { ModalFooter } from '../common/modal';
+var StyledMsg = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  margin-top: 24px;\n  font-size: 14px;\n"])));
+var StyledTitle = styled.span(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  font-weight: 600;\n  color: black;\n"])));
+var StyledIcon = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  margin-top: 24px;\n"])));
+var StyledOverwriteMapModal = styled(CenterVerticalFlexbox)(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  padding: 24px 12px;\n  min-height: 220px;\n"])));
+var CONFIRM_BUTTON = {
+  large: true,
+  children: 'Yes',
+  disabled: false
+};
+var OverwriteMapModalFactory = function OverwriteMapModalFactory() {
+  /**
+   * @type {React.FunctionComponent<OverwriteMapModalProps>}
+   */
+  var OverwriteMapModal = function OverwriteMapModal(_ref) {
+    var mapSaved = _ref.mapSaved,
+      title = _ref.title,
+      isProviderLoading = _ref.isProviderLoading,
+      onUpdateImageSetting = _ref.onUpdateImageSetting,
+      cleanupExportImage = _ref.cleanupExportImage,
+      onCancel = _ref.onCancel,
+      onConfirm = _ref.onConfirm;
+    var _useCloudListProvider = useCloudListProvider(),
+      provider = _useCloudListProvider.provider;
+    var confirmButton = useMemo(function () {
+      return _objectSpread(_objectSpread({}, CONFIRM_BUTTON), {}, {
+        disabled: !provider
+      });
+    }, [provider]);
+    return /*#__PURE__*/React.createElement(ImageModalContainer, {
+      provider: provider,
+      onUpdateImageSetting: onUpdateImageSetting,
+      cleanupExportImage: cleanupExportImage
+    }, /*#__PURE__*/React.createElement(StyledOverwriteMapModal, {
+      className: "overwrite-map-modal"
+    }, isProviderLoading ? /*#__PURE__*/React.createElement(StyledMsg, null, /*#__PURE__*/React.createElement(StyledTitle, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: 'modal.overwriteMap.title'
+    })), /*#__PURE__*/React.createElement(UploadAnimation, {
+      icon: provider && provider.icon
+    })) : /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(StyledIcon, null, provider && provider.icon ? /*#__PURE__*/React.createElement(provider.icon, {
+      height: "64px"
+    }) : null), /*#__PURE__*/React.createElement(StyledMsg, {
+      className: "overwrite-map-msg"
+    }, /*#__PURE__*/React.createElement(StyledTitle, null, title, " "), /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: 'modal.overwriteMap.alreadyExists',
+      values: {
+        mapSaved: mapSaved
+      }
+    })))), /*#__PURE__*/React.createElement(ModalFooter, {
+      cancel: onCancel,
+      confirm: function confirm() {
+        return provider && onConfirm(provider);
+      },
+      confirmButton: confirmButton
+    }));
+  };
+  return OverwriteMapModal;
+};
+export var OverwriteMapModal = OverwriteMapModalFactory();
+export default OverwriteMapModalFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMemo","styled","CenterVerticalFlexbox","UploadAnimation","FormattedMessage","ImageModalContainer","useCloudListProvider","ModalFooter","StyledMsg","div","_templateObject","_taggedTemplateLiteral","StyledTitle","span","_templateObject2","StyledIcon","_templateObject3","StyledOverwriteMapModal","_templateObject4","CONFIRM_BUTTON","large","children","disabled","OverwriteMapModalFactory","OverwriteMapModal","_ref","mapSaved","title","isProviderLoading","onUpdateImageSetting","cleanupExportImage","onCancel","onConfirm","_useCloudListProvider","provider","confirmButton","_objectSpread","createElement","className","id","icon","Fragment","height","values","cancel","confirm"],"sources":["../../../src/modals/overwrite-map-modal.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useMemo} from 'react';\nimport styled from 'styled-components';\nimport {CenterVerticalFlexbox} from '../common/styled-components';\nimport {UploadAnimation} from './status-panel';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport ImageModalContainer, {ImageModalContainerProps} from './image-modal-container';\nimport {Provider} from '@kepler.gl/cloud-providers';\nimport {cleanupExportImage as cleanupExportImageAction} from '@kepler.gl/actions';\nimport {useCloudListProvider} from '../hooks/use-cloud-list-provider';\nimport {ModalFooter} from '../common/modal';\n\nconst StyledMsg = styled.div`\n  margin-top: 24px;\n  font-size: 14px;\n`;\n\nconst StyledTitle = styled.span`\n  font-weight: 600;\n  color: black;\n`;\n\nconst StyledIcon = styled.div`\n  margin-top: 24px;\n`;\n\nconst StyledOverwriteMapModal = styled(CenterVerticalFlexbox)`\n  padding: 24px 12px;\n  min-height: 220px;\n`;\n\ntype OverwriteMapModalProps = {\n  mapSaved: string | null;\n  title: string;\n  isProviderLoading: boolean;\n\n  // callbacks\n  onUpdateImageSetting: ImageModalContainerProps['onUpdateImageSetting'];\n  cleanupExportImage: typeof cleanupExportImageAction;\n  onConfirm: (provider: Provider) => void;\n  onCancel: () => void;\n};\n\nconst CONFIRM_BUTTON = {\n  large: true,\n  children: 'Yes',\n  disabled: false\n};\n\nconst OverwriteMapModalFactory = () => {\n  /**\n   * @type {React.FunctionComponent<OverwriteMapModalProps>}\n   */\n  const OverwriteMapModal: React.FC<OverwriteMapModalProps> = ({\n    mapSaved,\n    title,\n    isProviderLoading,\n    onUpdateImageSetting,\n    cleanupExportImage,\n    onCancel,\n    onConfirm\n  }) => {\n    const {provider} = useCloudListProvider();\n\n    const confirmButton = useMemo(\n      () => ({\n        ...CONFIRM_BUTTON,\n        disabled: !provider\n      }),\n      [provider]\n    );\n\n    return (\n      <ImageModalContainer\n        provider={provider}\n        onUpdateImageSetting={onUpdateImageSetting}\n        cleanupExportImage={cleanupExportImage}\n      >\n        <StyledOverwriteMapModal className=\"overwrite-map-modal\">\n          {isProviderLoading ? (\n            <StyledMsg>\n              <StyledTitle>\n                <FormattedMessage id={'modal.overwriteMap.title'} />\n              </StyledTitle>\n              <UploadAnimation icon={provider && provider.icon} />\n            </StyledMsg>\n          ) : (\n            <>\n              <StyledIcon>\n                {provider && provider.icon ? <provider.icon height=\"64px\" /> : null}\n              </StyledIcon>\n              <StyledMsg className=\"overwrite-map-msg\">\n                <StyledTitle>{title} </StyledTitle>\n                <FormattedMessage id={'modal.overwriteMap.alreadyExists'} values={{mapSaved}} />\n              </StyledMsg>\n            </>\n          )}\n        </StyledOverwriteMapModal>\n        <ModalFooter\n          cancel={onCancel}\n          confirm={() => provider && onConfirm(provider)}\n          confirmButton={confirmButton}\n        />\n      </ImageModalContainer>\n    );\n  };\n  return OverwriteMapModal;\n};\n\nexport const OverwriteMapModal = OverwriteMapModalFactory();\nexport default OverwriteMapModalFactory;\n"],"mappings":"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","ignoreList":[]}