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

package/dist/esm/modals/cloud-components/cloud-item.spec.js

@@ -0,0 +1,163 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+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 React from 'react';
+import { fireEvent, waitFor } from '@testing-library/react';
+import { renderWithTheme } from '../../../../../test/helpers/component-jest-utils';
+import { CloudItem } from './cloud-item';
+import moment from 'moment';
+var nop = function nop() {
+  return;
+};
+describe('CloudItem', function () {
+  var mockVis = {
+    title: 'Test Title',
+    description: 'Test Description',
+    updatedAt: Date.now(),
+    thumbnail: 'test-thumbnail.jpg',
+    privateMap: true
+  };
+  var observerCallback;
+  beforeEach(function () {
+    observerCallback = null;
+    var MockIntersectionObserver = /*#__PURE__*/function () {
+      function MockIntersectionObserver(cb) {
+        _classCallCheck(this, MockIntersectionObserver);
+        observerCallback = cb;
+      }
+      return _createClass(MockIntersectionObserver, [{
+        key: "observe",
+        value: function observe() {
+          // Immediately report visible for lazy-load tests
+          if (observerCallback) {
+            observerCallback([{
+              isIntersecting: true
+            }]);
+          }
+        }
+      }, {
+        key: "disconnect",
+        value: function disconnect() {
+          return undefined;
+        }
+      }, {
+        key: "unobserve",
+        value: function unobserve() {
+          return undefined;
+        }
+      }]);
+    }();
+    global.IntersectionObserver = MockIntersectionObserver;
+  });
+  it('renders without crashing', function () {
+    var _renderWithTheme = renderWithTheme(/*#__PURE__*/React.createElement(CloudItem, {
+        vis: mockVis,
+        onClick: nop
+      })),
+      getByText = _renderWithTheme.getByText;
+    expect(getByText('Test Title')).toBeInTheDocument();
+  });
+  it('renders PrivacyBadge for private maps', function () {
+    var _renderWithTheme2 = renderWithTheme(/*#__PURE__*/React.createElement(CloudItem, {
+        vis: _objectSpread(_objectSpread({}, mockVis), {}, {
+          privateMap: true
+        }),
+        onClick: nop
+      })),
+      getByText = _renderWithTheme2.getByText;
+    expect(getByText('Private')).toBeInTheDocument();
+  });
+  it('does not render PrivacyBadge for public maps', function () {
+    var _renderWithTheme3 = renderWithTheme(/*#__PURE__*/React.createElement(CloudItem, {
+        vis: _objectSpread(_objectSpread({}, mockVis), {}, {
+          privateMap: false
+        }),
+        onClick: nop
+      })),
+      queryByText = _renderWithTheme3.queryByText;
+    expect(queryByText('Private')).toBeNull();
+  });
+  it('displays correct thumbnail image', function () {
+    var _renderWithTheme4 = renderWithTheme(/*#__PURE__*/React.createElement(CloudItem, {
+        vis: mockVis,
+        onClick: nop
+      })),
+      getByRole = _renderWithTheme4.getByRole;
+    expect(getByRole('thumbnail-wrapper').style.backgroundImage).toContain('test-thumbnail.jpg');
+  });
+  it('displays MapIcon when no thumbnail is provided', function () {
+    var _renderWithTheme5 = renderWithTheme(/*#__PURE__*/React.createElement(CloudItem, {
+        vis: _objectSpread(_objectSpread({}, mockVis), {}, {
+          thumbnail: null
+        }),
+        onClick: nop
+      })),
+      getByRole = _renderWithTheme5.getByRole;
+    expect(getByRole('map-icon')).toBeInTheDocument();
+  });
+  it('displays title, description, and last modification date', function () {
+    var _renderWithTheme6 = renderWithTheme(/*#__PURE__*/React.createElement(CloudItem, {
+        vis: mockVis,
+        onClick: nop
+      })),
+      getByText = _renderWithTheme6.getByText;
+    expect(getByText('Test Title')).toBeInTheDocument();
+    expect(getByText('Test Description')).toBeInTheDocument();
+    expect(getByText("Last modified ".concat(moment.utc(mockVis.updatedAt).fromNow()))).toBeInTheDocument();
+  });
+  it('calls onClick when component is clicked', function () {
+    var onClickMock = jest.fn();
+    var _renderWithTheme7 = renderWithTheme(/*#__PURE__*/React.createElement(CloudItem, {
+        vis: mockVis,
+        onClick: onClickMock
+      })),
+      getByText = _renderWithTheme7.getByText;
+    fireEvent.click(getByText('Test Title'));
+    expect(onClickMock).toHaveBeenCalled();
+  });
+  it('lazy-loads thumbnail when tile becomes visible', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var getMapThumbnail, provider, vis, _renderWithTheme8, findByRole, thumb;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          getMapThumbnail = jest.fn().mockResolvedValue('lazy-thumb.jpg');
+          provider = {
+            hasLazyThumbnails: function hasLazyThumbnails() {
+              return true;
+            },
+            getMapThumbnail: getMapThumbnail
+          };
+          vis = _objectSpread(_objectSpread({}, mockVis), {}, {
+            thumbnail: undefined
+          });
+          _renderWithTheme8 = renderWithTheme(/*#__PURE__*/React.createElement(CloudItem, {
+            vis: vis,
+            onClick: nop,
+            provider: provider
+          })), findByRole = _renderWithTheme8.findByRole;
+          _context.next = 6;
+          return findByRole('thumbnail-wrapper');
+        case 6:
+          thumb = _context.sent;
+          _context.next = 9;
+          return waitFor(function () {
+            return expect(getMapThumbnail).toHaveBeenCalledWith(vis);
+          });
+        case 9:
+          expect(thumb.style.backgroundImage).toContain('lazy-thumb.jpg');
+        case 10:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","fireEvent","waitFor","renderWithTheme","CloudItem","moment","nop","describe","mockVis","title","description","updatedAt","Date","now","thumbnail","privateMap","observerCallback","beforeEach","MockIntersectionObserver","cb","_classCallCheck","_createClass","key","value","observe","isIntersecting","disconnect","undefined","unobserve","global","IntersectionObserver","it","_renderWithTheme","createElement","vis","onClick","getByText","expect","toBeInTheDocument","_renderWithTheme2","_objectSpread","_renderWithTheme3","queryByText","toBeNull","_renderWithTheme4","getByRole","style","backgroundImage","toContain","_renderWithTheme5","_renderWithTheme6","concat","utc","fromNow","onClickMock","jest","fn","_renderWithTheme7","click","toHaveBeenCalled","_asyncToGenerator","_regeneratorRuntime","mark","_callee","getMapThumbnail","provider","_renderWithTheme8","findByRole","thumb","wrap","_callee$","_context","prev","next","mockResolvedValue","hasLazyThumbnails","sent","toHaveBeenCalledWith","stop"],"sources":["../../../../src/modals/cloud-components/cloud-item.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 {renderWithTheme} from '../../../../../test/helpers/component-jest-utils';\n\nimport {CloudItem} from './cloud-item';\nimport moment from 'moment';\nconst nop = () => {\n  return;\n};\ndescribe('CloudItem', () => {\n  const mockVis = {\n    title: 'Test Title',\n    description: 'Test Description',\n    updatedAt: Date.now(),\n    thumbnail: 'test-thumbnail.jpg',\n    privateMap: true\n  };\n\n  let observerCallback;\n  beforeEach(() => {\n    observerCallback = null;\n    class MockIntersectionObserver {\n      constructor(cb) {\n        observerCallback = cb;\n      }\n      observe() {\n        // Immediately report visible for lazy-load tests\n        if (observerCallback) {\n          observerCallback([{isIntersecting: true}]);\n        }\n      }\n      disconnect() {\n        return undefined;\n      }\n      unobserve() {\n        return undefined;\n      }\n    }\n    global.IntersectionObserver = MockIntersectionObserver;\n  });\n\n  it('renders without crashing', () => {\n    const {getByText} = renderWithTheme(<CloudItem vis={mockVis} onClick={nop} />);\n    expect(getByText('Test Title')).toBeInTheDocument();\n  });\n\n  it('renders PrivacyBadge for private maps', () => {\n    const {getByText} = renderWithTheme(\n      <CloudItem vis={{...mockVis, privateMap: true}} onClick={nop} />\n    );\n    expect(getByText('Private')).toBeInTheDocument();\n  });\n\n  it('does not render PrivacyBadge for public maps', () => {\n    const {queryByText} = renderWithTheme(\n      <CloudItem vis={{...mockVis, privateMap: false}} onClick={nop} />\n    );\n    expect(queryByText('Private')).toBeNull();\n  });\n\n  it('displays correct thumbnail image', () => {\n    const {getByRole} = renderWithTheme(<CloudItem vis={mockVis} onClick={nop} />);\n    expect(getByRole('thumbnail-wrapper').style.backgroundImage).toContain('test-thumbnail.jpg');\n  });\n\n  it('displays MapIcon when no thumbnail is provided', () => {\n    const {getByRole} = renderWithTheme(\n      <CloudItem vis={{...mockVis, thumbnail: null}} onClick={nop} />\n    );\n    expect(getByRole('map-icon')).toBeInTheDocument();\n  });\n\n  it('displays title, description, and last modification date', () => {\n    const {getByText} = renderWithTheme(<CloudItem vis={mockVis} onClick={nop} />);\n    expect(getByText('Test Title')).toBeInTheDocument();\n    expect(getByText('Test Description')).toBeInTheDocument();\n    expect(\n      getByText(`Last modified ${moment.utc(mockVis.updatedAt).fromNow()}`)\n    ).toBeInTheDocument();\n  });\n\n  it('calls onClick when component is clicked', () => {\n    const onClickMock = jest.fn();\n    const {getByText} = renderWithTheme(<CloudItem vis={mockVis} onClick={onClickMock} />);\n    fireEvent.click(getByText('Test Title'));\n    expect(onClickMock).toHaveBeenCalled();\n  });\n\n  it('lazy-loads thumbnail when tile becomes visible', async () => {\n    const getMapThumbnail = jest.fn().mockResolvedValue('lazy-thumb.jpg');\n    const provider = {\n      hasLazyThumbnails: () => true,\n      getMapThumbnail\n    };\n    const vis = {...mockVis, thumbnail: undefined};\n    const {findByRole} = renderWithTheme(<CloudItem vis={vis} onClick={nop} provider={provider} />);\n\n    const thumb = await findByRole('thumbnail-wrapper');\n    await waitFor(() => expect(getMapThumbnail).toHaveBeenCalledWith(vis));\n    expect(thumb.style.backgroundImage).toContain('lazy-thumb.jpg');\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/modals/cloud-components/cloud-maps.js

@@ -0,0 +1,43 @@
+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 LoadingDialog from '../loading-dialog';
+import { FormattedMessage } from '@kepler.gl/localization';
+import { CloudItem } from './cloud-item';
+import { FlexContainer } from '../../common/flex-container';
+var StyledSpinner = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  text-align: center;\n  span {\n    margin: 0 auto;\n  }\n"])));
+var StyledFlexContainer = styled(FlexContainer)(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  justify-content: flex-start;\n  flex-wrap: wrap;\n"])));
+export var CloudMaps = function CloudMaps(_ref) {
+  var provider = _ref.provider,
+    onSelectMap = _ref.onSelectMap,
+    isLoading = _ref.isLoading,
+    maps = _ref.maps,
+    error = _ref.error;
+  if (error) {
+    return /*#__PURE__*/React.createElement("div", null, "Error while fetching maps: ", error.message);
+  }
+  if (isLoading) {
+    return /*#__PURE__*/React.createElement(StyledSpinner, null, /*#__PURE__*/React.createElement(LoadingDialog, {
+      size: 64
+    }));
+  }
+  return /*#__PURE__*/React.createElement(StyledFlexContainer, null, (maps !== null && maps !== void 0 ? maps : []).length ? maps.map(function (vis) {
+    return /*#__PURE__*/React.createElement(CloudItem, {
+      key: vis.id,
+      onClick: function onClick() {
+        return onSelectMap(provider, vis);
+      },
+      provider: provider,
+      vis: vis
+    });
+  }) : /*#__PURE__*/React.createElement("div", {
+    className: "visualization-list__message"
+  }, /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: 'modal.loadStorageMap.noSavedMaps'
+  })));
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/modals/cloud-components/cloud-maps.spec.js

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+// @ts-nocheck
+import React from 'react';
+import { fireEvent } from '@testing-library/react';
+import { renderWithTheme } from '../../../../../test/helpers/component-jest-utils';
+import { CloudMaps } from './cloud-maps';
+describe('CloudMaps Component', function () {
+  it('renderWithThemes without crashing', function () {
+    var _renderWithTheme = renderWithTheme(/*#__PURE__*/React.createElement(CloudMaps, {
+        isLoading: false,
+        maps: [],
+        error: null
+      })),
+      getByText = _renderWithTheme.getByText;
+    expect(getByText(/noSavedMaps/i)).toBeInTheDocument();
+  });
+  it('displays error message when there is an error', function () {
+    var errorMessage = 'Test Error';
+    var _renderWithTheme2 = renderWithTheme(/*#__PURE__*/React.createElement(CloudMaps, {
+        isLoading: false,
+        maps: [],
+        error: {
+          message: errorMessage
+        }
+      })),
+      getByText = _renderWithTheme2.getByText;
+    expect(getByText("Error while fetching maps: ".concat(errorMessage))).toBeInTheDocument();
+  });
+  it('displays loading spinner when isLoading is true', function () {
+    var _renderWithTheme3 = renderWithTheme(/*#__PURE__*/React.createElement(CloudMaps, {
+        isLoading: true,
+        maps: [],
+        error: null
+      })),
+      getByText = _renderWithTheme3.getByText;
+    expect(getByText('modal.loadingDialog.loading')).toBeInTheDocument(); // Ensure your spinner has 'data-testid="loading-spinner"'
+  });
+  it('renderWithThemes correct number of CloudItems based on maps prop', function () {
+    var mockMaps = [{
+      id: 1,
+      title: 'map'
+    }, {
+      id: 2,
+      title: 'map'
+    }, {
+      id: 3,
+      title: 'map'
+    }];
+    var _renderWithTheme4 = renderWithTheme(/*#__PURE__*/React.createElement(CloudMaps, {
+        isLoading: false,
+        maps: mockMaps,
+        error: null
+      })),
+      getAllByText = _renderWithTheme4.getAllByText;
+    expect(getAllByText('map')).toHaveLength(mockMaps.length); // Ensure your CloudItem has 'data-testid="cloud-item"'
+  });
+  it('displays message when there are no maps', function () {
+    var _renderWithTheme5 = renderWithTheme(/*#__PURE__*/React.createElement(CloudMaps, {
+        isLoading: false,
+        maps: [],
+        error: null
+      })),
+      getByText = _renderWithTheme5.getByText;
+    expect(getByText(/noSavedMaps/i)).toBeInTheDocument();
+  });
+  it('calls onSelectMap when a CloudItem is clicked', function () {
+    var mockMaps = [{
+      id: 1,
+      title: 'map'
+    }, {
+      id: 2,
+      title: 'map'
+    }, {
+      id: 3,
+      title: 'map'
+    }];
+    var onSelectMap = jest.fn();
+    var provider = 'testProvider';
+    var _renderWithTheme6 = renderWithTheme(/*#__PURE__*/React.createElement(CloudMaps, {
+        provider: provider,
+        onSelectMap: onSelectMap,
+        isLoading: false,
+        maps: mockMaps,
+        error: null
+      })),
+      getAllByText = _renderWithTheme6.getAllByText;
+    var firstItem = getAllByText('map')[0];
+    fireEvent.click(firstItem);
+    expect(onSelectMap).toHaveBeenCalledWith(provider, mockMaps[0]);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/modals/cloud-components/provider-select.js

@@ -0,0 +1,25 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import CloudTile from '../cloud-tile';
+import React from 'react';
+import styled from 'styled-components';
+import { dataTestIds } from '@kepler.gl/constants';
+var StyledProviderSection = styled.div.attrs({
+  className: 'provider-selection'
+})(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: flex;\n  gap: 8px;\n"])));
+export var ProviderSelect = function ProviderSelect(_ref) {
+  var _ref$cloudProviders = _ref.cloudProviders,
+    cloudProviders = _ref$cloudProviders === void 0 ? [] : _ref$cloudProviders;
+  return /*#__PURE__*/React.createElement("div", {
+    "data-testid": dataTestIds.providerSelect
+  }, cloudProviders.length ? /*#__PURE__*/React.createElement(StyledProviderSection, null, cloudProviders.map(function (provider) {
+    return /*#__PURE__*/React.createElement(CloudTile, {
+      key: provider.name,
+      provider: provider
+    });
+  })) : /*#__PURE__*/React.createElement("p", null, "No storage provider available"));
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/modals/cloud-tile.js

@@ -0,0 +1,209 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6;
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useEffect, useState } from 'react';
+import styled from 'styled-components';
+import { Logout, Login } from '../common/icons';
+import { CenterVerticalFlexbox, Button, CheckMark } from '../common/styled-components';
+import { useCloudListProvider } from '../hooks/use-cloud-list-provider';
+var StyledTileWrapper = styled.div.attrs({
+  className: 'provider-tile__wrapper'
+})(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  justify-content: flex-start;\n  border-radius: 2px;\n  border: 1px solid\n    ", ";\n  color: ", ";\n  cursor: pointer;\n  font-weight: 500;\n  width: 120px;\n  height: 168px;\n  background-color: #ffffff;\n  transition: ", ";\n  position: relative;\n  &:hover {\n    border: 1px solid ", ";\n    color: ", ";\n  }\n\n  .button {\n    margin-top: 20px;\n  }\n"])), function (props) {
+  return props.selected ? props.theme.primaryBtnBgd : props.theme.selectBorderColorLT;
+}, function (props) {
+  return props.selected ? props.theme.primaryBtnBgd : props.theme.selectBorderColorLT;
+}, function (props) {
+  return props.theme.transition;
+}, function (props) {
+  return props.theme.primaryBtnBgd;
+}, function (props) {
+  return props.theme.primaryBtnBgd;
+});
+var StyledBox = styled(CenterVerticalFlexbox)(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  margin-right: 12px;\n  position: relative;\n"])));
+var StyledCloudName = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  font-size: 12px;\n  margin-top: 12px;\n  margin-bottom: 4px;\n"])));
+var StyledUserName = styled.div(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  font-size: 11px;\n  margin-top: 8px;\n  text-align: center;\n  color: ", ";\n  overflow: hidden;\n  width: 100px;\n  text-overflow: ellipsis;\n"])), function (props) {
+  return props.theme.primaryBtnActBgd;
+});
+var LoginButton = function LoginButton(_ref) {
+  var onClick = _ref.onClick;
+  return /*#__PURE__*/React.createElement(Button, {
+    className: "login-button",
+    link: true,
+    small: true,
+    onClick: onClick
+  }, /*#__PURE__*/React.createElement(Login, null), "Login");
+};
+var LogoutButton = function LogoutButton(_ref2) {
+  var onClick = _ref2.onClick;
+  return /*#__PURE__*/React.createElement(Button, {
+    className: "logout-button",
+    link: true,
+    small: true,
+    onClick: onClick
+  }, /*#__PURE__*/React.createElement(Logout, null), "Logout");
+};
+var NewTag = styled.div(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  width: 37px;\n  height: 19px;\n  display: flex;\n  align-content: center;\n  justify-content: center;\n  border-radius: 8px;\n  padding: 4px 8px;\n  background-color: #EDE9F9;\n  color: #8863F8;\n  position: absolute;\n  left: 35%;\n  top: -8px\n  z-index: 500;\n  font-size: 11px;\n  line-height: 10px;\n"])));
+export var StyledWarning = styled.span(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n  color: ", ";\n  font-weight: ", ";\n"])), function (props) {
+  return props.theme.errorColor;
+}, function (props) {
+  return props.theme.selectFontWeightBold;
+});
+/**
+ * this component display a provider and allows users to select and set the current provider
+ * @param provider
+ * @param actionName
+ * @constructor
+ */
+var CloudTile = function CloudTile(_ref3) {
+  var provider = _ref3.provider,
+    actionName = _ref3.actionName;
+  var _useState = useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    user = _useState2[0],
+    setUser = _useState2[1];
+  var _useState3 = useState(null),
+    _useState4 = _slicedToArray(_useState3, 2),
+    error = _useState4[0],
+    setError = _useState4[1];
+  var _useState5 = useState(false),
+    _useState6 = _slicedToArray(_useState5, 2),
+    isLoading = _useState6[0],
+    setIsLoading = _useState6[1];
+  var _useCloudListProvider = useCloudListProvider(),
+    currentProvider = _useCloudListProvider.provider,
+    setProvider = _useCloudListProvider.setProvider;
+  var isSelected = provider === currentProvider;
+  useEffect(function () {
+    if (!provider) {
+      return;
+    }
+    var cancelled = false;
+    setError(null);
+    setIsLoading(true);
+    provider.getUser().then(function (nextUser) {
+      if (!cancelled) {
+        setUser(nextUser);
+      }
+    })["catch"](function (err) {
+      if (!cancelled) {
+        setUser(null);
+        setError(err);
+      }
+    })["finally"](function () {
+      if (!cancelled) {
+        setIsLoading(false);
+      }
+    });
+    return function () {
+      cancelled = true;
+    };
+  }, [provider]);
+  var onLogin = useCallback(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var nextUser;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          setError(null);
+          setIsLoading(true);
+          _context.prev = 2;
+          _context.next = 5;
+          return provider.login();
+        case 5:
+          nextUser = _context.sent;
+          setUser(nextUser);
+          setProvider(provider);
+          return _context.abrupt("return", nextUser);
+        case 11:
+          _context.prev = 11;
+          _context.t0 = _context["catch"](2);
+          // Swallow: also used as LoginButton onClick (must not reject)
+          setError(_context.t0);
+          return _context.abrupt("return", null);
+        case 15:
+          _context.prev = 15;
+          setIsLoading(false);
+          return _context.finish(15);
+        case 18:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[2, 11, 15, 18]]);
+  })), [provider, setProvider]);
+  var onSelect = useCallback(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var nextUser;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          if (!isLoading) {
+            _context2.next = 2;
+            break;
+          }
+          return _context2.abrupt("return");
+        case 2:
+          if (!user) {
+            _context2.next = 5;
+            break;
+          }
+          setProvider(provider);
+          return _context2.abrupt("return");
+        case 5:
+          _context2.next = 7;
+          return onLogin();
+        case 7:
+          nextUser = _context2.sent;
+          if (!nextUser) {
+            setProvider(null);
+          }
+          // onLogin already selected the provider on success
+        case 9:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })), [setProvider, provider, user, isLoading, onLogin]);
+  var onLogout = useCallback(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          setIsLoading(true);
+          setError(null);
+          _context3.prev = 2;
+          _context3.next = 5;
+          return provider.logout();
+        case 5:
+          _context3.next = 10;
+          break;
+        case 7:
+          _context3.prev = 7;
+          _context3.t0 = _context3["catch"](2);
+          setError(_context3.t0);
+        case 10:
+          setIsLoading(false);
+          setUser(null);
+          setProvider(null);
+        case 13:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[2, 7]]);
+  })), [provider, setProvider]);
+  var displayName = provider.displayName,
+    name = provider.name;
+  return /*#__PURE__*/React.createElement(StyledBox, null, provider.isNew ? /*#__PURE__*/React.createElement(NewTag, null, "New") : null, /*#__PURE__*/React.createElement("div", null), /*#__PURE__*/React.createElement(StyledTileWrapper, {
+    onClick: onSelect,
+    selected: isSelected
+  }, /*#__PURE__*/React.createElement(StyledCloudName, null, displayName || name), provider.icon ? /*#__PURE__*/React.createElement(provider.icon, {
+    height: "64px"
+  }) : null, isLoading ? /*#__PURE__*/React.createElement("div", null, "Loading ...") : /*#__PURE__*/React.createElement(React.Fragment, null, user ? /*#__PURE__*/React.createElement(StyledUserName, null, actionName || user.name) : null), isSelected ? /*#__PURE__*/React.createElement(CheckMark, null) : null), user || error ? /*#__PURE__*/React.createElement(LogoutButton, {
+    onClick: onLogout
+  }) : /*#__PURE__*/React.createElement(LoginButton, {
+    onClick: onLogin
+  }), error ? /*#__PURE__*/React.createElement(StyledWarning, null, error.message) : null);
+};
+export default CloudTile;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useState","styled","Logout","Login","CenterVerticalFlexbox","Button","CheckMark","useCloudListProvider","StyledTileWrapper","div","attrs","className","_templateObject","_taggedTemplateLiteral","props","selected","theme","primaryBtnBgd","selectBorderColorLT","transition","StyledBox","_templateObject2","StyledCloudName","_templateObject3","StyledUserName","_templateObject4","primaryBtnActBgd","LoginButton","_ref","onClick","createElement","link","small","LogoutButton","_ref2","NewTag","_templateObject5","StyledWarning","span","_templateObject6","errorColor","selectFontWeightBold","CloudTile","_ref3","provider","actionName","_useState","_useState2","_slicedToArray","user","setUser","_useState3","_useState4","error","setError","_useState5","_useState6","isLoading","setIsLoading","_useCloudListProvider","currentProvider","setProvider","isSelected","cancelled","getUser","then","nextUser","err","onLogin","_asyncToGenerator","_regeneratorRuntime","mark","_callee","wrap","_callee$","_context","prev","next","login","sent","abrupt","t0","finish","stop","onSelect","_callee2","_callee2$","_context2","onLogout","_callee3","_callee3$","_context3","logout","displayName","name","isNew","icon","height","Fragment","message"],"sources":["../../../src/modals/cloud-tile.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useEffect, useState} from 'react';\nimport styled, {IStyledComponent} from 'styled-components';\nimport {Logout, Login} from '../common/icons';\nimport {CenterVerticalFlexbox, Button, CheckMark} from '../common/styled-components';\nimport {Provider, CloudUser} from '@kepler.gl/cloud-providers';\nimport {useCloudListProvider} from '../hooks/use-cloud-list-provider';\nimport {BaseComponentProps} from '../types';\n\nexport type StyledTileWrapperProps = BaseComponentProps & {\n  selected?: boolean;\n};\n\nconst StyledTileWrapper: IStyledComponent<'web', StyledTileWrapperProps> = styled.div.attrs({\n  className: 'provider-tile__wrapper'\n})<StyledTileWrapperProps>`\n  display: flex;\n  flex-direction: column;\n  align-items: center;\n  justify-content: flex-start;\n  border-radius: 2px;\n  border: 1px solid\n    ${props => (props.selected ? props.theme.primaryBtnBgd : props.theme.selectBorderColorLT)};\n  color: ${props => (props.selected ? props.theme.primaryBtnBgd : props.theme.selectBorderColorLT)};\n  cursor: pointer;\n  font-weight: 500;\n  width: 120px;\n  height: 168px;\n  background-color: #ffffff;\n  transition: ${props => props.theme.transition};\n  position: relative;\n  &:hover {\n    border: 1px solid ${props => props.theme.primaryBtnBgd};\n    color: ${props => props.theme.primaryBtnBgd};\n  }\n\n  .button {\n    margin-top: 20px;\n  }\n`;\n\nconst StyledBox = styled(CenterVerticalFlexbox)`\n  margin-right: 12px;\n  position: relative;\n`;\n\nconst StyledCloudName = styled.div`\n  font-size: 12px;\n  margin-top: 12px;\n  margin-bottom: 4px;\n`;\n\nconst StyledUserName = styled.div`\n  font-size: 11px;\n  margin-top: 8px;\n  text-align: center;\n  color: ${props => props.theme.primaryBtnActBgd};\n  overflow: hidden;\n  width: 100px;\n  text-overflow: ellipsis;\n`;\n\ninterface OnClickProps {\n  onClick?: React.MouseEventHandler<HTMLButtonElement>;\n}\n\nconst LoginButton = ({onClick}: OnClickProps) => (\n  <Button className=\"login-button\" link small onClick={onClick}>\n    <Login />\n    Login\n  </Button>\n);\n\nconst LogoutButton = ({onClick}: OnClickProps) => (\n  <Button className=\"logout-button\" link small onClick={onClick}>\n    <Logout />\n    Logout\n  </Button>\n);\n\nconst NewTag = styled.div`\n  width: 37px;\n  height: 19px;\n  display: flex;\n  align-content: center;\n  justify-content: center;\n  border-radius: 8px;\n  padding: 4px 8px;\n  background-color: #EDE9F9;\n  color: #8863F8;\n  position: absolute;\n  left: 35%;\n  top: -8px\n  z-index: 500;\n  font-size: 11px;\n  line-height: 10px;\n`;\n\nexport const StyledWarning = styled.span`\n  color: ${props => props.theme.errorColor};\n  font-weight: ${props => props.theme.selectFontWeightBold};\n`;\n\ninterface CloudTileProps {\n  actionName?: string | null;\n  // cloud provider class\n  provider: Provider;\n}\n\n/**\n * this component display a provider and allows users to select and set the current provider\n * @param provider\n * @param actionName\n * @constructor\n */\nconst CloudTile: React.FC<CloudTileProps> = ({provider, actionName}) => {\n  const [user, setUser] = useState<CloudUser | null>(null);\n  const [error, setError] = useState<Error | null>(null);\n  const [isLoading, setIsLoading] = useState(false);\n  const {provider: currentProvider, setProvider} = useCloudListProvider();\n  const isSelected = provider === currentProvider;\n\n  useEffect(() => {\n    if (!provider) {\n      return;\n    }\n    let cancelled = false;\n    setError(null);\n    setIsLoading(true);\n    provider\n      .getUser()\n      .then(nextUser => {\n        if (!cancelled) {\n          setUser(nextUser);\n        }\n      })\n      .catch(err => {\n        if (!cancelled) {\n          setUser(null);\n          setError(err as Error);\n        }\n      })\n      .finally(() => {\n        if (!cancelled) {\n          setIsLoading(false);\n        }\n      });\n    return () => {\n      cancelled = true;\n    };\n  }, [provider]);\n\n  const onLogin = useCallback(async () => {\n    setError(null);\n    setIsLoading(true);\n    try {\n      const nextUser = await provider.login();\n      setUser(nextUser);\n      setProvider(provider);\n      return nextUser;\n    } catch (error) {\n      // Swallow: also used as LoginButton onClick (must not reject)\n      setError(error as Error);\n      return null;\n    } finally {\n      setIsLoading(false);\n    }\n  }, [provider, setProvider]);\n\n  const onSelect = useCallback(async () => {\n    if (isLoading) {\n      return;\n    }\n    if (user) {\n      setProvider(provider);\n      return;\n    }\n    const nextUser = await onLogin();\n    if (!nextUser) {\n      setProvider(null);\n    }\n    // onLogin already selected the provider on success\n  }, [setProvider, provider, user, isLoading, onLogin]);\n\n  const onLogout = useCallback(async () => {\n    setIsLoading(true);\n    setError(null);\n    try {\n      await provider.logout();\n    } catch (error) {\n      setError(error as Error);\n    }\n    setIsLoading(false);\n    setUser(null);\n    setProvider(null);\n  }, [provider, setProvider]);\n\n  const {displayName, name} = provider;\n\n  return (\n    <StyledBox>\n      {provider.isNew ? <NewTag>New</NewTag> : null}\n      <div />\n      <StyledTileWrapper onClick={onSelect} selected={isSelected}>\n        <StyledCloudName>{displayName || name}</StyledCloudName>\n        {provider.icon ? <provider.icon height=\"64px\" /> : null}\n        {isLoading ? (\n          <div>Loading ...</div>\n        ) : (\n          <>{user ? <StyledUserName>{actionName || user.name}</StyledUserName> : null}</>\n        )}\n        {isSelected ? <CheckMark /> : null}\n      </StyledTileWrapper>\n      {user || error ? <LogoutButton onClick={onLogout} /> : <LoginButton onClick={onLogin} />}\n      {error ? <StyledWarning>{error.message}</StyledWarning> : null}\n    </StyledBox>\n  );\n};\n\nexport default CloudTile;\n"],"mappings":"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","ignoreList":[]}