@carto/kepler.gl 0.1.0-alpha.1 → 0.1.0-next.1

package/dist/components/side-panel/custom-panel.d.ts

@@ -1,9 +1,9 @@
-import React from 'react';
-declare function CustomPanelsFactory(): {
-    (props: any): React.JSX.Element;
-    defaultProps: {
-        panels: any[];
-        getProps: (sidePanelProps: any) => {};
-    };
-};
-export default CustomPanelsFactory;
+import React from 'react';
+declare function CustomPanelsFactory(): {
+    (props: any): React.JSX.Element;
+    defaultProps: {
+        panels: any[];
+        getProps: (sidePanelProps: any) => {};
+    };
+};
+export default CustomPanelsFactory;

package/dist/components/side-panel/custom-panel.js

@@ -0,0 +1,56 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _react = _interopRequireDefault(require("react"));
+// 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.
+
+// This is a dummy component that can be replaced to inject more side panel sub panels into the side bar
+function CustomPanelsFactory() {
+  var CustomPanels = function CustomPanels(props) {
+    return /*#__PURE__*/_react["default"].createElement("div", null);
+  };
+  CustomPanels.defaultProps = {
+    // provide a list of additional panels
+    panels: [
+      // {
+      //   id: 'rocket',
+      //   label: 'Rocket',
+      //   iconComponent: Icons.Rocket
+      // },
+      // {
+      //   id: 'chart',
+      //   label: 'Chart',
+      //   iconComponent: Icons.LineChart
+      // }
+    ],
+    // prop selector from side panel props
+    getProps: function getProps(sidePanelProps) {
+      return {};
+    }
+  };
+  return CustomPanels;
+}
+var _default = exports["default"] = CustomPanelsFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/components/side-panel/filter-manager.d.ts

@@ -1,20 +1,20 @@
-import React from 'react';
-import SourceDataCatalogFactory from './common/source-data-catalog';
-import FilterPanelFactory from './filter-panel/filter-panel';
-import { Datasets, Filter } from 'reducers';
-import { Layer } from 'layers';
-import * as VisStateActions from 'actions/vis-state-actions';
-import { ActionHandler } from 'actions';
-type FilterManagerProps = {
-    filters: Filter[];
-    datasets: Datasets;
-    layers: Layer[];
-    showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;
-    updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;
-    visStateActions: typeof VisStateActions;
-};
-declare function FilterManagerFactory(SourceDataCatalog: ReturnType<typeof SourceDataCatalogFactory>, FilterPanel: ReturnType<typeof FilterPanelFactory>): ({ filters, datasets, layers, showDatasetTable, updateTableColor, visStateActions }: FilterManagerProps) => React.JSX.Element;
-declare namespace FilterManagerFactory {
-    var deps: (typeof SourceDataCatalogFactory | typeof FilterPanelFactory)[];
-}
-export default FilterManagerFactory;
+import React from 'react';
+import SourceDataCatalogFactory from './common/source-data-catalog';
+import FilterPanelFactory from './filter-panel/filter-panel';
+import { Datasets, Filter } from 'reducers';
+import { Layer } from 'layers';
+import * as VisStateActions from 'actions/vis-state-actions';
+import { ActionHandler } from 'actions';
+type FilterManagerProps = {
+    filters: Filter[];
+    datasets: Datasets;
+    layers: Layer[];
+    showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;
+    updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;
+    visStateActions: typeof VisStateActions;
+};
+declare function FilterManagerFactory(SourceDataCatalog: ReturnType<typeof SourceDataCatalogFactory>, FilterPanel: ReturnType<typeof FilterPanelFactory>): ({ filters, datasets, layers, showDatasetTable, updateTableColor, visStateActions }: FilterManagerProps) => React.JSX.Element;
+declare namespace FilterManagerFactory {
+    var deps: (typeof SourceDataCatalogFactory | typeof FilterPanelFactory)[];
+}
+export default FilterManagerFactory;

package/dist/components/side-panel/filter-manager.js

@@ -0,0 +1,113 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _react = _interopRequireWildcard(require("react"));
+var _localization = require("../../localization");
+var _styledComponents = require("../common/styled-components");
+var _icons = require("../common/icons");
+var _sourceDataCatalog = _interopRequireDefault(require("./common/source-data-catalog"));
+var _filterPanel = _interopRequireDefault(require("./filter-panel/filter-panel"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+// 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.
+
+FilterManagerFactory.deps = [_sourceDataCatalog["default"], _filterPanel["default"]];
+function FilterManagerFactory(SourceDataCatalog, FilterPanel) {
+  var FilterManager = function FilterManager(_ref) {
+    var _ref$filters = _ref.filters,
+      filters = _ref$filters === void 0 ? [] : _ref$filters,
+      datasets = _ref.datasets,
+      layers = _ref.layers,
+      showDatasetTable = _ref.showDatasetTable,
+      updateTableColor = _ref.updateTableColor,
+      visStateActions = _ref.visStateActions;
+    var addFilter = visStateActions.addFilter,
+      _enlargeFilter = visStateActions.enlargeFilter,
+      _removeFilter = visStateActions.removeFilter,
+      setFilter = visStateActions.setFilter,
+      toggleFilterAnimation = visStateActions.toggleFilterAnimation,
+      _toggleFilterFeature = visStateActions.toggleFilterFeature;
+    var isAnyFilterAnimating = filters.some(function (f) {
+      return f.isAnimating;
+    });
+    var hadEmptyFilter = filters.some(function (f) {
+      return !f.name;
+    });
+    var hadDataset = Object.keys(datasets).length;
+    var onClickAddFilter = (0, _react.useCallback)(function () {
+      var defaultDataset = Object.keys(datasets).length && Object.keys(datasets)[0] || null;
+      addFilter(defaultDataset);
+    }, [datasets, addFilter]);
+    // render last added filter first
+    var reversedIndex = (0, _react.useMemo)(function () {
+      return new Array(filters.length).fill(0).map(function (d, i) {
+        return i;
+      }).reverse();
+    }, [filters.length]);
+    return /*#__PURE__*/_react["default"].createElement("div", {
+      className: "filter-manager"
+    }, /*#__PURE__*/_react["default"].createElement(SourceDataCatalog, {
+      datasets: datasets,
+      showDatasetTable: showDatasetTable,
+      updateTableColor: updateTableColor
+    }), /*#__PURE__*/_react["default"].createElement(_styledComponents.SidePanelDivider, null), /*#__PURE__*/_react["default"].createElement(_styledComponents.SidePanelSection, null, reversedIndex.map(function (idx) {
+      return /*#__PURE__*/_react["default"].createElement(FilterPanel, {
+        key: "".concat(filters[idx].id, "-").concat(idx),
+        idx: idx,
+        filters: filters,
+        filter: filters[idx],
+        datasets: datasets,
+        layers: layers,
+        isAnyFilterAnimating: isAnyFilterAnimating,
+        removeFilter: function removeFilter() {
+          return _removeFilter(idx);
+        },
+        enlargeFilter: function enlargeFilter() {
+          return _enlargeFilter(idx);
+        },
+        toggleAnimation: function toggleAnimation() {
+          return toggleFilterAnimation(idx);
+        },
+        toggleFilterFeature: function toggleFilterFeature() {
+          return _toggleFilterFeature(idx);
+        },
+        setFilter: setFilter
+      });
+    })), /*#__PURE__*/_react["default"].createElement(_styledComponents.Button, {
+      className: "add-filter-button",
+      inactive: hadEmptyFilter || !hadDataset,
+      width: "105px",
+      onClick: onClickAddFilter
+    }, /*#__PURE__*/_react["default"].createElement(_icons.Add, {
+      height: "12px"
+    }), /*#__PURE__*/_react["default"].createElement(_localization.FormattedMessage, {
+      id: 'filterManager.addFilter'
+    })));
+  };
+  return FilterManager;
+}
+var _default = exports["default"] = FilterManagerFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_localization","_styledComponents","_icons","_sourceDataCatalog","_interopRequireDefault","_filterPanel","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","FilterManagerFactory","deps","SourceDataCatalogFactory","FilterPanelFactory","SourceDataCatalog","FilterPanel","FilterManager","_ref","_ref$filters","filters","datasets","layers","showDatasetTable","updateTableColor","visStateActions","addFilter","enlargeFilter","removeFilter","setFilter","toggleFilterAnimation","toggleFilterFeature","isAnyFilterAnimating","some","f","isAnimating","hadEmptyFilter","name","hadDataset","keys","length","onClickAddFilter","useCallback","defaultDataset","reversedIndex","useMemo","Array","fill","map","d","reverse","createElement","className","SidePanelDivider","SidePanelSection","idx","key","concat","id","filter","toggleAnimation","Button","inactive","width","onClick","Add","height","FormattedMessage","_default","exports"],"sources":["../../../src/components/side-panel/filter-manager.tsx"],"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, {useCallback, useMemo} from 'react';\nimport {FormattedMessage} from 'localization';\nimport {Button, SidePanelDivider, SidePanelSection} from 'components/common/styled-components';\nimport {Add} from 'components/common/icons';\nimport SourceDataCatalogFactory from './common/source-data-catalog';\nimport FilterPanelFactory from './filter-panel/filter-panel';\nimport {Datasets, Filter} from 'reducers';\nimport {Layer} from 'layers';\nimport * as VisStateActions from 'actions/vis-state-actions';\nimport {ActionHandler} from 'actions';\n\ntype FilterManagerProps = {\n  filters: Filter[];\n  datasets: Datasets;\n  layers: Layer[];\n  showDatasetTable: ActionHandler<typeof VisStateActions.showDatasetTable>;\n  updateTableColor: ActionHandler<typeof VisStateActions.updateTableColor>;\n  visStateActions: typeof VisStateActions;\n};\n\nFilterManagerFactory.deps = [SourceDataCatalogFactory, FilterPanelFactory];\n\nfunction FilterManagerFactory(\n  SourceDataCatalog: ReturnType<typeof SourceDataCatalogFactory>,\n  FilterPanel: ReturnType<typeof FilterPanelFactory>\n) {\n  const FilterManager = ({\n    filters = [],\n    datasets,\n    layers,\n    showDatasetTable,\n    updateTableColor,\n    visStateActions\n  }: FilterManagerProps) => {\n    const {\n      addFilter,\n      enlargeFilter,\n      removeFilter,\n      setFilter,\n      toggleFilterAnimation,\n      toggleFilterFeature\n    } = visStateActions;\n    const isAnyFilterAnimating = filters.some(f => f.isAnimating);\n    const hadEmptyFilter = filters.some(f => !f.name);\n    const hadDataset = Object.keys(datasets).length;\n    const onClickAddFilter = useCallback(() => {\n      const defaultDataset = (Object.keys(datasets).length && Object.keys(datasets)[0]) || null;\n      addFilter(defaultDataset);\n    }, [datasets, addFilter]);\n    // render last added filter first\n    const reversedIndex = useMemo(() => {\n      return new Array(filters.length)\n        .fill(0)\n        .map((d, i) => i)\n        .reverse();\n    }, [filters.length]);\n\n    return (\n      <div className=\"filter-manager\">\n        <SourceDataCatalog\n          datasets={datasets}\n          showDatasetTable={showDatasetTable}\n          updateTableColor={updateTableColor}\n        />\n        <SidePanelDivider />\n        <SidePanelSection>\n          {reversedIndex.map(idx => (\n            <FilterPanel\n              key={`${filters[idx].id}-${idx}`}\n              idx={idx}\n              filters={filters}\n              filter={filters[idx]}\n              datasets={datasets}\n              layers={layers}\n              isAnyFilterAnimating={isAnyFilterAnimating}\n              removeFilter={() => removeFilter(idx)}\n              enlargeFilter={() => enlargeFilter(idx)}\n              toggleAnimation={() => toggleFilterAnimation(idx)}\n              toggleFilterFeature={() => toggleFilterFeature(idx)}\n              setFilter={setFilter}\n            />\n          ))}\n        </SidePanelSection>\n        <Button\n          className=\"add-filter-button\"\n          inactive={hadEmptyFilter || !hadDataset}\n          width=\"105px\"\n          onClick={onClickAddFilter}\n        >\n          <Add height=\"12px\" />\n          <FormattedMessage id={'filterManager.addFilter'} />\n        </Button>\n      </div>\n    );\n  };\n\n  return FilterManager;\n}\n\nexport default FilterManagerFactory;\n"],"mappings":"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","ignoreList":[]}

package/dist/components/side-panel/filter-panel/filter-panel-header.d.ts

@@ -1,21 +1,21 @@
-import React, { ComponentType } from 'react';
-import PanelHeaderActionFactory from 'components/side-panel/panel-header-action';
-import { StyledPanelHeaderProps } from 'components/common/styled-components';
-import { Filter, RGBColor } from 'reducers';
-import KeplerTable from 'utils/table-utils/kepler-table';
-interface StyledFilterHeaderProps extends StyledPanelHeaderProps {
-    $labelRCGColorValues: RGBColor[];
-}
-export declare const StyledFilterHeader: import("styled-components").StyledComponent<"div", any, StyledPanelHeaderProps & StyledFilterHeaderProps, never>;
-type FilterPanelHeaderProps = {
-    children: React.ReactNode;
-    datasets: KeplerTable[];
-    filter: Filter;
-    removeFilter: () => void;
-    actionIcons?: Record<string, ComponentType>;
-};
-declare function FilterPanelHeaderFactory(PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>): React.ComponentType<FilterPanelHeaderProps>;
-declare namespace FilterPanelHeaderFactory {
-    var deps: (typeof PanelHeaderActionFactory)[];
-}
-export default FilterPanelHeaderFactory;
+import React, { ComponentType } from 'react';
+import PanelHeaderActionFactory from 'components/side-panel/panel-header-action';
+import { StyledPanelHeaderProps } from 'components/common/styled-components';
+import { Filter, RGBColor } from 'reducers';
+import KeplerTable from 'utils/table-utils/kepler-table';
+interface StyledFilterHeaderProps extends StyledPanelHeaderProps {
+    $labelRCGColorValues: RGBColor[];
+}
+export declare const StyledFilterHeader: import("styled-components").StyledComponent<"div", any, StyledPanelHeaderProps & StyledFilterHeaderProps, never>;
+type FilterPanelHeaderProps = {
+    children: React.ReactNode;
+    datasets: KeplerTable[];
+    filter: Filter;
+    removeFilter: () => void;
+    actionIcons?: Record<string, ComponentType>;
+};
+declare function FilterPanelHeaderFactory(PanelHeaderAction: ReturnType<typeof PanelHeaderActionFactory>): React.ComponentType<FilterPanelHeaderProps>;
+declare namespace FilterPanelHeaderFactory {
+    var deps: (typeof PanelHeaderActionFactory)[];
+}
+export default FilterPanelHeaderFactory;

package/dist/components/side-panel/filter-panel/filter-panel-header.js

@@ -0,0 +1,67 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = exports.StyledFilterHeader = void 0;
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _react = _interopRequireDefault(require("react"));
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+var _panelHeaderAction = _interopRequireDefault(require("../panel-header-action"));
+var _icons = require("../../common/icons");
+var _colorUtils = require("../../../utils/color-utils");
+var _styledComponents2 = require("../../common/styled-components");
+var _templateObject, _templateObject2; // 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.
+var StyledFilterHeader = exports.StyledFilterHeader = (0, _styledComponents["default"])(_styledComponents2.StyledPanelHeader)(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  cursor: pointer;\n  padding: 10px 12px;\n\n  .field-selector {\n    flex: 2;\n  }\n\n  border-left: 3px solid;\n  ", ";\n"])), function (props) {
+  return props.$labelRCGColorValues && props.$labelRCGColorValues.length > 0 ? "border-image: ".concat((0, _colorUtils.createLinearGradient)('bottom', props.$labelRCGColorValues), " 3;") : 'border-color: transparent;';
+});
+var StyledChildrenContainer = _styledComponents["default"].div(_templateObject2 || (_templateObject2 = (0, _taggedTemplateLiteral2["default"])(["\n  display: flex;\n  flex: 2;\n"])));
+FilterPanelHeaderFactory.deps = [_panelHeaderAction["default"]];
+function FilterPanelHeaderFactory(PanelHeaderAction) {
+  var defaultActionIcons = {
+    "delete": _icons.Trash
+  };
+  var FilterPanelHeader = function FilterPanelHeader(_ref) {
+    var children = _ref.children,
+      datasets = _ref.datasets,
+      filter = _ref.filter,
+      removeFilter = _ref.removeFilter,
+      _ref$actionIcons = _ref.actionIcons,
+      actionIcons = _ref$actionIcons === void 0 ? defaultActionIcons : _ref$actionIcons;
+    return /*#__PURE__*/_react["default"].createElement(StyledFilterHeader, {
+      className: "filter-panel__header",
+      $labelRCGColorValues: datasets.map(function (d) {
+        return d.color;
+      })
+    }, /*#__PURE__*/_react["default"].createElement(StyledChildrenContainer, null, children), /*#__PURE__*/_react["default"].createElement(PanelHeaderAction, {
+      id: filter.id,
+      tooltip: "tooltip.delete",
+      tooltipType: "error",
+      onClick: removeFilter,
+      hoverColor: 'errorColor',
+      IconComponent: actionIcons["delete"]
+    }));
+  };
+  return FilterPanelHeader;
+}
+var _default = exports["default"] = FilterPanelHeaderFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/components/side-panel/filter-panel/filter-panel.d.ts

@@ -1,23 +1,23 @@
-import React from 'react';
-import NewFilterPanelFactory from 'components/filters/filter-panels/new-filter-panel';
-import TimeRangeFilterPanelFactory from 'components/filters/filter-panels/time-range-filter-panel';
-import SingleSelectFilterPanelFactory from 'components/filters/filter-panels/single-select-filter-panel';
-import MultiSelectFilterPanelFactory from 'components/filters/filter-panels/multi-select-filter-panel';
-import RangeFilterPanelFactory from 'components/filters/filter-panels/range-filter-panel';
-import PolygonFilterPanelFactory from 'components/filters/filter-panels/polygon-filter-panel';
-import { Filter } from 'reducers/vis-state-updaters';
-import { FilterPanelProps } from 'components/filters/filter-panels/types';
-import { Layer } from 'layers';
-interface FilterPanelPropsImpl extends Omit<FilterPanelProps, 'allAvailableFields'> {
-    filters: Filter[];
-    layers: ReadonlyArray<Layer>;
-    isAnyFilterAnimating: boolean;
-    enlargeFilter: () => void;
-    toggleAnimation: () => void;
-    toggleFilterFeature: () => void;
-}
-declare function FilterPanelFactory(NewFilterPanel: ReturnType<typeof NewFilterPanelFactory>, TimeRangeFilterPanel: ReturnType<typeof TimeRangeFilterPanelFactory>, SingleSelectFilterPanel: ReturnType<typeof SingleSelectFilterPanelFactory>, MultiSelectFilterPanel: ReturnType<typeof MultiSelectFilterPanelFactory>, RangeFilterPanel: ReturnType<typeof RangeFilterPanelFactory>, PolygonFilterPanel: ReturnType<typeof PolygonFilterPanelFactory>): React.ComponentType<FilterPanelPropsImpl>;
-declare namespace FilterPanelFactory {
-    var deps: (typeof NewFilterPanelFactory | typeof TimeRangeFilterPanelFactory | typeof SingleSelectFilterPanelFactory | typeof MultiSelectFilterPanelFactory | typeof RangeFilterPanelFactory | typeof PolygonFilterPanelFactory)[];
-}
-export default FilterPanelFactory;
+import React from 'react';
+import NewFilterPanelFactory from 'components/filters/filter-panels/new-filter-panel';
+import TimeRangeFilterPanelFactory from 'components/filters/filter-panels/time-range-filter-panel';
+import SingleSelectFilterPanelFactory from 'components/filters/filter-panels/single-select-filter-panel';
+import MultiSelectFilterPanelFactory from 'components/filters/filter-panels/multi-select-filter-panel';
+import RangeFilterPanelFactory from 'components/filters/filter-panels/range-filter-panel';
+import PolygonFilterPanelFactory from 'components/filters/filter-panels/polygon-filter-panel';
+import { Filter } from 'reducers/vis-state-updaters';
+import { FilterPanelProps } from 'components/filters/filter-panels/types';
+import { Layer } from 'layers';
+interface FilterPanelPropsImpl extends Omit<FilterPanelProps, 'allAvailableFields'> {
+    filters: Filter[];
+    layers: ReadonlyArray<Layer>;
+    isAnyFilterAnimating: boolean;
+    enlargeFilter: () => void;
+    toggleAnimation: () => void;
+    toggleFilterFeature: () => void;
+}
+declare function FilterPanelFactory(NewFilterPanel: ReturnType<typeof NewFilterPanelFactory>, TimeRangeFilterPanel: ReturnType<typeof TimeRangeFilterPanelFactory>, SingleSelectFilterPanel: ReturnType<typeof SingleSelectFilterPanelFactory>, MultiSelectFilterPanel: ReturnType<typeof MultiSelectFilterPanelFactory>, RangeFilterPanel: ReturnType<typeof RangeFilterPanelFactory>, PolygonFilterPanel: ReturnType<typeof PolygonFilterPanelFactory>): React.ComponentType<FilterPanelPropsImpl>;
+declare namespace FilterPanelFactory {
+    var deps: (typeof NewFilterPanelFactory | typeof TimeRangeFilterPanelFactory | typeof SingleSelectFilterPanelFactory | typeof MultiSelectFilterPanelFactory | typeof RangeFilterPanelFactory | typeof PolygonFilterPanelFactory)[];
+}
+export default FilterPanelFactory;

package/dist/components/side-panel/filter-panel/filter-panel.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+var _react = _interopRequireWildcard(require("react"));
+var _reselect = require("reselect");
+var _styledComponents = _interopRequireDefault(require("styled-components"));
+var _lodash = _interopRequireDefault(require("lodash.get"));
+var _defaultSettings = require("../../../constants/default-settings");
+var _newFilterPanel = _interopRequireDefault(require("../../filters/filter-panels/new-filter-panel"));
+var _timeRangeFilterPanel = _interopRequireDefault(require("../../filters/filter-panels/time-range-filter-panel"));
+var _singleSelectFilterPanel = _interopRequireDefault(require("../../filters/filter-panels/single-select-filter-panel"));
+var _multiSelectFilterPanel = _interopRequireDefault(require("../../filters/filter-panels/multi-select-filter-panel"));
+var _rangeFilterPanel = _interopRequireDefault(require("../../filters/filter-panels/range-filter-panel"));
+var _polygonFilterPanel = _interopRequireDefault(require("../../filters/filter-panels/polygon-filter-panel"));
+var _templateObject; // 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.
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+var StyledFilterPanel = _styledComponents["default"].div(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["\n  margin-bottom: 12px;\n  border-radius: 1px;\n"])));
+FilterPanelFactory.deps = [_newFilterPanel["default"], _timeRangeFilterPanel["default"], _singleSelectFilterPanel["default"], _multiSelectFilterPanel["default"], _rangeFilterPanel["default"], _polygonFilterPanel["default"]];
+function FilterPanelFactory(NewFilterPanel, TimeRangeFilterPanel, SingleSelectFilterPanel, MultiSelectFilterPanel, RangeFilterPanel, PolygonFilterPanel) {
+  var FilterPanelComponents = (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({
+    "default": NewFilterPanel
+  }, _defaultSettings.FILTER_TYPES.timeRange, TimeRangeFilterPanel), _defaultSettings.FILTER_TYPES.select, SingleSelectFilterPanel), _defaultSettings.FILTER_TYPES.multiSelect, MultiSelectFilterPanel), _defaultSettings.FILTER_TYPES.range, RangeFilterPanel), _defaultSettings.FILTER_TYPES.polygon, PolygonFilterPanel);
+  return /*#__PURE__*/function (_Component) {
+    function FilterPanel() {
+      var _this;
+      (0, _classCallCheck2["default"])(this, FilterPanel);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _callSuper(this, FilterPanel, [].concat(args));
+      /* selectors */
+      (0, _defineProperty2["default"])(_this, "fieldsSelector", function (props) {
+        var datasetId = props.filter.dataId[0];
+        if (!datasetId) {
+          return [];
+        }
+        return (0, _lodash["default"])(props, ['datasets', datasetId, 'fields'], []);
+      });
+      (0, _defineProperty2["default"])(_this, "filterSelector", function (props) {
+        return props.filters;
+      });
+      (0, _defineProperty2["default"])(_this, "nameSelector", function (props) {
+        return props.filter.name;
+      });
+      (0, _defineProperty2["default"])(_this, "dataIdSelector", function (props) {
+        return props.filter.dataId[0];
+      });
+      // only show current field and field that's not already been used as a filter
+      (0, _defineProperty2["default"])(_this, "availableFieldsSelector", (0, _reselect.createSelector)(_this.fieldsSelector, _this.filterSelector, _this.nameSelector, _this.dataIdSelector, function (fields, filters, name, dataId) {
+        return fields.filter(function (f) {
+          return f.type && f.type !== _defaultSettings.ALL_FIELD_TYPES.geojson && (name.includes(f.name) || !filters.find(function (d) {
+            return d.name.includes(f.name) && d.dataId.includes(dataId);
+          }));
+        });
+      }));
+      return _this;
+    }
+    (0, _inherits2["default"])(FilterPanel, _Component);
+    return (0, _createClass2["default"])(FilterPanel, [{
+      key: "render",
+      value: function render() {
+        var filter = this.props.filter;
+        var type = filter.type;
+        var FilterFilterComponent = type && FilterPanelComponents[type] || FilterPanelComponents["default"];
+        var allAvailableFields = this.availableFieldsSelector(this.props);
+        return /*#__PURE__*/_react["default"].createElement(StyledFilterPanel, {
+          className: "filter-panel"
+        }, /*#__PURE__*/_react["default"].createElement(FilterFilterComponent, (0, _extends2["default"])({
+          allAvailableFields: allAvailableFields
+        }, this.props)));
+      }
+    }]);
+  }(_react.Component);
+}
+var _default = exports["default"] = FilterPanelFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireWildcard","require","_reselect","_styledComponents","_interopRequireDefault","_lodash","_defaultSettings","_newFilterPanel","_timeRangeFilterPanel","_singleSelectFilterPanel","_multiSelectFilterPanel","_rangeFilterPanel","_polygonFilterPanel","_templateObject","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","_callSuper","o","_getPrototypeOf2","_possibleConstructorReturn2","_isNativeReflectConstruct","Reflect","construct","constructor","apply","Boolean","prototype","valueOf","StyledFilterPanel","styled","div","_taggedTemplateLiteral2","FilterPanelFactory","deps","NewFilterPanelFactory","TimeRangeFilterPanelFactory","SingleSelectFilterPanelFactory","MultiSelectFilterPanelFactory","RangeFilterPanelFactory","PolygonFilterPanelFactory","NewFilterPanel","TimeRangeFilterPanel","SingleSelectFilterPanel","MultiSelectFilterPanel","RangeFilterPanel","PolygonFilterPanel","FilterPanelComponents","_defineProperty2","FILTER_TYPES","timeRange","select","multiSelect","range","polygon","_Component","FilterPanel","_this","_classCallCheck2","_len","arguments","length","args","Array","_key","concat","props","datasetId","filter","dataId","filters","name","createSelector","fieldsSelector","filterSelector","nameSelector","dataIdSelector","fields","f","type","ALL_FIELD_TYPES","geojson","includes","find","d","_inherits2","_createClass2","key","value","render","FilterFilterComponent","allAvailableFields","availableFieldsSelector","createElement","className","_extends2","Component","_default","exports"],"sources":["../../../../src/components/side-panel/filter-panel/filter-panel.tsx"],"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 {createSelector} from 'reselect';\nimport styled from 'styled-components';\nimport get from 'lodash.get';\nimport {ALL_FIELD_TYPES, FILTER_TYPES} from 'constants/default-settings';\n\nimport NewFilterPanelFactory from 'components/filters/filter-panels/new-filter-panel';\nimport TimeRangeFilterPanelFactory from 'components/filters/filter-panels/time-range-filter-panel';\nimport SingleSelectFilterPanelFactory from 'components/filters/filter-panels/single-select-filter-panel';\nimport MultiSelectFilterPanelFactory from 'components/filters/filter-panels/multi-select-filter-panel';\nimport RangeFilterPanelFactory from 'components/filters/filter-panels/range-filter-panel';\nimport PolygonFilterPanelFactory from 'components/filters/filter-panels/polygon-filter-panel';\nimport {Filter} from 'reducers/vis-state-updaters';\nimport {Field} from 'utils/table-utils/kepler-table';\nimport {FilterPanelProps} from 'components/filters/filter-panels/types';\nimport {Layer} from 'layers';\n\nconst StyledFilterPanel = styled.div`\n  margin-bottom: 12px;\n  border-radius: 1px;\n`;\n\ninterface FilterPanelPropsImpl extends Omit<FilterPanelProps, 'allAvailableFields'> {\n  filters: Filter[];\n  layers: ReadonlyArray<Layer>;\n  isAnyFilterAnimating: boolean;\n  enlargeFilter: () => void;\n  toggleAnimation: () => void;\n  toggleFilterFeature: () => void;\n}\n\nFilterPanelFactory.deps = [\n  NewFilterPanelFactory,\n  TimeRangeFilterPanelFactory,\n  SingleSelectFilterPanelFactory,\n  MultiSelectFilterPanelFactory,\n  RangeFilterPanelFactory,\n  PolygonFilterPanelFactory\n];\n\nfunction FilterPanelFactory(\n  NewFilterPanel: ReturnType<typeof NewFilterPanelFactory>,\n  TimeRangeFilterPanel: ReturnType<typeof TimeRangeFilterPanelFactory>,\n  SingleSelectFilterPanel: ReturnType<typeof SingleSelectFilterPanelFactory>,\n  MultiSelectFilterPanel: ReturnType<typeof MultiSelectFilterPanelFactory>,\n  RangeFilterPanel: ReturnType<typeof RangeFilterPanelFactory>,\n  PolygonFilterPanel: ReturnType<typeof PolygonFilterPanelFactory>\n): React.ComponentType<FilterPanelPropsImpl> {\n  const FilterPanelComponents = {\n    default: NewFilterPanel,\n    [FILTER_TYPES.timeRange]: TimeRangeFilterPanel,\n    [FILTER_TYPES.select]: SingleSelectFilterPanel,\n    [FILTER_TYPES.multiSelect]: MultiSelectFilterPanel,\n    [FILTER_TYPES.range]: RangeFilterPanel,\n    [FILTER_TYPES.polygon]: PolygonFilterPanel\n  };\n\n  return class FilterPanel extends Component<FilterPanelPropsImpl> {\n    /* selectors */\n    fieldsSelector = (props: FilterPanelPropsImpl) => {\n      const datasetId = props.filter.dataId[0];\n      if (!datasetId) {\n        return [];\n      }\n      return get(props, ['datasets', datasetId, 'fields'], []);\n    };\n\n    filterSelector = (props: FilterPanelPropsImpl) => props.filters;\n    nameSelector = (props: FilterPanelPropsImpl) => props.filter.name;\n    dataIdSelector = (props: FilterPanelPropsImpl) => props.filter.dataId[0];\n\n    // only show current field and field that's not already been used as a filter\n    availableFieldsSelector = createSelector(\n      this.fieldsSelector,\n      this.filterSelector,\n      this.nameSelector,\n      this.dataIdSelector,\n      (fields, filters, name, dataId) =>\n        fields.filter(\n          (f: Field) =>\n            f.type &&\n            f.type !== ALL_FIELD_TYPES.geojson &&\n            (name.includes(f.name) ||\n              !filters.find(d => d.name.includes(f.name) && d.dataId.includes(dataId)))\n        )\n    );\n\n    render() {\n      const {filter} = this.props;\n\n      const {type} = filter;\n      const FilterFilterComponent =\n        (type && FilterPanelComponents[type]) || FilterPanelComponents.default;\n      const allAvailableFields = this.availableFieldsSelector(this.props);\n\n      return (\n        <StyledFilterPanel className=\"filter-panel\">\n          <FilterFilterComponent allAvailableFields={allAvailableFields} {...this.props} />\n        </StyledFilterPanel>\n      );\n    }\n  };\n}\n\nexport default FilterPanelFactory;\n"],"mappings":"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","ignoreList":[]}

package/dist/components/side-panel/interaction-manager.d.ts

@@ -1,14 +1,14 @@
-import React from 'react';
-import { Datasets, InteractionConfig } from 'reducers';
-import InteractionPanelFactory from './interaction-panel/interaction-panel';
-import * as VisStateActions from 'actions/vis-state-actions';
-type InteractionManagerProps = {
-    interactionConfig: InteractionConfig;
-    datasets: Datasets;
-    visStateActions: typeof VisStateActions;
-};
-declare function InteractionManagerFactory(InteractionPanel: ReturnType<typeof InteractionPanelFactory>): ({ interactionConfig, datasets, visStateActions }: InteractionManagerProps) => React.JSX.Element;
-declare namespace InteractionManagerFactory {
-    var deps: (typeof InteractionPanelFactory)[];
-}
-export default InteractionManagerFactory;
+import React from 'react';
+import { Datasets, InteractionConfig } from 'reducers';
+import InteractionPanelFactory from './interaction-panel/interaction-panel';
+import * as VisStateActions from 'actions/vis-state-actions';
+type InteractionManagerProps = {
+    interactionConfig: InteractionConfig;
+    datasets: Datasets;
+    visStateActions: typeof VisStateActions;
+};
+declare function InteractionManagerFactory(InteractionPanel: ReturnType<typeof InteractionPanelFactory>): ({ interactionConfig, datasets, visStateActions }: InteractionManagerProps) => React.JSX.Element;
+declare namespace InteractionManagerFactory {
+    var deps: (typeof InteractionPanelFactory)[];
+}
+export default InteractionManagerFactory;