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

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

@@ -0,0 +1,161 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+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, { useEffect, useState, useMemo } from 'react';
+import styled, { ThemeProvider } from 'styled-components';
+import { CopyToClipboard } from 'react-copy-to-clipboard';
+import { themeLT } from '@kepler.gl/styles';
+import ImageModalContainer from './image-modal-container';
+import { StyledModalContent, StyledExportSection, InputLight, Button } from '../common/styled-components';
+import StatusPanel from './status-panel';
+import { FormattedMessage } from '@kepler.gl/localization';
+import { useCloudListProvider } from '../hooks/use-cloud-list-provider';
+import { ProviderSelect } from './cloud-components/provider-select';
+import { CloudStorageDisclaimer } from './cloud-components/cloud-storage-disclaimer';
+import { dataTestIds } from '@kepler.gl/constants';
+export var StyledInputLabel = styled.label(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  font-size: 12px;\n  color: ", ";\n  letter-spacing: 0.2px;\n"])), function (props) {
+  return props.theme.textColorLT;
+});
+export var StyleSharingUrl = styled.div.attrs({
+  className: 'sharing-url'
+})(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  width: 100%;\n  display: flex;\n  margin-bottom: 14px;\n  flex-direction: column;\n\n  input {\n    border-right: 0;\n  }\n\n  .button {\n    border-top-left-radius: 0;\n    border-bottom-left-radius: 0;\n  }\n"])));
+export var SharingUrl = function SharingUrl(_ref) {
+  var url = _ref.url,
+    _ref$message = _ref.message,
+    message = _ref$message === void 0 ? '' : _ref$message;
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    copied = _useState2[0],
+    setCopy = _useState2[1];
+  return /*#__PURE__*/React.createElement(StyleSharingUrl, null, /*#__PURE__*/React.createElement(StyledInputLabel, null, message), /*#__PURE__*/React.createElement("div", {
+    style: {
+      display: 'flex'
+    }
+  }, /*#__PURE__*/React.createElement(InputLight, {
+    type: "text",
+    value: url,
+    readOnly: true
+  }), /*#__PURE__*/React.createElement(CopyToClipboard, {
+    text: url,
+    onCopy: function onCopy() {
+      return setCopy(true);
+    }
+  }, /*#__PURE__*/React.createElement(Button, {
+    width: "80px"
+  }, copied ? 'Copied!' : 'Copy'))));
+};
+var nop = function nop() {
+  return;
+};
+var StyledShareMapModal = styled(StyledModalContent)(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  padding: 24px 72px 40px 72px;\n  margin: 0 -72px -40px -72px;\n  display: flex;\n  flex-direction: column;\n  min-height: 500px;\n"])));
+var StyledInnerDiv = styled.div(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  flex: 1;\n"])));
+var UNDERLINE_TEXT_DECORATION_STYLE = {
+  textDecoration: 'underline'
+};
+var ShareMapHeader = function ShareMapHeader(_ref2) {
+  var cloudProviders = _ref2.cloudProviders;
+  var shareableCloudProviders = useMemo(function () {
+    return cloudProviders.filter(function (cp) {
+      return cp.hasSharingUrl();
+    });
+  }, [cloudProviders]);
+  return /*#__PURE__*/React.createElement(StyledExportSection, null, /*#__PURE__*/React.createElement("div", {
+    className: "description"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "title"
+  }, /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: 'modal.shareMap.title'
+  }))), /*#__PURE__*/React.createElement(ProviderSelect, {
+    cloudProviders: shareableCloudProviders
+  }));
+};
+export default function ShareMapUrlModalFactory() {
+  var ShareMapUrlModal = function ShareMapUrlModal(_ref3) {
+    var _ref3$isProviderLoadi = _ref3.isProviderLoading,
+      isProviderLoading = _ref3$isProviderLoadi === void 0 ? false : _ref3$isProviderLoadi,
+      _ref3$onExport = _ref3.onExport,
+      onExport = _ref3$onExport === void 0 ? nop : _ref3$onExport,
+      _ref3$providerError = _ref3.providerError,
+      providerError = _ref3$providerError === void 0 ? null : _ref3$providerError,
+      _ref3$successInfo = _ref3.successInfo,
+      successInfo = _ref3$successInfo === void 0 ? {} : _ref3$successInfo,
+      _ref3$onUpdateImageSe = _ref3.onUpdateImageSetting,
+      onUpdateImageSetting = _ref3$onUpdateImageSe === void 0 ? nop : _ref3$onUpdateImageSe,
+      cleanupExportImage = _ref3.cleanupExportImage;
+    var _useCloudListProvider = useCloudListProvider(),
+      provider = _useCloudListProvider.provider,
+      cloudProviders = _useCloudListProvider.cloudProviders;
+    var shareUrl = successInfo.shareUrl,
+      folderLink = successInfo.folderLink;
+    useEffect(function () {
+      if (provider) {
+        onExport(provider);
+      }
+    }, [onExport, provider]);
+    return /*#__PURE__*/React.createElement(ThemeProvider, {
+      theme: themeLT
+    }, /*#__PURE__*/React.createElement(ImageModalContainer, {
+      provider: provider,
+      onUpdateImageSetting: onUpdateImageSetting,
+      cleanupExportImage: cleanupExportImage
+    }, /*#__PURE__*/React.createElement(StyledShareMapModal, {
+      className: "export-cloud-modal"
+    }, /*#__PURE__*/React.createElement(ShareMapHeader, {
+      cloudProviders: cloudProviders
+    }), provider !== null && provider !== void 0 && provider.hasSharingUrl() ? /*#__PURE__*/React.createElement(StyledInnerDiv, {
+      "data-testid": dataTestIds.providerShareMap
+    }, /*#__PURE__*/React.createElement(StyledExportSection, null, /*#__PURE__*/React.createElement("div", {
+      className: "description"
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "title"
+    }, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: 'modal.shareMap.shareUriTitle'
+    })), /*#__PURE__*/React.createElement("div", {
+      className: "subtitle"
+    }, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: 'modal.shareMap.shareUriSubtitle'
+    }))), /*#__PURE__*/React.createElement("div", {
+      className: "selection"
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "title warning"
+    }, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: 'modal.shareMap.shareDisclaimer'
+    })))), /*#__PURE__*/React.createElement(StyledExportSection, {
+      disabled: isProviderLoading
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "description"
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "title"
+    }, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: 'modal.shareMap.cloudTitle'
+    })), /*#__PURE__*/React.createElement("div", {
+      className: "subtitle"
+    }, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: 'modal.shareMap.cloudSubtitle'
+    })))), isProviderLoading || providerError ? /*#__PURE__*/React.createElement(StatusPanel, {
+      isLoading: isProviderLoading,
+      error: providerError,
+      providerIcon: provider.icon
+    }) : null, shareUrl && /*#__PURE__*/React.createElement(StyledExportSection, null, /*#__PURE__*/React.createElement("div", {
+      className: "description"
+    }, /*#__PURE__*/React.createElement("div", {
+      className: "title"
+    }, "Share Url")), /*#__PURE__*/React.createElement("div", {
+      className: "selection"
+    }, /*#__PURE__*/React.createElement(SharingUrl, {
+      key: 0,
+      url: shareUrl
+    }), provider && folderLink && /*#__PURE__*/React.createElement("a", {
+      key: 1,
+      href: folderLink,
+      target: "_blank",
+      rel: "noopener noreferrer",
+      style: UNDERLINE_TEXT_DECORATION_STYLE
+    }, provider.name)))) : null, /*#__PURE__*/React.createElement(CloudStorageDisclaimer, null))));
+  };
+  return ShareMapUrlModal;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useState","useMemo","styled","ThemeProvider","CopyToClipboard","themeLT","ImageModalContainer","StyledModalContent","StyledExportSection","InputLight","Button","StatusPanel","FormattedMessage","useCloudListProvider","ProviderSelect","CloudStorageDisclaimer","dataTestIds","StyledInputLabel","label","_templateObject","_taggedTemplateLiteral","props","theme","textColorLT","StyleSharingUrl","div","attrs","className","_templateObject2","SharingUrl","_ref","url","_ref$message","message","_useState","_useState2","_slicedToArray","copied","setCopy","createElement","style","display","type","value","readOnly","text","onCopy","width","nop","StyledShareMapModal","_templateObject3","StyledInnerDiv","_templateObject4","UNDERLINE_TEXT_DECORATION_STYLE","textDecoration","ShareMapHeader","_ref2","cloudProviders","shareableCloudProviders","filter","cp","hasSharingUrl","id","ShareMapUrlModalFactory","ShareMapUrlModal","_ref3","_ref3$isProviderLoadi","isProviderLoading","_ref3$onExport","onExport","_ref3$providerError","providerError","_ref3$successInfo","successInfo","_ref3$onUpdateImageSe","onUpdateImageSetting","cleanupExportImage","_useCloudListProvider","provider","shareUrl","folderLink","providerShareMap","disabled","isLoading","error","providerIcon","icon","key","href","target","rel","name"],"sources":["../../../src/modals/share-map-modal.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useEffect, useState, useMemo} from 'react';\nimport styled, {ThemeProvider} from 'styled-components';\nimport {CopyToClipboard} from 'react-copy-to-clipboard';\nimport {themeLT} from '@kepler.gl/styles';\nimport ImageModalContainer, {ImageModalContainerProps} from './image-modal-container';\n\nimport {\n  StyledModalContent,\n  StyledExportSection,\n  InputLight,\n  Button\n} from '../common/styled-components';\nimport StatusPanel from './status-panel';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {useCloudListProvider} from '../hooks/use-cloud-list-provider';\nimport {ProviderSelect} from './cloud-components/provider-select';\nimport {CloudStorageDisclaimer} from './cloud-components/cloud-storage-disclaimer';\nimport {Provider} from '@kepler.gl/cloud-providers';\nimport {cleanupExportImage as cleanupExportImageAction} from '@kepler.gl/actions';\nimport {dataTestIds} from '@kepler.gl/constants';\n\nexport const StyledInputLabel = styled.label`\n  font-size: 12px;\n  color: ${props => props.theme.textColorLT};\n  letter-spacing: 0.2px;\n`;\n\nexport const StyleSharingUrl = styled.div.attrs({\n  className: 'sharing-url'\n})`\n  width: 100%;\n  display: flex;\n  margin-bottom: 14px;\n  flex-direction: column;\n\n  input {\n    border-right: 0;\n  }\n\n  .button {\n    border-top-left-radius: 0;\n    border-bottom-left-radius: 0;\n  }\n`;\n\ninterface SharingUrlProps {\n  url: string;\n  message?: string;\n}\n\nexport const SharingUrl: React.FC<SharingUrlProps> = ({url, message = ''}) => {\n  const [copied, setCopy] = useState(false);\n  return (\n    <StyleSharingUrl>\n      <StyledInputLabel>{message}</StyledInputLabel>\n      <div style={{display: 'flex'}}>\n        <InputLight type=\"text\" value={url} readOnly />\n        <CopyToClipboard text={url} onCopy={() => setCopy(true)}>\n          <Button width=\"80px\">{copied ? 'Copied!' : 'Copy'}</Button>\n        </CopyToClipboard>\n      </div>\n    </StyleSharingUrl>\n  );\n};\nconst nop = () => {\n  return;\n};\n\nconst StyledShareMapModal = styled(StyledModalContent)`\n  padding: 24px 72px 40px 72px;\n  margin: 0 -72px -40px -72px;\n  display: flex;\n  flex-direction: column;\n  min-height: 500px;\n`;\n\nconst StyledInnerDiv = styled.div`\n  flex: 1;\n`;\n\nconst UNDERLINE_TEXT_DECORATION_STYLE = {textDecoration: 'underline'};\n\nconst ShareMapHeader = ({cloudProviders}) => {\n  const shareableCloudProviders = useMemo(\n    () => cloudProviders.filter(cp => cp.hasSharingUrl()),\n    [cloudProviders]\n  );\n\n  return (\n    <StyledExportSection>\n      <div className=\"description\">\n        <div className=\"title\">\n          <FormattedMessage id={'modal.shareMap.title'} />\n        </div>\n      </div>\n      <ProviderSelect cloudProviders={shareableCloudProviders} />\n    </StyledExportSection>\n  );\n};\n\ninterface ShareMapUrlModalFactoryProps {\n  isProviderLoading?: boolean;\n  onExport?: (provider: Provider) => void;\n  providerError?: string;\n  successInfo?: {shareUrl?: string; folderLink?: string};\n  onUpdateImageSetting: ImageModalContainerProps['onUpdateImageSetting'];\n  cleanupExportImage: typeof cleanupExportImageAction;\n}\n\nexport default function ShareMapUrlModalFactory() {\n  const ShareMapUrlModal: React.FC<ShareMapUrlModalFactoryProps> = ({\n    isProviderLoading = false,\n    onExport = nop,\n    providerError = null,\n    successInfo = {},\n    onUpdateImageSetting = nop,\n    cleanupExportImage\n  }) => {\n    const {provider, cloudProviders} = useCloudListProvider();\n    const {shareUrl, folderLink} = successInfo;\n\n    useEffect(() => {\n      if (provider) {\n        onExport(provider);\n      }\n    }, [onExport, provider]);\n\n    return (\n      <ThemeProvider theme={themeLT}>\n        <ImageModalContainer\n          provider={provider}\n          onUpdateImageSetting={onUpdateImageSetting}\n          cleanupExportImage={cleanupExportImage}\n        >\n          <StyledShareMapModal className=\"export-cloud-modal\">\n            <ShareMapHeader cloudProviders={cloudProviders} />\n            {provider?.hasSharingUrl() ? (\n              <StyledInnerDiv data-testid={dataTestIds.providerShareMap}>\n                <StyledExportSection>\n                  <div className=\"description\">\n                    <div className=\"title\">\n                      <FormattedMessage id={'modal.shareMap.shareUriTitle'} />\n                    </div>\n                    <div className=\"subtitle\">\n                      <FormattedMessage id={'modal.shareMap.shareUriSubtitle'} />\n                    </div>\n                  </div>\n                  <div className=\"selection\">\n                    <div className=\"title warning\">\n                      <FormattedMessage id={'modal.shareMap.shareDisclaimer'} />\n                    </div>\n                  </div>\n                </StyledExportSection>\n                <StyledExportSection disabled={isProviderLoading}>\n                  <div className=\"description\">\n                    <div className=\"title\">\n                      <FormattedMessage id={'modal.shareMap.cloudTitle'} />\n                    </div>\n                    <div className=\"subtitle\">\n                      <FormattedMessage id={'modal.shareMap.cloudSubtitle'} />\n                    </div>\n                  </div>\n                </StyledExportSection>\n                {isProviderLoading || providerError ? (\n                  <StatusPanel\n                    isLoading={isProviderLoading}\n                    error={providerError}\n                    providerIcon={provider.icon}\n                  />\n                ) : null}\n                {shareUrl && (\n                  <StyledExportSection>\n                    <div className=\"description\">\n                      <div className=\"title\">Share Url</div>\n                    </div>\n                    <div className=\"selection\">\n                      <SharingUrl key={0} url={shareUrl} />\n                      {provider && folderLink && (\n                        <a\n                          key={1}\n                          href={folderLink}\n                          target=\"_blank\"\n                          rel=\"noopener noreferrer\"\n                          style={UNDERLINE_TEXT_DECORATION_STYLE}\n                        >\n                          {provider.name}\n                        </a>\n                      )}\n                    </div>\n                  </StyledExportSection>\n                )}\n              </StyledInnerDiv>\n            ) : null}\n            <CloudStorageDisclaimer />\n          </StyledShareMapModal>\n        </ImageModalContainer>\n      </ThemeProvider>\n    );\n  };\n\n  return ShareMapUrlModal;\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/modals/share-map-modal.spec.js

@@ -0,0 +1,172 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+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 React from 'react';
+import { useCloudListProvider } from '../hooks/use-cloud-list-provider';
+import { renderWithTheme } from 'test/helpers/component-jest-utils';
+import ShareMapUrlModalFactory from './share-map-modal';
+import { dataTestIds } from '@kepler.gl/constants';
+import { act } from '@testing-library/react';
+import { ThemeProvider } from 'styled-components';
+import { IntlProvider } from 'react-intl';
+import { theme } from '@kepler.gl/styles';
+import { messages } from '@kepler.gl/localization';
+jest.mock('../hooks/use-cloud-list-provider', function () {
+  return {
+    useCloudListProvider: jest.fn().mockImplementation(function () {
+      return {
+        provider: null,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    })
+  };
+});
+var ShareMapUrlModal = ShareMapUrlModalFactory();
+var DEFAULT_PROPS = {
+  isProviderLoading: false,
+  onExport: jest.fn(),
+  providerError: null,
+  successInfo: undefined,
+  onUpdateImageSetting: jest.fn(),
+  cleanupExportImage: jest.fn()
+};
+describe('ShareMapModal', function () {
+  afterEach(function () {
+    jest.clearAllMocks();
+  });
+  test('renders only list of providers', function () {
+    var _renderWithTheme = renderWithTheme(/*#__PURE__*/React.createElement(ShareMapUrlModal, DEFAULT_PROPS)),
+      getByText = _renderWithTheme.getByText,
+      queryByTestId = _renderWithTheme.queryByTestId;
+    expect(getByText('modal.shareMap.title')).toBeInTheDocument();
+    expect(queryByTestId(dataTestIds.providerShareMap)).toBeNull();
+  });
+  test('renders list of provider and sharing section', function () {
+    var mapProvider = {
+      name: 'test provider',
+      icon: jest.fn(),
+      getManagementUrl: jest.fn().mockImplementation(function () {
+        return 'provider.url';
+      }),
+      listMaps: jest.fn().mockResolvedValue([]),
+      hasSharingUrl: jest.fn().mockImplementation(function () {
+        return true;
+      })
+    };
+    useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+    var _renderWithTheme2 = renderWithTheme(/*#__PURE__*/React.createElement(ShareMapUrlModal, DEFAULT_PROPS)),
+      getByText = _renderWithTheme2.getByText,
+      getByTestId = _renderWithTheme2.getByTestId;
+    expect(getByText('modal.shareMap.title')).toBeInTheDocument();
+    expect(getByTestId(dataTestIds.providerShareMap)).toBeInTheDocument();
+  });
+  test('renders loading when isLoading is set to true', function () {
+    var mapProvider = {
+      name: 'test provider',
+      icon: jest.fn(),
+      getManagementUrl: jest.fn().mockImplementation(function () {
+        return 'provider.url';
+      }),
+      listMaps: jest.fn().mockResolvedValue([]),
+      hasSharingUrl: jest.fn().mockImplementation(function () {
+        return true;
+      })
+    };
+    useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+    var providerLoadingProps = _objectSpread(_objectSpread({}, DEFAULT_PROPS), {}, {
+      isProviderLoading: true
+    });
+    var _renderWithTheme3 = renderWithTheme(/*#__PURE__*/React.createElement(ShareMapUrlModal, providerLoadingProps)),
+      getByText = _renderWithTheme3.getByText;
+    expect(getByText('modal.statusPanel.mapUploading')).toBeInTheDocument();
+  });
+  test('calls onExport when provider is set correctly', function () {
+    var mapProvider = {
+      name: 'test provider',
+      icon: jest.fn(),
+      getManagementUrl: jest.fn().mockImplementation(function () {
+        return 'provider.url';
+      }),
+      listMaps: jest.fn().mockResolvedValue([]),
+      hasSharingUrl: jest.fn().mockImplementation(function () {
+        return true;
+      })
+    };
+    useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+    renderWithTheme(/*#__PURE__*/React.createElement(ShareMapUrlModal, DEFAULT_PROPS));
+    expect(DEFAULT_PROPS.onExport).toHaveBeenCalled();
+  });
+  test('calls onExport after provider was updated', function () {
+    var _renderWithTheme4 = renderWithTheme(/*#__PURE__*/React.createElement(ShareMapUrlModal, DEFAULT_PROPS)),
+      rerender = _renderWithTheme4.rerender;
+    var mapProvider = {
+      name: 'test provider',
+      icon: jest.fn(),
+      getManagementUrl: jest.fn().mockImplementation(function () {
+        return 'provider.url';
+      }),
+      listMaps: jest.fn().mockResolvedValue([]),
+      hasSharingUrl: jest.fn().mockImplementation(function () {
+        return true;
+      })
+    };
+    useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+    act(function () {
+      rerender(/*#__PURE__*/React.createElement(ThemeProvider, {
+        theme: theme
+      }, /*#__PURE__*/React.createElement(IntlProvider, {
+        locale: "en",
+        messages: messages
+      }, /*#__PURE__*/React.createElement(ShareMapUrlModal, DEFAULT_PROPS))));
+    });
+    expect(DEFAULT_PROPS.onExport).toHaveBeenCalled();
+  });
+  it('displays share URL when provided', function () {
+    var shareUrl = 'http://example.com';
+    var _renderWithTheme5 = renderWithTheme(/*#__PURE__*/React.createElement(ShareMapUrlModal, _extends({}, DEFAULT_PROPS, {
+        successInfo: {
+          shareUrl: shareUrl
+        }
+      }))),
+      getByText = _renderWithTheme5.getByText;
+    expect(getByText('Share Url')).toBeInTheDocument();
+  });
+  it('renders errors', function () {
+    var _renderWithTheme6 = renderWithTheme(/*#__PURE__*/React.createElement(ShareMapUrlModal, _extends({}, DEFAULT_PROPS, {
+        providerError: new Error('timeout')
+      }))),
+      getByText = _renderWithTheme6.getByText;
+    expect(getByText('modal.statusPanel.error')).toBeInTheDocument();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCloudListProvider","renderWithTheme","ShareMapUrlModalFactory","dataTestIds","act","ThemeProvider","IntlProvider","theme","messages","jest","mock","fn","mockImplementation","provider","setProvider","cloudProviders","ShareMapUrlModal","DEFAULT_PROPS","isProviderLoading","onExport","providerError","successInfo","undefined","onUpdateImageSetting","cleanupExportImage","describe","afterEach","clearAllMocks","test","_renderWithTheme","createElement","getByText","queryByTestId","expect","toBeInTheDocument","providerShareMap","toBeNull","mapProvider","name","icon","getManagementUrl","listMaps","mockResolvedValue","hasSharingUrl","_renderWithTheme2","getByTestId","providerLoadingProps","_objectSpread","_renderWithTheme3","toHaveBeenCalled","_renderWithTheme4","rerender","locale","it","shareUrl","_renderWithTheme5","_extends","_renderWithTheme6","Error"],"sources":["../../../src/modals/share-map-modal.spec.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n// @ts-nocheck\nimport React from 'react';\nimport {useCloudListProvider} from '../hooks/use-cloud-list-provider';\nimport {renderWithTheme} from 'test/helpers/component-jest-utils';\nimport ShareMapUrlModalFactory from './share-map-modal';\nimport {dataTestIds} from '@kepler.gl/constants';\nimport {act} from '@testing-library/react';\nimport {ThemeProvider} from 'styled-components';\nimport {IntlProvider} from 'react-intl';\nimport {theme} from '@kepler.gl/styles';\nimport {messages} from '@kepler.gl/localization';\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\nconst ShareMapUrlModal = ShareMapUrlModalFactory();\n\nconst DEFAULT_PROPS = {\n  isProviderLoading: false,\n  onExport: jest.fn(),\n  providerError: null,\n  successInfo: undefined,\n  onUpdateImageSetting: jest.fn(),\n  cleanupExportImage: jest.fn()\n};\n\ndescribe('ShareMapModal', () => {\n  afterEach(() => {\n    jest.clearAllMocks();\n  });\n\n  test('renders only list of providers', () => {\n    const {getByText, queryByTestId} = renderWithTheme(<ShareMapUrlModal {...DEFAULT_PROPS} />);\n    expect(getByText('modal.shareMap.title')).toBeInTheDocument();\n    expect(queryByTestId(dataTestIds.providerShareMap)).toBeNull();\n  });\n\n  test('renders list of provider and sharing section', () => {\n    const mapProvider = {\n      name: 'test provider',\n      icon: jest.fn(),\n      getManagementUrl: jest.fn().mockImplementation(() => 'provider.url'),\n      listMaps: jest.fn().mockResolvedValue([]),\n      hasSharingUrl: jest.fn().mockImplementation(() => true)\n    };\n    useCloudListProvider.mockImplementation(() => ({\n      provider: mapProvider,\n      setProvider: jest.fn(),\n      cloudProviders: []\n    }));\n\n    const {getByText, getByTestId} = renderWithTheme(<ShareMapUrlModal {...DEFAULT_PROPS} />);\n    expect(getByText('modal.shareMap.title')).toBeInTheDocument();\n    expect(getByTestId(dataTestIds.providerShareMap)).toBeInTheDocument();\n  });\n\n  test('renders loading when isLoading is set to true', () => {\n    const mapProvider = {\n      name: 'test provider',\n      icon: jest.fn(),\n      getManagementUrl: jest.fn().mockImplementation(() => 'provider.url'),\n      listMaps: jest.fn().mockResolvedValue([]),\n      hasSharingUrl: jest.fn().mockImplementation(() => true)\n    };\n    useCloudListProvider.mockImplementation(() => ({\n      provider: mapProvider,\n      setProvider: jest.fn(),\n      cloudProviders: []\n    }));\n\n    const providerLoadingProps = {\n      ...DEFAULT_PROPS,\n      isProviderLoading: true\n    };\n\n    const {getByText} = renderWithTheme(<ShareMapUrlModal {...providerLoadingProps} />);\n    expect(getByText('modal.statusPanel.mapUploading')).toBeInTheDocument();\n  });\n\n  test('calls onExport when provider is set correctly', () => {\n    const mapProvider = {\n      name: 'test provider',\n      icon: jest.fn(),\n      getManagementUrl: jest.fn().mockImplementation(() => 'provider.url'),\n      listMaps: jest.fn().mockResolvedValue([]),\n      hasSharingUrl: jest.fn().mockImplementation(() => true)\n    };\n    useCloudListProvider.mockImplementation(() => ({\n      provider: mapProvider,\n      setProvider: jest.fn(),\n      cloudProviders: []\n    }));\n\n    renderWithTheme(<ShareMapUrlModal {...DEFAULT_PROPS} />);\n\n    expect(DEFAULT_PROPS.onExport).toHaveBeenCalled();\n  });\n\n  test('calls onExport after provider was updated', () => {\n    const {rerender} = renderWithTheme(<ShareMapUrlModal {...DEFAULT_PROPS} />);\n\n    const mapProvider = {\n      name: 'test provider',\n      icon: jest.fn(),\n      getManagementUrl: jest.fn().mockImplementation(() => 'provider.url'),\n      listMaps: jest.fn().mockResolvedValue([]),\n      hasSharingUrl: jest.fn().mockImplementation(() => true)\n    };\n    useCloudListProvider.mockImplementation(() => ({\n      provider: mapProvider,\n      setProvider: jest.fn(),\n      cloudProviders: []\n    }));\n\n    act(() => {\n      rerender(\n        <ThemeProvider theme={theme}>\n          <IntlProvider locale=\"en\" messages={messages}>\n            <ShareMapUrlModal {...DEFAULT_PROPS} />\n          </IntlProvider>\n        </ThemeProvider>\n      );\n    });\n\n    expect(DEFAULT_PROPS.onExport).toHaveBeenCalled();\n  });\n\n  it('displays share URL when provided', () => {\n    const shareUrl = 'http://example.com';\n    const {getByText} = renderWithTheme(\n      <ShareMapUrlModal {...DEFAULT_PROPS} successInfo={{shareUrl}} />\n    );\n    expect(getByText('Share Url')).toBeInTheDocument();\n  });\n\n  it('renders errors', () => {\n    const {getByText} = renderWithTheme(\n      <ShareMapUrlModal {...DEFAULT_PROPS} providerError={new Error('timeout')} />\n    );\n    expect(getByText('modal.statusPanel.error')).toBeInTheDocument();\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/modals/status-panel.js

@@ -0,0 +1,60 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import styled from 'styled-components';
+import { MapIcon } from '../common/icons';
+import { StyledExportSection } from '../common/styled-components';
+import ErrorDisplay from './error-display';
+import { FormattedMessage } from '@kepler.gl/localization';
+var StyledUploader = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: flex;\n  align-items: center;\n  justify-content: flex-start;\n"])));
+var StyledMapIcon = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  color: ", ";\n  margin-right: 16px;\n  margin-top: 4px;\n"])), function (props) {
+  return props.theme.textColorLT;
+});
+var StyledSvg = styled.svg(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  margin-right: 16px;\n\n  line {\n    stroke: ", ";\n    stroke-width: 4;\n    stroke-linecap: square;\n    stroke-dasharray: 5 12;\n    animation: dash-animation 25s infinite linear;\n  }\n  circle {\n    fill: ", ";\n  }\n\n  @keyframes dash-animation {\n    to {\n      stroke-dashoffset: -1000;\n    }\n  }\n"])), function (props) {
+  return props.theme.selectBorderColorLT;
+}, function (props) {
+  return props.theme.selectBorderColorLT;
+});
+var Line = function Line() {
+  return /*#__PURE__*/React.createElement(StyledSvg, {
+    height: "5px",
+    width: "150px"
+  }, /*#__PURE__*/React.createElement("line", {
+    x1: "0",
+    y1: "4",
+    x2: "150",
+    y2: "4"
+  }));
+};
+export var UploadAnimation = function UploadAnimation(props) {
+  return /*#__PURE__*/React.createElement(StyledUploader, null, /*#__PURE__*/React.createElement(StyledMapIcon, null, /*#__PURE__*/React.createElement(MapIcon, {
+    height: "48px"
+  })), /*#__PURE__*/React.createElement(Line, null), props.icon && /*#__PURE__*/React.createElement(props.icon, {
+    height: "64px"
+  }));
+};
+var StatusPanel = function StatusPanel(_ref) {
+  var error = _ref.error,
+    isLoading = _ref.isLoading,
+    providerIcon = _ref.providerIcon;
+  return /*#__PURE__*/React.createElement(StyledExportSection, null, /*#__PURE__*/React.createElement("div", {
+    className: "description"
+  }, /*#__PURE__*/React.createElement("div", {
+    className: "title"
+  }, isLoading ? /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: 'modal.statusPanel.mapUploading'
+  }) : error ? /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: 'modal.statusPanel.error'
+  }) : null)), /*#__PURE__*/React.createElement("div", {
+    className: "selection"
+  }, isLoading && /*#__PURE__*/React.createElement(UploadAnimation, {
+    icon: providerIcon
+  }), error && /*#__PURE__*/React.createElement(ErrorDisplay, {
+    error: error
+  })));
+};
+export default StatusPanel;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,119 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { easeInOut } from 'popmotion';
+import { drawStarsBackground } from '@kepler.gl/deckgl-layers';
+var linear = function linear(p) {
+  return p;
+};
+var EASING_MAP = {
+  linear: linear,
+  'ease-in-out': easeInOut
+};
+
+/**
+ * Compute the swipe percentage at a given time.
+ */
+export function getSwipePercentageAtTime(timeMs, durationMs, startPct, endPct) {
+  var easing = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'ease-in-out';
+  var progress = Math.max(0, Math.min(1, timeMs / durationMs));
+  var easedProgress = EASING_MAP[easing](progress);
+  return startPct + (endPct - startPct) * easedProgress;
+}
+var HANDLE_RADIUS = 14;
+var ARROW_SIZE = 6;
+
+/**
+ * Draw a swipe divider (line + circular handle with arrows) onto a 2D canvas context.
+ */
+function drawSwipeDivider(ctx, splitX, height) {
+  ctx.save();
+
+  // Divider line
+  ctx.strokeStyle = '#FFFFFF';
+  ctx.lineWidth = 2;
+  ctx.shadowColor = 'rgba(0, 0, 0, 0.5)';
+  ctx.shadowBlur = 4;
+  ctx.beginPath();
+  ctx.moveTo(splitX, 0);
+  ctx.lineTo(splitX, height);
+  ctx.stroke();
+
+  // Handle circle
+  var cy = height / 2;
+  ctx.shadowBlur = 6;
+  ctx.beginPath();
+  ctx.arc(splitX, cy, HANDLE_RADIUS, 0, Math.PI * 2);
+  ctx.fillStyle = '#29323C';
+  ctx.fill();
+  ctx.strokeStyle = '#FFFFFF';
+  ctx.lineWidth = 2;
+  ctx.stroke();
+  ctx.shadowBlur = 0;
+
+  // Left arrow
+  ctx.fillStyle = '#FFFFFF';
+  ctx.beginPath();
+  ctx.moveTo(splitX - ARROW_SIZE - 3, cy);
+  ctx.lineTo(splitX - 3, cy - ARROW_SIZE);
+  ctx.lineTo(splitX - 3, cy + ARROW_SIZE);
+  ctx.closePath();
+  ctx.fill();
+
+  // Right arrow
+  ctx.beginPath();
+  ctx.moveTo(splitX + ARROW_SIZE + 3, cy);
+  ctx.lineTo(splitX + 3, cy - ARROW_SIZE);
+  ctx.lineTo(splitX + 3, cy + ARROW_SIZE);
+  ctx.closePath();
+  ctx.fill();
+  ctx.restore();
+}
+
+/**
+ * Composite two canvases (left/right map views) with a swipe divider
+ * into a single output canvas.
+ */
+export function compositeSwipeFrame(leftCanvas, rightCanvas, outputCanvas, percentage) {
+  var showDivider = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+  var backgroundColor = arguments.length > 5 ? arguments[5] : undefined;
+  var showStars = arguments.length > 6 ? arguments[6] : undefined;
+  var ctx = outputCanvas.getContext('2d');
+  if (!ctx) return;
+  var w = outputCanvas.width;
+  var h = outputCanvas.height;
+  var splitX = Math.round(w * percentage / 100);
+  ctx.clearRect(0, 0, w, h);
+
+  // In globe mode the deck canvases are transparent where the globe isn't
+  // drawn (clearColor is disabled to keep picking intact), so paint the
+  // configured background first. Non-globe swipe passes no color and keeps the
+  // previous transparent-clear behavior (the base map is already opaque).
+  if (backgroundColor) {
+    ctx.fillStyle = backgroundColor;
+    ctx.fillRect(0, 0, w, h);
+  }
+
+  // Stars are a CSS background on the live globe map, so they must be tiled
+  // onto the composite canvas or they won't appear in preview or export.
+  if (showStars) {
+    drawStarsBackground(ctx, w, h);
+  }
+
+  // Draw right (background) canvas fully
+  ctx.drawImage(rightCanvas, 0, 0, w, h);
+
+  // Draw left (foreground) canvas clipped to 0..splitX
+  ctx.save();
+  ctx.beginPath();
+  ctx.rect(0, 0, splitX, h);
+  ctx.clip();
+  ctx.drawImage(leftCanvas, 0, 0, w, h);
+  ctx.restore();
+
+  // Draw the divider
+  if (showDivider) {
+    drawSwipeDivider(ctx, splitX, h);
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["easeInOut","drawStarsBackground","linear","p","EASING_MAP","getSwipePercentageAtTime","timeMs","durationMs","startPct","endPct","easing","arguments","length","undefined","progress","Math","max","min","easedProgress","HANDLE_RADIUS","ARROW_SIZE","drawSwipeDivider","ctx","splitX","height","save","strokeStyle","lineWidth","shadowColor","shadowBlur","beginPath","moveTo","lineTo","stroke","cy","arc","PI","fillStyle","fill","closePath","restore","compositeSwipeFrame","leftCanvas","rightCanvas","outputCanvas","percentage","showDivider","backgroundColor","showStars","getContext","w","width","h","round","clearRect","fillRect","drawImage","rect","clip"],"sources":["../../../src/modals/swipe-composite-utils.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {easeInOut} from 'popmotion';\nimport {drawStarsBackground} from '@kepler.gl/deckgl-layers';\n\nexport type SwipeEasing = 'linear' | 'ease-in-out';\n\nconst linear = (p: number): number => p;\nconst EASING_MAP: Record<SwipeEasing, (p: number) => number> = {\n  linear,\n  'ease-in-out': easeInOut\n};\n\n/**\n * Compute the swipe percentage at a given time.\n */\nexport function getSwipePercentageAtTime(\n  timeMs: number,\n  durationMs: number,\n  startPct: number,\n  endPct: number,\n  easing: SwipeEasing = 'ease-in-out'\n): number {\n  const progress = Math.max(0, Math.min(1, timeMs / durationMs));\n  const easedProgress = EASING_MAP[easing](progress);\n  return startPct + (endPct - startPct) * easedProgress;\n}\n\nconst HANDLE_RADIUS = 14;\nconst ARROW_SIZE = 6;\n\n/**\n * Draw a swipe divider (line + circular handle with arrows) onto a 2D canvas context.\n */\nfunction drawSwipeDivider(\n  ctx: CanvasRenderingContext2D,\n  splitX: number,\n  height: number\n): void {\n  ctx.save();\n\n  // Divider line\n  ctx.strokeStyle = '#FFFFFF';\n  ctx.lineWidth = 2;\n  ctx.shadowColor = 'rgba(0, 0, 0, 0.5)';\n  ctx.shadowBlur = 4;\n  ctx.beginPath();\n  ctx.moveTo(splitX, 0);\n  ctx.lineTo(splitX, height);\n  ctx.stroke();\n\n  // Handle circle\n  const cy = height / 2;\n  ctx.shadowBlur = 6;\n  ctx.beginPath();\n  ctx.arc(splitX, cy, HANDLE_RADIUS, 0, Math.PI * 2);\n  ctx.fillStyle = '#29323C';\n  ctx.fill();\n  ctx.strokeStyle = '#FFFFFF';\n  ctx.lineWidth = 2;\n  ctx.stroke();\n  ctx.shadowBlur = 0;\n\n  // Left arrow\n  ctx.fillStyle = '#FFFFFF';\n  ctx.beginPath();\n  ctx.moveTo(splitX - ARROW_SIZE - 3, cy);\n  ctx.lineTo(splitX - 3, cy - ARROW_SIZE);\n  ctx.lineTo(splitX - 3, cy + ARROW_SIZE);\n  ctx.closePath();\n  ctx.fill();\n\n  // Right arrow\n  ctx.beginPath();\n  ctx.moveTo(splitX + ARROW_SIZE + 3, cy);\n  ctx.lineTo(splitX + 3, cy - ARROW_SIZE);\n  ctx.lineTo(splitX + 3, cy + ARROW_SIZE);\n  ctx.closePath();\n  ctx.fill();\n\n  ctx.restore();\n}\n\n/**\n * Composite two canvases (left/right map views) with a swipe divider\n * into a single output canvas.\n */\nexport function compositeSwipeFrame(\n  leftCanvas: HTMLCanvasElement,\n  rightCanvas: HTMLCanvasElement,\n  outputCanvas: HTMLCanvasElement,\n  percentage: number,\n  showDivider: boolean = true,\n  backgroundColor?: string,\n  showStars?: boolean\n): void {\n  const ctx = outputCanvas.getContext('2d');\n  if (!ctx) return;\n\n  const w = outputCanvas.width;\n  const h = outputCanvas.height;\n  const splitX = Math.round((w * percentage) / 100);\n\n  ctx.clearRect(0, 0, w, h);\n\n  // In globe mode the deck canvases are transparent where the globe isn't\n  // drawn (clearColor is disabled to keep picking intact), so paint the\n  // configured background first. Non-globe swipe passes no color and keeps the\n  // previous transparent-clear behavior (the base map is already opaque).\n  if (backgroundColor) {\n    ctx.fillStyle = backgroundColor;\n    ctx.fillRect(0, 0, w, h);\n  }\n\n  // Stars are a CSS background on the live globe map, so they must be tiled\n  // onto the composite canvas or they won't appear in preview or export.\n  if (showStars) {\n    drawStarsBackground(ctx, w, h);\n  }\n\n  // Draw right (background) canvas fully\n  ctx.drawImage(rightCanvas, 0, 0, w, h);\n\n  // Draw left (foreground) canvas clipped to 0..splitX\n  ctx.save();\n  ctx.beginPath();\n  ctx.rect(0, 0, splitX, h);\n  ctx.clip();\n  ctx.drawImage(leftCanvas, 0, 0, w, h);\n  ctx.restore();\n\n  // Draw the divider\n  if (showDivider) {\n    drawSwipeDivider(ctx, splitX, h);\n  }\n}\n"],"mappings":"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","ignoreList":[]}