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

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

@@ -0,0 +1,202 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _useCloudListProvider = require("../hooks/use-cloud-list-provider");
+
+var _componentJestUtils = require("test/helpers/component-jest-utils");
+
+var _shareMapModal = _interopRequireDefault(require("./share-map-modal"));
+
+var _constants = require("@kepler.gl/constants");
+
+var _react2 = require("@testing-library/react");
+
+var _styledComponents = require("styled-components");
+
+var _reactIntl = require("react-intl");
+
+var _styles = require("@kepler.gl/styles");
+
+var _localization = require("@kepler.gl/localization");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+jest.mock('../hooks/use-cloud-list-provider', function () {
+  return {
+    useCloudListProvider: jest.fn().mockImplementation(function () {
+      return {
+        provider: null,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    })
+  };
+});
+var ShareMapUrlModal = (0, _shareMapModal["default"])();
+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 = (0, _componentJestUtils.renderWithTheme)( /*#__PURE__*/_react["default"].createElement(ShareMapUrlModal, DEFAULT_PROPS)),
+        getByText = _renderWithTheme.getByText,
+        queryByTestId = _renderWithTheme.queryByTestId;
+
+    expect(getByText('modal.shareMap.title')).toBeInTheDocument();
+    expect(queryByTestId(_constants.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.useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+
+    var _renderWithTheme2 = (0, _componentJestUtils.renderWithTheme)( /*#__PURE__*/_react["default"].createElement(ShareMapUrlModal, DEFAULT_PROPS)),
+        getByText = _renderWithTheme2.getByText,
+        getByTestId = _renderWithTheme2.getByTestId;
+
+    expect(getByText('modal.shareMap.title')).toBeInTheDocument();
+    expect(getByTestId(_constants.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.useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+
+    var providerLoadingProps = _objectSpread(_objectSpread({}, DEFAULT_PROPS), {}, {
+      isProviderLoading: true
+    });
+
+    var _renderWithTheme3 = (0, _componentJestUtils.renderWithTheme)( /*#__PURE__*/_react["default"].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.useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+
+    (0, _componentJestUtils.renderWithTheme)( /*#__PURE__*/_react["default"].createElement(ShareMapUrlModal, DEFAULT_PROPS));
+    expect(DEFAULT_PROPS.onExport).toHaveBeenCalled();
+  });
+  test('calls onExport after provider was updated', function () {
+    var _renderWithTheme4 = (0, _componentJestUtils.renderWithTheme)( /*#__PURE__*/_react["default"].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.useCloudListProvider.mockImplementation(function () {
+      return {
+        provider: mapProvider,
+        setProvider: jest.fn(),
+        cloudProviders: []
+      };
+    });
+
+    (0, _react2.act)(function () {
+      rerender( /*#__PURE__*/_react["default"].createElement(_styledComponents.ThemeProvider, {
+        theme: _styles.theme
+      }, /*#__PURE__*/_react["default"].createElement(_reactIntl.IntlProvider, {
+        locale: "en",
+        messages: _localization.messages
+      }, /*#__PURE__*/_react["default"].createElement(ShareMapUrlModal, DEFAULT_PROPS))));
+    });
+    expect(DEFAULT_PROPS.onExport).toHaveBeenCalled();
+  });
+  it('displays share URL when provided', function () {
+    var shareUrl = 'http://example.com';
+
+    var _renderWithTheme5 = (0, _componentJestUtils.renderWithTheme)( /*#__PURE__*/_react["default"].createElement(ShareMapUrlModal, (0, _extends2["default"])({}, DEFAULT_PROPS, {
+      successInfo: {
+        shareUrl: shareUrl
+      }
+    }))),
+        getByText = _renderWithTheme5.getByText;
+
+    expect(getByText('Share Url')).toBeInTheDocument();
+  });
+  it('renders errors', function () {
+    var _renderWithTheme6 = (0, _componentJestUtils.renderWithTheme)( /*#__PURE__*/_react["default"].createElement(ShareMapUrlModal, (0, _extends2["default"])({}, 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,"sources":["../../src/modals/share-map-modal.spec.tsx"],"names":["jest","mock","useCloudListProvider","fn","mockImplementation","provider","setProvider","cloudProviders","ShareMapUrlModal","DEFAULT_PROPS","isProviderLoading","onExport","providerError","successInfo","undefined","onUpdateImageSetting","cleanupExportImage","describe","afterEach","clearAllMocks","test","getByText","queryByTestId","expect","toBeInTheDocument","dataTestIds","providerShareMap","toBeNull","mapProvider","name","icon","getManagementUrl","listMaps","mockResolvedValue","hasSharingUrl","getByTestId","providerLoadingProps","toHaveBeenCalled","rerender","theme","messages","it","shareUrl","Error"],"mappings":"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","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"]}

package/dist/modals/status-panel.js

@@ -1,23 +1,3 @@
-// Copyright (c) 2022 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
@@ -100,4 +80,4 @@ var StatusPanel = function StatusPanel(_ref) {
 
 var _default = StatusPanel;
 exports["default"] = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9tb2RhbHMvc3RhdHVzLXBhbmVsLnRzeCJdLCJuYW1lcyI6WyJTdHlsZWRVcGxvYWRlciIsInN0eWxlZCIsImRpdiIsIlN0eWxlZE1hcEljb24iLCJwcm9wcyIsInRoZW1lIiwidGV4dENvbG9yTFQiLCJTdHlsZWRTdmciLCJzdmciLCJzZWxlY3RCb3JkZXJDb2xvckxUIiwiTGluZSIsIlVwbG9hZEFuaW1hdGlvbiIsImljb24iLCJTdGF0dXNQYW5lbCIsImVycm9yIiwiaXNMb2FkaW5nIiwicHJvdmlkZXJJY29uIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7OztBQUdBOztBQUNBOztBQUNBOztBQUNBOztBQUNBOztBQUNBOzs7O0FBR0EsSUFBTUEsY0FBYyxHQUFHQyw2QkFBT0MsR0FBVixrS0FBcEI7O0FBTUEsSUFBTUMsYUFBYSxHQUFHRiw2QkFBT0MsR0FBVixzSkFDUixVQUFBRSxLQUFLO0FBQUEsU0FBSUEsS0FBSyxDQUFDQyxLQUFOLENBQVlDLFdBQWhCO0FBQUEsQ0FERyxDQUFuQjs7QUFNQSxJQUFNQyxTQUFTLEdBQUdOLDZCQUFPTyxHQUFWLG9aQUlELFVBQUFKLEtBQUs7QUFBQSxTQUFJQSxLQUFLLENBQUNDLEtBQU4sQ0FBWUksbUJBQWhCO0FBQUEsQ0FKSixFQVdILFVBQUFMLEtBQUs7QUFBQSxTQUFJQSxLQUFLLENBQUNDLEtBQU4sQ0FBWUksbUJBQWhCO0FBQUEsQ0FYRixDQUFmOztBQXFCQSxJQUFNQyxJQUFJLEdBQUcsU0FBUEEsSUFBTztBQUFBLHNCQUNYLGdDQUFDLFNBQUQ7QUFBVyxJQUFBLE1BQU0sRUFBQyxLQUFsQjtBQUF3QixJQUFBLEtBQUssRUFBQztBQUE5QixrQkFDRTtBQUFNLElBQUEsRUFBRSxFQUFDLEdBQVQ7QUFBYSxJQUFBLEVBQUUsRUFBQyxHQUFoQjtBQUFvQixJQUFBLEVBQUUsRUFBQyxLQUF2QjtBQUE2QixJQUFBLEVBQUUsRUFBQztBQUFoQyxJQURGLENBRFc7QUFBQSxDQUFiOztBQVVPLElBQU1DLGVBQStDLEdBQUcsU0FBbERBLGVBQWtELENBQUFQLEtBQUs7QUFBQSxzQkFDbEUsZ0NBQUMsY0FBRCxxQkFDRSxnQ0FBQyxhQUFELHFCQUNFLGdDQUFDLGNBQUQ7QUFBUyxJQUFBLE1BQU0sRUFBQztBQUFoQixJQURGLENBREYsZUFJRSxnQ0FBQyxJQUFELE9BSkYsRUFLR0EsS0FBSyxDQUFDUSxJQUFOLGlCQUFjLGdDQUFDLEtBQUQsQ0FBTyxJQUFQO0FBQVksSUFBQSxNQUFNLEVBQUM7QUFBbkIsSUFMakIsQ0FEa0U7QUFBQSxDQUE3RDs7OztBQWdCUCxJQUFNQyxXQUF1QyxHQUFHLFNBQTFDQSxXQUEwQztBQUFBLE1BQUVDLEtBQUYsUUFBRUEsS0FBRjtBQUFBLE1BQVNDLFNBQVQsUUFBU0EsU0FBVDtBQUFBLE1BQW9CQyxZQUFwQixRQUFvQkEsWUFBcEI7QUFBQSxzQkFDOUMsZ0NBQUMsc0NBQUQscUJBQ0U7QUFBSyxJQUFBLFNBQVMsRUFBQztBQUFmLGtCQUNFO0FBQUssSUFBQSxTQUFTLEVBQUM7QUFBZixLQUNHRCxTQUFTLGdCQUNSLGdDQUFDLDhCQUFEO0FBQWtCLElBQUEsRUFBRSxFQUFFO0FBQXRCLElBRFEsR0FFTkQsS0FBSyxnQkFDUCxnQ0FBQyw4QkFBRDtBQUFrQixJQUFBLEVBQUUsRUFBRTtBQUF0QixJQURPLEdBRUwsSUFMTixDQURGLENBREYsZUFVRTtBQUFLLElBQUEsU0FBUyxFQUFDO0FBQWYsS0FDR0MsU0FBUyxpQkFBSSxnQ0FBQyxlQUFEO0FBQWlCLElBQUEsSUFBSSxFQUFFQztBQUF2QixJQURoQixFQUVHRixLQUFLLGlCQUFJLGdDQUFDLHdCQUFEO0FBQWMsSUFBQSxLQUFLLEVBQUVBO0FBQXJCLElBRlosQ0FWRixDQUQ4QztBQUFBLENBQWhEOztlQWtCZUQsVyIsInNvdXJjZXNDb250ZW50IjpbIi8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVRcbi8vIENvcHlyaWdodCBjb250cmlidXRvcnMgdG8gdGhlIGtlcGxlci5nbCBwcm9qZWN0XG5cbmltcG9ydCBSZWFjdCwge0NvbXBvbmVudFR5cGV9IGZyb20gJ3JlYWN0JztcbmltcG9ydCBzdHlsZWQgZnJvbSAnc3R5bGVkLWNvbXBvbmVudHMnO1xuaW1wb3J0IHtNYXBJY29ufSBmcm9tICcuLi9jb21tb24vaWNvbnMnO1xuaW1wb3J0IHtTdHlsZWRFeHBvcnRTZWN0aW9ufSBmcm9tICcuLi9jb21tb24vc3R5bGVkLWNvbXBvbmVudHMnO1xuaW1wb3J0IEVycm9yRGlzcGxheSBmcm9tICcuL2Vycm9yLWRpc3BsYXknO1xuaW1wb3J0IHtGb3JtYXR0ZWRNZXNzYWdlfSBmcm9tICdAa2VwbGVyLmdsL2xvY2FsaXphdGlvbic7XG5pbXBvcnQge0ljb25Qcm9wc30gZnJvbSAnQGtlcGxlci5nbC9jbG91ZC1wcm92aWRlcnMnO1xuXG5jb25zdCBTdHlsZWRVcGxvYWRlciA9IHN0eWxlZC5kaXZgXG4gIGRpc3BsYXk6IGZsZXg7XG4gIGFsaWduLWl0ZW1zOiBjZW50ZXI7XG4gIGp1c3RpZnktY29udGVudDogZmxleC1zdGFydDtcbmA7XG5cbmNvbnN0IFN0eWxlZE1hcEljb24gPSBzdHlsZWQuZGl2YFxuICBjb2xvcjogJHtwcm9wcyA9PiBwcm9wcy50aGVtZS50ZXh0Q29sb3JMVH07XG4gIG1hcmdpbi1yaWdodDogMTZweDtcbiAgbWFyZ2luLXRvcDogNHB4O1xuYDtcblxuY29uc3QgU3R5bGVkU3ZnID0gc3R5bGVkLnN2Z2BcbiAgbWFyZ2luLXJpZ2h0OiAxNnB4O1xuXG4gIGxpbmUge1xuICAgIHN0cm9rZTogJHtwcm9wcyA9PiBwcm9wcy50aGVtZS5zZWxlY3RCb3JkZXJDb2xvckxUfTtcbiAgICBzdHJva2Utd2lkdGg6IDQ7XG4gICAgc3Ryb2tlLWxpbmVjYXA6IHNxdWFyZTtcbiAgICBzdHJva2UtZGFzaGFycmF5OiA1IDEyO1xuICAgIGFuaW1hdGlvbjogZGFzaC1hbmltYXRpb24gMjVzIGluZmluaXRlIGxpbmVhcjtcbiAgfVxuICBjaXJjbGUge1xuICAgIGZpbGw6ICR7cHJvcHMgPT4gcHJvcHMudGhlbWUuc2VsZWN0Qm9yZGVyQ29sb3JMVH07XG4gIH1cblxuICBAa2V5ZnJhbWVzIGRhc2gtYW5pbWF0aW9uIHtcbiAgICB0byB7XG4gICAgICBzdHJva2UtZGFzaG9mZnNldDogLTEwMDA7XG4gICAgfVxuICB9XG5gO1xuXG5jb25zdCBMaW5lID0gKCkgPT4gKFxuICA8U3R5bGVkU3ZnIGhlaWdodD1cIjVweFwiIHdpZHRoPVwiMTUwcHhcIj5cbiAgICA8bGluZSB4MT1cIjBcIiB5MT1cIjRcIiB4Mj1cIjE1MFwiIHkyPVwiNFwiIC8+XG4gIDwvU3R5bGVkU3ZnPlxuKTtcblxuaW50ZXJmYWNlIFVwbG9hZEFuaW1hdGlvblByb3BzIHtcbiAgaWNvbj86IENvbXBvbmVudFR5cGU8SWNvblByb3BzPiB8IG51bGw7XG59XG5cbmV4cG9ydCBjb25zdCBVcGxvYWRBbmltYXRpb246IFJlYWN0LkZDPFVwbG9hZEFuaW1hdGlvblByb3BzPiA9IHByb3BzID0+IChcbiAgPFN0eWxlZFVwbG9hZGVyPlxuICAgIDxTdHlsZWRNYXBJY29uPlxuICAgICAgPE1hcEljb24gaGVpZ2h0PVwiNDhweFwiIC8+XG4gICAgPC9TdHlsZWRNYXBJY29uPlxuICAgIDxMaW5lIC8+XG4gICAge3Byb3BzLmljb24gJiYgPHByb3BzLmljb24gaGVpZ2h0PVwiNjRweFwiIC8+fVxuICA8L1N0eWxlZFVwbG9hZGVyPlxuKTtcblxuaW50ZXJmYWNlIFN0YXR1c1BhbmVsUHJvcHMge1xuICBlcnJvcj86IHN0cmluZyB8IG51bGw7XG4gIGlzTG9hZGluZz86IGJvb2xlYW47XG4gIHByb3ZpZGVySWNvbj86IENvbXBvbmVudFR5cGU8SWNvblByb3BzPiB8IG51bGw7XG59XG5cbmNvbnN0IFN0YXR1c1BhbmVsOiBSZWFjdC5GQzxTdGF0dXNQYW5lbFByb3BzPiA9ICh7ZXJyb3IsIGlzTG9hZGluZywgcHJvdmlkZXJJY29ufSkgPT4gKFxuICA8U3R5bGVkRXhwb3J0U2VjdGlvbj5cbiAgICA8ZGl2IGNsYXNzTmFtZT1cImRlc2NyaXB0aW9uXCI+XG4gICAgICA8ZGl2IGNsYXNzTmFtZT1cInRpdGxlXCI+XG4gICAgICAgIHtpc0xvYWRpbmcgPyAoXG4gICAgICAgICAgPEZvcm1hdHRlZE1lc3NhZ2UgaWQ9eydtb2RhbC5zdGF0dXNQYW5lbC5tYXBVcGxvYWRpbmcnfSAvPlxuICAgICAgICApIDogZXJyb3IgPyAoXG4gICAgICAgICAgPEZvcm1hdHRlZE1lc3NhZ2UgaWQ9eydtb2RhbC5zdGF0dXNQYW5lbC5lcnJvcid9IC8+XG4gICAgICAgICkgOiBudWxsfVxuICAgICAgPC9kaXY+XG4gICAgPC9kaXY+XG4gICAgPGRpdiBjbGFzc05hbWU9XCJzZWxlY3Rpb25cIj5cbiAgICAgIHtpc0xvYWRpbmcgJiYgPFVwbG9hZEFuaW1hdGlvbiBpY29uPXtwcm92aWRlckljb259IC8+fVxuICAgICAge2Vycm9yICYmIDxFcnJvckRpc3BsYXkgZXJyb3I9e2Vycm9yfSAvPn1cbiAgICA8L2Rpdj5cbiAgPC9TdHlsZWRFeHBvcnRTZWN0aW9uPlxuKTtcblxuZXhwb3J0IGRlZmF1bHQgU3RhdHVzUGFuZWw7XG4iXX0=

package/dist/modals/storage-map-viewer.d.ts

@@ -16,6 +16,6 @@ interface StorageAssetsViewerProps {
     };
 }
 declare class StorageAssetsViewer extends React.Component<StorageAssetsViewerProps> {
-    render(): JSX.Element;
+    render(): React.JSX.Element;
 }
 export default StorageAssetsViewer;

package/dist/modals/storage-map-viewer.js

@@ -1,23 +1,3 @@
-// Copyright (c) 2022 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
@@ -144,4 +124,4 @@ var StorageAssetsViewer = /*#__PURE__*/function (_React$Component) {
 
 var _default = StorageAssetsViewer;
 exports["default"] = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/modals/storage-map-viewer.tsx"],"names":["imageH","StyledAssetGallery","styled","div","attrs","className","StyledAssetItem","props","theme","textColorLT","BackLink","titleColorLT","StyledError","getDuration","last","moment","duration","Date","valueOf","humanize","AssetItem","asset","onClick","imageUrl","label","title","description","lastUpdated","StorageAssetsViewer","assets","onLoadAsset","back","error","message","map","sp","id","React","Component"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport React from 'react';\nimport styled from 'styled-components';\nimport moment from 'moment';\nimport {LeftArrow} from '../common/icons';\nimport {FormattedMessage} from '@kepler.gl/localization';\n\nconst imageH = 108;\n\nconst StyledAssetGallery = styled.div.attrs({\n  className: 'storage-asset-gallery'\n})`\n  display: flex;\n  justify-content: flex-start;\n  flex-wrap: wrap;\n`;\n\nconst StyledAssetItem = styled.div.attrs({\n  className: 'asset__item'\n})`\n  width: 23%;\n  margin-right: 2%;\n  max-width: 500px;\n  margin-bottom: 40px;\n  height: 245px;\n  display: flex;\n  flex-direction: column;\n  justify-content: space-between;\n\n  :last {\n    margin-right: 0;\n  }\n\n  .asset__title {\n    font-size: 12px;\n    font-weight: 500;\n    color: ${props => props.theme.textColorLT};\n    line-height: 18px;\n    height: 32px;\n  }\n\n  .asset__image {\n    border-radius: 4px;\n    overflow: hidden;\n    margin-bottom: 12px;\n    opacity: 0.9;\n    transition: opacity 0.4s ease;\n    position: relative;\n    line-height: 0;\n    height: ${imageH}px;\n    flex-shrink: 0;\n\n    img {\n      max-width: 100%;\n    }\n    :hover {\n      cursor: pointer;\n      opacity: 1;\n    }\n  }\n\n  .asset__image__caption {\n    font-size: 11px;\n    font-weight: 400;\n    line-height: 16px;\n    margin-top: 10px;\n    height: 48px;\n    overflow: hidden;\n    display: -webkit-box;\n    text-overflow: ellipsis;\n    -webkit-line-clamp: 3;\n    -webkit-box-orient: vertical;\n  }\n\n  .asset__last-updated {\n    font-size: 11px;\n    color: ${props => props.theme.textColorLT};\n  }\n`;\n\nconst BackLink = styled.div`\n  display: flex;\n  font-size: 14px;\n  align-items: center;\n  color: ${props => props.theme.titleColorLT};\n  cursor: pointer;\n  margin-bottom: 40px;\n\n  :hover {\n    font-weight: 500;\n  }\n\n  span {\n    white-space: nowrap;\n  }\n  svg {\n    margin-right: 10px;\n  }\n`;\n\nconst StyledError = styled.div`\n  color: red;\n  font-size: 14px;\n  margin-bottom: 16px;\n`;\n\nconst getDuration = (last: number = 0) => moment.duration(new Date().valueOf() - last).humanize();\n\ninterface Asset {\n  imageUrl?: string;\n  label?: string;\n  title?: string;\n  description?: string;\n  lastUpdated?: number;\n  id?: string;\n}\n\ninterface AssetItemProps {\n  asset: Asset;\n  onClick: React.MouseEventHandler<HTMLDivElement>;\n}\n\nconst AssetItem: React.FC<AssetItemProps> = ({asset, onClick}) => (\n  <StyledAssetItem>\n    <div className=\"asset__image\" onClick={onClick}>\n      {asset.imageUrl && <img src={asset.imageUrl} />}\n    </div>\n    <div className=\"asset__title\">{asset.label || asset.title}</div>\n    <div className=\"asset__image__caption\">{asset.description}</div>\n    {asset.lastUpdated ? (\n      <div className=\"asset__last-updated\">\n        <FormattedMessage\n          id={'modal.storageMapViewer.lastModified'}\n          values={{lastUpdated: getDuration(asset.lastUpdated)}}\n        />\n      </div>\n    ) : null}\n  </StyledAssetItem>\n);\n\ninterface StorageAssetsViewerProps {\n  assets: Asset[];\n  onLoadAsset: (asset: Asset) => void;\n  back?: React.MouseEventHandler<HTMLDivElement>;\n  error?: {message?: string};\n}\n\nclass StorageAssetsViewer extends React.Component<StorageAssetsViewerProps> {\n  render() {\n    const {assets, onLoadAsset, back, error} = this.props;\n\n    return (\n      <div className=\"storage-asset-viewer\">\n        <BackLink onClick={back}>\n          <LeftArrow height=\"12px\" />\n          <span>\n            <FormattedMessage id={'modal.storageMapViewer.back'} />\n          </span>\n        </BackLink>\n        {error && <StyledError>{error.message}</StyledError>}\n        <StyledAssetGallery>\n          {assets.map(sp => (\n            <AssetItem asset={sp} key={sp.id} onClick={() => onLoadAsset(sp)} />\n          ))}\n        </StyledAssetGallery>\n      </div>\n    );\n  }\n}\n\nexport default StorageAssetsViewer;\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/modals/storage-map-viewer.tsx"],"names":["imageH","StyledAssetGallery","styled","div","attrs","className","StyledAssetItem","props","theme","textColorLT","BackLink","titleColorLT","StyledError","getDuration","last","moment","duration","Date","valueOf","humanize","AssetItem","asset","onClick","imageUrl","label","title","description","lastUpdated","StorageAssetsViewer","assets","onLoadAsset","back","error","message","map","sp","id","React","Component"],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React from 'react';\nimport styled from 'styled-components';\nimport moment from 'moment';\nimport {LeftArrow} from '../common/icons';\nimport {FormattedMessage} from '@kepler.gl/localization';\n\nconst imageH = 108;\n\nconst StyledAssetGallery = styled.div.attrs({\n  className: 'storage-asset-gallery'\n})`\n  display: flex;\n  justify-content: flex-start;\n  flex-wrap: wrap;\n`;\n\nconst StyledAssetItem = styled.div.attrs({\n  className: 'asset__item'\n})`\n  width: 23%;\n  margin-right: 2%;\n  max-width: 500px;\n  margin-bottom: 40px;\n  height: 245px;\n  display: flex;\n  flex-direction: column;\n  justify-content: space-between;\n\n  :last {\n    margin-right: 0;\n  }\n\n  .asset__title {\n    font-size: 12px;\n    font-weight: 500;\n    color: ${props => props.theme.textColorLT};\n    line-height: 18px;\n    height: 32px;\n  }\n\n  .asset__image {\n    border-radius: 4px;\n    overflow: hidden;\n    margin-bottom: 12px;\n    opacity: 0.9;\n    transition: opacity 0.4s ease;\n    position: relative;\n    line-height: 0;\n    height: ${imageH}px;\n    flex-shrink: 0;\n\n    img {\n      max-width: 100%;\n    }\n    :hover {\n      cursor: pointer;\n      opacity: 1;\n    }\n  }\n\n  .asset__image__caption {\n    font-size: 11px;\n    font-weight: 400;\n    line-height: 16px;\n    margin-top: 10px;\n    height: 48px;\n    overflow: hidden;\n    display: -webkit-box;\n    text-overflow: ellipsis;\n    -webkit-line-clamp: 3;\n    -webkit-box-orient: vertical;\n  }\n\n  .asset__last-updated {\n    font-size: 11px;\n    color: ${props => props.theme.textColorLT};\n  }\n`;\n\nconst BackLink = styled.div`\n  display: flex;\n  font-size: 14px;\n  align-items: center;\n  color: ${props => props.theme.titleColorLT};\n  cursor: pointer;\n  margin-bottom: 40px;\n\n  :hover {\n    font-weight: 500;\n  }\n\n  span {\n    white-space: nowrap;\n  }\n  svg {\n    margin-right: 10px;\n  }\n`;\n\nconst StyledError = styled.div`\n  color: red;\n  font-size: 14px;\n  margin-bottom: 16px;\n`;\n\nconst getDuration = (last: number = 0) => moment.duration(new Date().valueOf() - last).humanize();\n\ninterface Asset {\n  imageUrl?: string;\n  label?: string;\n  title?: string;\n  description?: string;\n  lastUpdated?: number;\n  id?: string;\n}\n\ninterface AssetItemProps {\n  asset: Asset;\n  onClick: React.MouseEventHandler<HTMLDivElement>;\n}\n\nconst AssetItem: React.FC<AssetItemProps> = ({asset, onClick}) => (\n  <StyledAssetItem>\n    <div className=\"asset__image\" onClick={onClick}>\n      {asset.imageUrl && <img src={asset.imageUrl} />}\n    </div>\n    <div className=\"asset__title\">{asset.label || asset.title}</div>\n    <div className=\"asset__image__caption\">{asset.description}</div>\n    {asset.lastUpdated ? (\n      <div className=\"asset__last-updated\">\n        <FormattedMessage\n          id={'modal.storageMapViewer.lastModified'}\n          values={{lastUpdated: getDuration(asset.lastUpdated)}}\n        />\n      </div>\n    ) : null}\n  </StyledAssetItem>\n);\n\ninterface StorageAssetsViewerProps {\n  assets: Asset[];\n  onLoadAsset: (asset: Asset) => void;\n  back?: React.MouseEventHandler<HTMLDivElement>;\n  error?: {message?: string};\n}\n\nclass StorageAssetsViewer extends React.Component<StorageAssetsViewerProps> {\n  render() {\n    const {assets, onLoadAsset, back, error} = this.props;\n\n    return (\n      <div className=\"storage-asset-viewer\">\n        <BackLink onClick={back}>\n          <LeftArrow height=\"12px\" />\n          <span>\n            <FormattedMessage id={'modal.storageMapViewer.back'} />\n          </span>\n        </BackLink>\n        {error && <StyledError>{error.message}</StyledError>}\n        <StyledAssetGallery>\n          {assets.map(sp => (\n            <AssetItem asset={sp} key={sp.id} onClick={() => onLoadAsset(sp)} />\n          ))}\n        </StyledAssetGallery>\n      </div>\n    );\n  }\n}\n\nexport default StorageAssetsViewer;\n"]}

package/dist/notification-panel/notification-item.d.ts

@@ -5,6 +5,7 @@ interface NotificationItemProps {
         id: string;
         type: string;
         message: string;
+        count?: number;
     };
     isExpanded?: boolean;
     removeNotification?: ActionHandler<typeof removeNotificationActions>;
@@ -16,13 +17,11 @@ export default function NotificationItemFactory(): {
             isExpanded: boolean;
         };
         componentDidMount(): void;
-        render(): JSX.Element;
-        context: any;
+        render(): React.JSX.Element;
+        context: unknown;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<NotificationItemProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<NotificationItemProps> & Readonly<{
-            children?: React.ReactNode;
-        }>;
+        readonly props: Readonly<NotificationItemProps>;
         refs: {
             [key: string]: React.ReactInstance;
         };
@@ -43,13 +42,11 @@ export default function NotificationItemFactory(): {
             isExpanded: boolean;
         };
         componentDidMount(): void;
-        render(): JSX.Element;
-        context: any;
+        render(): React.JSX.Element;
+        context: unknown;
         setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<NotificationItemProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
         forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<NotificationItemProps> & Readonly<{
-            children?: React.ReactNode;
-        }>;
+        readonly props: Readonly<NotificationItemProps>;
         refs: {
             [key: string]: React.ReactInstance;
         };

package/dist/notification-panel/notification-item.js

@@ -1,23 +1,3 @@
-// Copyright (c) 2022 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
@@ -53,13 +33,21 @@ var _icons = require("../common/icons");
 
 var _reactMarkdown = _interopRequireDefault(require("react-markdown"));
 
-var _templateObject, _templateObject2, _templateObject3, _templateObject4;
+var _constants = require("@kepler.gl/constants");
+
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6;
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
 
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-var NotificationItemContent = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  background-color: ", ";\n  color: #fff;\n  display: flex;\n  flex-direction: row;\n  width: ", "px;\n  height: ", "px;\n  font-size: 11px;\n  margin-bottom: 1rem;\n  padding: 1em;\n  border-radius: 4px;\n  box-shadow: ", ";\n  cursor: pointer;\n"])), function (props) {
+var NotificationItemContentBlock = _styledComponents["default"].div.attrs({
+  className: 'notification-item--content-block'
+})(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  display: block;\n  position: relative;\n  width: ", "px;\n  margin-left: auto;\n"])), function (props) {
+  return props.theme.notificationPanelItemWidth * (1 + Number(props.isExpanded));
+});
+
+var NotificationItemContent = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  background-color: ", ";\n  color: #fff;\n  display: flex;\n  flex-direction: row;\n  width: ", "px;\n  height: ", "px;\n  font-size: 11px;\n  margin-bottom: 1rem;\n  padding: 1em;\n  border-radius: 4px;\n  box-shadow: ", ";\n  cursor: pointer;\n"])), function (props) {
   return props.theme.notificationColors[props.type] || '#000';
 }, function (props) {
   return props.theme.notificationPanelItemWidth * (1 + Number(props.isExpanded));
@@ -69,11 +57,21 @@ var NotificationItemContent = _styledComponents["default"].div(_templateObject |
   return props.theme.boxShadow;
 });
 
-var DeleteIcon = (0, _styledComponents["default"])(_icons.Delete)(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  cursor: pointer;\n"])));
+var DeleteIcon = (0, _styledComponents["default"])(_icons.Delete)(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  cursor: pointer;\n  width: 13px;\n  height: 13px;\n"])));
+
+var NotificationCounter = _styledComponents["default"].div.attrs({
+  className: 'notification-item--counter'
+})(_templateObject4 || (_templateObject4 = (0, _taggedTemplateLiteral2["default"])(["\n  position: absolute;\n  font-size: 11px;\n  font-weight: bold;\n  text-align: center;\n  left: -4px;\n  bottom: -4px;\n  border-radius: 50%;\n  width: 20px;\n  height: 20px;\n  background-color: #ffffff;\n  border: 1px solid ", ";\n  color: ", ";\n  box-shadow: ", ";\n"])), function (props) {
+  return props.theme.notificationColors[props.type] || '#000';
+}, function (props) {
+  return props.theme.notificationColors[props.type] || '#000';
+}, function (props) {
+  return props.theme.boxShadow;
+});
 
 var NotificationMessage = _styledComponents["default"].div.attrs({
   className: 'notification-item--message'
-})(_templateObject3 || (_templateObject3 = (0, _taggedTemplateLiteral2["default"])(["\n  flex-grow: 2;\n  width: ", "px;\n  margin: 0 1em;\n  overflow: ", ";\n  padding-right: ", ";\n\n  p {\n    margin-top: 0;\n    a {\n      color: #fff;\n      text-decoration: underline;\n    }\n  }\n"])), function (props) {
+})(_templateObject5 || (_templateObject5 = (0, _taggedTemplateLiteral2["default"])(["\n  flex-grow: 2;\n  width: ", "px;\n  margin: 0 1em;\n  overflow: ", ";\n  padding-right: ", ";\n\n  p {\n    margin-top: 0;\n    a {\n      color: #fff;\n      text-decoration: underline;\n    }\n  }\n"])), function (props) {
   return props.theme.notificationPanelItemWidth;
 }, function (props) {
   return props.isExpanded ? 'auto' : 'hidden';
@@ -81,13 +79,21 @@ var NotificationMessage = _styledComponents["default"].div.attrs({
   return props.isExpanded ? '1em' : 0;
 });
 
-var NotificationIcon = _styledComponents["default"].div(_templateObject4 || (_templateObject4 = (0, _taggedTemplateLiteral2["default"])(["\n  svg {\n    vertical-align: text-top;\n  }\n"])));
+var NotificationIcon = _styledComponents["default"].div(_templateObject6 || (_templateObject6 = (0, _taggedTemplateLiteral2["default"])(["\n  svg {\n    vertical-align: text-top;\n  }\n"])));
 
 var icons = {
-  info: /*#__PURE__*/_react["default"].createElement(_icons.Info, null),
-  warning: /*#__PURE__*/_react["default"].createElement(_icons.Warning, null),
-  error: /*#__PURE__*/_react["default"].createElement(_icons.Warning, null),
-  success: /*#__PURE__*/_react["default"].createElement(_icons.Checkmark, null)
+  info: /*#__PURE__*/_react["default"].createElement(_icons.Info, {
+    "data-testid": _constants.dataTestIds.infoIcon
+  }),
+  warning: /*#__PURE__*/_react["default"].createElement(_icons.Warning, {
+    "data-testid": _constants.dataTestIds.warningIcon
+  }),
+  error: /*#__PURE__*/_react["default"].createElement(_icons.Warning, {
+    "data-testid": _constants.dataTestIds.errorIcon
+  }),
+  success: /*#__PURE__*/_react["default"].createElement(_icons.Checkmark, {
+    "data-testid": _constants.dataTestIds.successIcon
+  })
 };
 
 var LinkRenderer = function LinkRenderer(props) {
@@ -138,7 +144,13 @@ function NotificationItemFactory() {
             notification = _this$props.notification,
             removeNotification = _this$props.removeNotification;
         var isExpanded = this.state.isExpanded;
-        return /*#__PURE__*/_react["default"].createElement(NotificationItemContent, {
+        return /*#__PURE__*/_react["default"].createElement(NotificationItemContentBlock, {
+          isExpanded: isExpanded,
+          theme: this.props.theme
+        }, (notification.count || 0) > 1 ? /*#__PURE__*/_react["default"].createElement(NotificationCounter, {
+          type: notification.type,
+          theme: this.props.theme
+        }, notification.count) : null, /*#__PURE__*/_react["default"].createElement(NotificationItemContent, {
           className: "notification-item",
           type: notification.type,
           isExpanded: isExpanded,
@@ -164,10 +176,10 @@ function NotificationItemFactory() {
           onClick: function onClick() {
             return removeNotification(notification.id);
           }
-        })) : null);
+        })) : null));
       }
     }]);
     return NotificationItem;
   }(_react.Component);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/notification-panel/notification-item.tsx"],"names":["NotificationItemContent","styled","div","props","theme","notificationColors","type","notificationPanelItemWidth","Number","isExpanded","notificationPanelItemHeight","boxShadow","DeleteIcon","Delete","NotificationMessage","attrs","className","NotificationIcon","icons","info","warning","error","success","LinkRenderer","href","children","NotificationItemFactory","setState","notification","removeNotification","state","message","link","id","Component"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport React, {Component} from 'react';\nimport styled from 'styled-components';\nimport {Delete, Info, Warning, Checkmark} from '../common/icons';\nimport ReactMarkdown from 'react-markdown';\nimport {\n  ActionHandler,\n  removeNotification as removeNotificationActions\n} from '@kepler.gl/actions';\n\ninterface NotificationItemContentProps {\n  type: string;\n  isExpanded?: boolean;\n}\n\nconst NotificationItemContent = styled.div<NotificationItemContentProps>`\n  background-color: ${props => props.theme.notificationColors[props.type] || '#000'};\n  color: #fff;\n  display: flex;\n  flex-direction: row;\n  width: ${props => props.theme.notificationPanelItemWidth * (1 + Number(props.isExpanded))}px;\n  height: ${props => props.theme.notificationPanelItemHeight * (1 + Number(props.isExpanded))}px;\n  font-size: 11px;\n  margin-bottom: 1rem;\n  padding: 1em;\n  border-radius: 4px;\n  box-shadow: ${props => props.theme.boxShadow};\n  cursor: pointer;\n`;\n\nconst DeleteIcon = styled(Delete)`\n  cursor: pointer;\n`;\n\ninterface NotificationMessageProps {\n  isExpanded?: boolean;\n}\n\nconst NotificationMessage = styled.div.attrs({\n  className: 'notification-item--message'\n})<NotificationMessageProps>`\n  flex-grow: 2;\n  width: ${props => props.theme.notificationPanelItemWidth}px;\n  margin: 0 1em;\n  overflow: ${props => (props.isExpanded ? 'auto' : 'hidden')};\n  padding-right: ${props => (props.isExpanded ? '1em' : 0)};\n\n  p {\n    margin-top: 0;\n    a {\n      color: #fff;\n      text-decoration: underline;\n    }\n  }\n`;\n\nconst NotificationIcon = styled.div`\n  svg {\n    vertical-align: text-top;\n  }\n`;\n\nconst icons = {\n  info: <Info />,\n  warning: <Warning />,\n  error: <Warning />,\n  success: <Checkmark />\n};\n\nconst LinkRenderer = props => {\n  return (\n    <a href={props.href} target=\"_blank\" rel=\"noopener noreferrer\">\n      {props.children}\n    </a>\n  );\n};\n\ninterface NotificationItemProps {\n  notification: {\n    id: string;\n    type: string;\n    message: string;\n  };\n  isExpanded?: boolean;\n  removeNotification?: ActionHandler<typeof removeNotificationActions>;\n  theme?: any;\n}\n\nexport default function NotificationItemFactory() {\n  return class NotificationItem extends Component<NotificationItemProps> {\n    state = {\n      isExpanded: false\n    };\n\n    componentDidMount() {\n      if (this.props.isExpanded) {\n        this.setState({isExpanded: true});\n      }\n    }\n\n    render() {\n      const {notification, removeNotification} = this.props;\n      const {isExpanded} = this.state;\n\n      return (\n        <NotificationItemContent\n          className=\"notification-item\"\n          type={notification.type}\n          isExpanded={isExpanded}\n          onClick={() => this.setState({isExpanded: !isExpanded})}\n        >\n          <NotificationIcon className=\"notification-item--icon\">\n            {icons[notification.type]}\n          </NotificationIcon>\n          <NotificationMessage isExpanded={isExpanded} theme={this.props.theme}>\n            <ReactMarkdown source={notification.message} renderers={{link: LinkRenderer}} />\n          </NotificationMessage>\n          {typeof removeNotification === 'function' ? (\n            <div className=\"notification-item--action\">\n              <DeleteIcon height=\"10px\" onClick={() => removeNotification(notification.id)} />\n            </div>\n          ) : null}\n        </NotificationItemContent>\n      );\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/notification-panel/notification-item.tsx"],"names":["NotificationItemContentBlock","styled","div","attrs","className","props","theme","notificationPanelItemWidth","Number","isExpanded","NotificationItemContent","notificationColors","type","notificationPanelItemHeight","boxShadow","DeleteIcon","Delete","NotificationCounter","NotificationMessage","NotificationIcon","icons","info","dataTestIds","infoIcon","warning","warningIcon","error","errorIcon","success","successIcon","LinkRenderer","href","children","NotificationItemFactory","setState","notification","removeNotification","state","count","message","link","id","Component"],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {Component} from 'react';\nimport styled from 'styled-components';\nimport {Delete, Info, Warning, Checkmark} from '../common/icons';\nimport ReactMarkdown from 'react-markdown';\nimport {dataTestIds} from '@kepler.gl/constants';\nimport {ActionHandler, removeNotification as removeNotificationActions} from '@kepler.gl/actions';\n\ninterface NotificationItemContentBlockProps {\n  isExpanded?: boolean;\n}\n\nconst NotificationItemContentBlock = styled.div.attrs({\n  className: 'notification-item--content-block'\n})<NotificationItemContentBlockProps>`\n  display: block;\n  position: relative;\n  width: ${props => props.theme.notificationPanelItemWidth * (1 + Number(props.isExpanded))}px;\n  margin-left: auto;\n`;\n\ninterface NotificationItemContentProps {\n  type: string;\n  isExpanded?: boolean;\n}\n\nconst NotificationItemContent = styled.div<NotificationItemContentProps>`\n  background-color: ${props => props.theme.notificationColors[props.type] || '#000'};\n  color: #fff;\n  display: flex;\n  flex-direction: row;\n  width: ${props => props.theme.notificationPanelItemWidth * (1 + Number(props.isExpanded))}px;\n  height: ${props => props.theme.notificationPanelItemHeight * (1 + Number(props.isExpanded))}px;\n  font-size: 11px;\n  margin-bottom: 1rem;\n  padding: 1em;\n  border-radius: 4px;\n  box-shadow: ${props => props.theme.boxShadow};\n  cursor: pointer;\n`;\n\nconst DeleteIcon = styled(Delete)`\n  cursor: pointer;\n  width: 13px;\n  height: 13px;\n`;\n\ninterface NotificationCounterProps {\n  type: string;\n}\n\nconst NotificationCounter = styled.div.attrs({\n  className: 'notification-item--counter'\n})<NotificationCounterProps>`\n  position: absolute;\n  font-size: 11px;\n  font-weight: bold;\n  text-align: center;\n  left: -4px;\n  bottom: -4px;\n  border-radius: 50%;\n  width: 20px;\n  height: 20px;\n  background-color: #ffffff;\n  border: 1px solid ${props => props.theme.notificationColors[props.type] || '#000'};\n  color: ${props => props.theme.notificationColors[props.type] || '#000'};\n  box-shadow: ${props => props.theme.boxShadow};\n`;\n\ninterface NotificationMessageProps {\n  isExpanded?: boolean;\n}\n\nconst NotificationMessage = styled.div.attrs({\n  className: 'notification-item--message'\n})<NotificationMessageProps>`\n  flex-grow: 2;\n  width: ${props => props.theme.notificationPanelItemWidth}px;\n  margin: 0 1em;\n  overflow: ${props => (props.isExpanded ? 'auto' : 'hidden')};\n  padding-right: ${props => (props.isExpanded ? '1em' : 0)};\n\n  p {\n    margin-top: 0;\n    a {\n      color: #fff;\n      text-decoration: underline;\n    }\n  }\n`;\n\nconst NotificationIcon = styled.div`\n  svg {\n    vertical-align: text-top;\n  }\n`;\n\nconst icons = {\n  info: <Info data-testid={dataTestIds.infoIcon} />,\n  warning: <Warning data-testid={dataTestIds.warningIcon} />,\n  error: <Warning data-testid={dataTestIds.errorIcon} />,\n  success: <Checkmark data-testid={dataTestIds.successIcon} />\n};\n\nconst LinkRenderer = props => {\n  return (\n    <a href={props.href} target=\"_blank\" rel=\"noopener noreferrer\">\n      {props.children}\n    </a>\n  );\n};\n\ninterface NotificationItemProps {\n  notification: {\n    id: string;\n    type: string;\n    message: string;\n    count?: number;\n  };\n  isExpanded?: boolean;\n  removeNotification?: ActionHandler<typeof removeNotificationActions>;\n  theme?: any;\n}\n\nexport default function NotificationItemFactory() {\n  return class NotificationItem extends Component<NotificationItemProps> {\n    state = {\n      isExpanded: false\n    };\n\n    componentDidMount() {\n      if (this.props.isExpanded) {\n        this.setState({isExpanded: true});\n      }\n    }\n\n    render() {\n      const {notification, removeNotification} = this.props;\n      const {isExpanded} = this.state;\n\n      return (\n        <NotificationItemContentBlock isExpanded={isExpanded} theme={this.props.theme}>\n          {(notification.count || 0) > 1 ? (\n            <NotificationCounter type={notification.type} theme={this.props.theme}>\n              {notification.count}\n            </NotificationCounter>\n          ) : null}\n          <NotificationItemContent\n            className=\"notification-item\"\n            type={notification.type}\n            isExpanded={isExpanded}\n            onClick={() => this.setState({isExpanded: !isExpanded})}\n          >\n            <NotificationIcon className=\"notification-item--icon\">\n              {icons[notification.type]}\n            </NotificationIcon>\n            <NotificationMessage isExpanded={isExpanded} theme={this.props.theme}>\n              <ReactMarkdown source={notification.message} renderers={{link: LinkRenderer}} />\n            </NotificationMessage>\n            {typeof removeNotification === 'function' ? (\n              <div className=\"notification-item--action\">\n                <DeleteIcon height=\"10px\" onClick={() => removeNotification(notification.id)} />\n              </div>\n            ) : null}\n          </NotificationItemContent>\n        </NotificationItemContentBlock>\n      );\n    }\n  };\n}\n"]}