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

package/dist/esm/remote-dataset-refresh-controller.js

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import { useEffect, useMemo } from 'react';
+import { DatasetType, getDatasetRefreshIntervalMs } from '@kepler.gl/constants';
+/**
+ * Polls remotely hosted datasets that have metadata.refreshIntervalMs set.
+ * Lives on KeplerGl so polling continues when the side panel is closed.
+ */
+export default function RemoteDatasetRefreshController(_ref) {
+  var datasets = _ref.datasets,
+    refreshDataset = _ref.refreshDataset;
+  var pollTargets = useMemo(function () {
+    return Object.values(datasets).filter(function (dataset) {
+      return dataset.type === DatasetType.EXTERNALLY_HOSTED && getDatasetRefreshIntervalMs(dataset.metadata) > 0;
+    }).map(function (dataset) {
+      return {
+        id: dataset.id,
+        intervalMs: getDatasetRefreshIntervalMs(dataset.metadata)
+      };
+    });
+  }, [datasets]);
+  var pollKey = JSON.stringify(pollTargets.slice().sort(function (a, b) {
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  }));
+  useEffect(function () {
+    var targets = JSON.parse(pollKey);
+    if (!refreshDataset || !targets.length) {
+      return undefined;
+    }
+    var timers = targets.map(function (target) {
+      return window.setInterval(function () {
+        return refreshDataset(target.id);
+      }, target.intervalMs);
+    });
+    return function () {
+      timers.forEach(function (timer) {
+        return window.clearInterval(timer);
+      });
+    };
+  }, [pollKey, refreshDataset]);
+  return null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/side-panel/add-by-dataset-button.js

@@ -0,0 +1,121 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useMemo, useState } from 'react';
+import styled from 'styled-components';
+import { FormattedMessage } from '@kepler.gl/localization';
+import Tippy from '@tippyjs/react';
+import { Add } from '../common/icons';
+import { Button, DatasetSquare } from '../common/styled-components';
+import Typeahead from '../common/item-selector/typeahead';
+import Accessor from '../common/item-selector/accessor';
+import { useIntl } from 'react-intl';
+import { RootContext } from '../context';
+var DropdownContainer = styled.div.attrs({
+  className: 'add-layer-menu-dropdown'
+})(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  .list-selector {\n    border-top: 1px solid ", ";\n    width: 100%;\n    /* disable scrolling, currently set to 280px internally */\n    max-height: unset;\n  }\n  .list__item > div {\n    display: flex;\n    flex-direction: row;\n    justify-content: flex-start;\n    line-height: 18px;\n    padding: 0;\n    svg {\n      margin-right: 10px;\n    }\n  }\n"])), function (props) {
+  return props.theme.secondaryInputBorderColor;
+});
+var DropdownMenu = styled.div.attrs({
+  className: 'dropdown-menu'
+})(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  display: flex;\n  flex-direction: column;\n  min-width: 240px;\n  max-width: 240px;\n  position: absolute;\n  top: 100%;\n  left: -120px;\n  z-index: 5;\n"])));
+var ListItemWrapper = styled.div.attrs({
+  className: 'dropdown-menu-list-item-wrapper'
+})(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  display: flex;\n  color: ", ";\n  font-size: 11px;\n  letter-spacing: 0.2px;\n  overflow: auto;\n  .dataset-color {\n    flex-shrink: 0;\n    margin-top: 3px;\n  }\n  .dataset-name {\n    white-space: nowrap;\n    overflow: hidden;\n    text-overflow: ellipsis;\n  }\n"])), function (props) {
+  return props.theme.textColor;
+});
+var TYPEAHEAD_CLASS = 'typeahead';
+var TYPEAHEAD_INPUT_CLASS = 'typeahead__input';
+var ListItem = function ListItem(_ref) {
+  var value = _ref.value;
+  return /*#__PURE__*/React.createElement(ListItemWrapper, null, /*#__PURE__*/React.createElement(DatasetSquare, {
+    className: "dataset-color",
+    backgroundColor: value.color
+  }), /*#__PURE__*/React.createElement("div", {
+    className: "dataset-name",
+    title: value.label
+  }, value.label));
+};
+var AddByDatasetButton = function AddByDatasetButton(_ref2) {
+  var datasets = _ref2.datasets,
+    onAdd = _ref2.onAdd,
+    buttonIntlId = _ref2.buttonIntlId,
+    className = _ref2.className,
+    inactive = _ref2.inactive;
+  var _useState = useState(),
+    _useState2 = _slicedToArray(_useState, 2),
+    tippyInstance = _useState2[0],
+    setTippyInstance = _useState2[1];
+  var options = useMemo(function () {
+    return Object.values(datasets).map(function (ds) {
+      return {
+        label: ds.label,
+        value: ds.id,
+        color: ds.color
+      };
+    });
+  }, [datasets]);
+  var onClickBtn = useCallback(function () {
+    if (options.length === 1) {
+      onAdd(options[0].value);
+    }
+    return;
+  }, [options, onAdd]);
+  var onOptionSelected = useCallback(function (option) {
+    if (!option) {
+      return;
+    }
+    onAdd(option.value);
+    if (tippyInstance) {
+      // @ts-ignore
+      tippyInstance.hide();
+    }
+  }, [onAdd, tippyInstance]);
+  var intl = useIntl();
+  var buttonRendered = /*#__PURE__*/React.createElement(Button, {
+    tabIndex: -1,
+    className: className || 'add-by-dataset-button',
+    onClick: onClickBtn,
+    disabled: !options.length || inactive
+  }, /*#__PURE__*/React.createElement(Add, {
+    height: "12px"
+  }), /*#__PURE__*/React.createElement(FormattedMessage, {
+    id: buttonIntlId
+  }));
+  return options.length === 1 ? buttonRendered : /*#__PURE__*/React.createElement(RootContext.Consumer, null, function (context) {
+    return /*#__PURE__*/React.createElement(Tippy, {
+      trigger: "click",
+      arrow: false,
+      interactive: true,
+      placement: "left-end",
+      appendTo: (context === null || context === void 0 ? void 0 : context.current) || 'parent'
+      // @ts-ignore
+      ,
+      onCreate: setTippyInstance,
+      duration: 0,
+      content: /*#__PURE__*/React.createElement(DropdownMenu, null, /*#__PURE__*/React.createElement(DropdownContainer, null, /*#__PURE__*/React.createElement(Typeahead, {
+        className: TYPEAHEAD_CLASS,
+        customClasses: {
+          results: 'list-selector',
+          input: TYPEAHEAD_INPUT_CLASS,
+          listItem: 'list__item'
+        },
+        placeholder: intl ? intl.formatMessage({
+          id: 'placeholder.search'
+        }) : 'Search',
+        selectedItems: null,
+        options: options,
+        displayOption: Accessor.generateOptionToStringFor('label'),
+        filterOption: 'label',
+        searchable: true,
+        onOptionSelected: onOptionSelected,
+        customListItemComponent: ListItem
+      })))
+    }, buttonRendered);
+  });
+};
+export default AddByDatasetButton;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useMemo","useState","styled","FormattedMessage","Tippy","Add","Button","DatasetSquare","Typeahead","Accessor","useIntl","RootContext","DropdownContainer","div","attrs","className","_templateObject","_taggedTemplateLiteral","props","theme","secondaryInputBorderColor","DropdownMenu","_templateObject2","ListItemWrapper","_templateObject3","textColor","TYPEAHEAD_CLASS","TYPEAHEAD_INPUT_CLASS","ListItem","_ref","value","createElement","backgroundColor","color","title","label","AddByDatasetButton","_ref2","datasets","onAdd","buttonIntlId","inactive","_useState","_useState2","_slicedToArray","tippyInstance","setTippyInstance","options","Object","values","map","ds","id","onClickBtn","length","onOptionSelected","option","hide","intl","buttonRendered","tabIndex","onClick","disabled","height","Consumer","context","trigger","arrow","interactive","placement","appendTo","current","onCreate","duration","content","customClasses","results","input","listItem","placeholder","formatMessage","selectedItems","displayOption","generateOptionToStringFor","filterOption","searchable","customListItemComponent"],"sources":["../../../src/side-panel/add-by-dataset-button.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useMemo, useState} from 'react';\nimport styled from 'styled-components';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {Datasets, KeplerTable} from '@kepler.gl/table';\n\nimport Tippy from '@tippyjs/react';\nimport {Add} from '../common/icons';\nimport {Button, DatasetSquare} from '../common/styled-components';\nimport Typeahead from '../common/item-selector/typeahead';\nimport Accessor from '../common/item-selector/accessor';\nimport {useIntl} from 'react-intl';\nimport {RootContext} from '../context';\n\nconst DropdownContainer = styled.div.attrs({\n  className: 'add-layer-menu-dropdown'\n})`\n  .list-selector {\n    border-top: 1px solid ${props => props.theme.secondaryInputBorderColor};\n    width: 100%;\n    /* disable scrolling, currently set to 280px internally */\n    max-height: unset;\n  }\n  .list__item > div {\n    display: flex;\n    flex-direction: row;\n    justify-content: flex-start;\n    line-height: 18px;\n    padding: 0;\n    svg {\n      margin-right: 10px;\n    }\n  }\n`;\n\nconst DropdownMenu = styled.div.attrs({\n  className: 'dropdown-menu'\n})`\n  display: flex;\n  flex-direction: column;\n  min-width: 240px;\n  max-width: 240px;\n  position: absolute;\n  top: 100%;\n  left: -120px;\n  z-index: 5;\n`;\n\nconst ListItemWrapper = styled.div.attrs({\n  className: 'dropdown-menu-list-item-wrapper'\n})`\n  display: flex;\n  color: ${props => props.theme.textColor};\n  font-size: 11px;\n  letter-spacing: 0.2px;\n  overflow: auto;\n  .dataset-color {\n    flex-shrink: 0;\n    margin-top: 3px;\n  }\n  .dataset-name {\n    white-space: nowrap;\n    overflow: hidden;\n    text-overflow: ellipsis;\n  }\n`;\n\nconst TYPEAHEAD_CLASS = 'typeahead';\nconst TYPEAHEAD_INPUT_CLASS = 'typeahead__input';\n\nexport type AddByDatasetButtonProps = {\n  datasets: Datasets;\n  onAdd: (dataId: string) => void;\n  buttonIntlId: string;\n  inactive?: boolean;\n  className?: string;\n};\n\nconst ListItem = ({value}) => (\n  <ListItemWrapper>\n    <DatasetSquare className=\"dataset-color\" backgroundColor={value.color} />\n    <div className=\"dataset-name\" title={value.label}>\n      {value.label}\n    </div>\n  </ListItemWrapper>\n);\n\nconst AddByDatasetButton: React.FC<AddByDatasetButtonProps> = ({\n  datasets,\n  onAdd,\n  buttonIntlId,\n  className,\n  inactive\n}) => {\n  const [tippyInstance, setTippyInstance] = useState();\n\n  const options = useMemo(() => {\n    return Object.values(datasets).map((ds: KeplerTable) => ({\n      label: ds.label,\n      value: ds.id,\n      color: ds.color\n    }));\n  }, [datasets]);\n\n  const onClickBtn = useCallback(() => {\n    if (options.length === 1) {\n      onAdd(options[0].value);\n    }\n\n    return;\n  }, [options, onAdd]);\n\n  const onOptionSelected = useCallback(\n    option => {\n      if (!option) {\n        return;\n      }\n      onAdd(option.value);\n      if (tippyInstance) {\n        // @ts-ignore\n        tippyInstance.hide();\n      }\n    },\n    [onAdd, tippyInstance]\n  );\n\n  const intl = useIntl();\n\n  const buttonRendered = (\n    <Button\n      tabIndex={-1}\n      className={className || 'add-by-dataset-button'}\n      onClick={onClickBtn}\n      disabled={!options.length || inactive}\n    >\n      <Add height=\"12px\" />\n      <FormattedMessage id={buttonIntlId} />\n    </Button>\n  );\n\n  return options.length === 1 ? (\n    buttonRendered\n  ) : (\n    <RootContext.Consumer>\n      {context => (\n        <Tippy\n          trigger=\"click\"\n          arrow={false}\n          interactive\n          placement=\"left-end\"\n          appendTo={context?.current || 'parent'}\n          // @ts-ignore\n          onCreate={setTippyInstance}\n          duration={0}\n          content={\n            <DropdownMenu>\n              <DropdownContainer>\n                <Typeahead\n                  className={TYPEAHEAD_CLASS}\n                  customClasses={{\n                    results: 'list-selector',\n                    input: TYPEAHEAD_INPUT_CLASS,\n                    listItem: 'list__item'\n                  }}\n                  placeholder={intl ? intl.formatMessage({id: 'placeholder.search'}) : 'Search'}\n                  selectedItems={null}\n                  options={options}\n                  displayOption={Accessor.generateOptionToStringFor('label')}\n                  filterOption={'label'}\n                  searchable\n                  onOptionSelected={onOptionSelected}\n                  customListItemComponent={ListItem}\n                />\n              </DropdownContainer>\n            </DropdownMenu>\n          }\n        >\n          {buttonRendered}\n        </Tippy>\n      )}\n    </RootContext.Consumer>\n  );\n};\n\nexport default AddByDatasetButton;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/side-panel/common/dataset-info.js

@@ -0,0 +1,206 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useCallback, useEffect, useState } from 'react';
+import styled from 'styled-components';
+import { format } from 'd3-format';
+import { useIntl } from 'react-intl';
+import { DatasetType, DATASET_REFRESH_CUSTOM_VALUE, DATASET_REFRESH_DEFAULT_CUSTOM_MS, DATASET_REFRESH_INTERVAL_OPTIONS, DATASET_REFRESH_MIN_INTERVAL_MS, formatCustomRefreshSeconds, getDatasetRefreshIntervalMs, isPresetDatasetRefreshInterval, parseCustomRefreshIntervalMs } from '@kepler.gl/constants';
+import { FormattedMessage } from '@kepler.gl/localization';
+import { Reset } from '../../common/icons';
+import { Tooltip } from '../../common/styled-components';
+import DatasetRefreshProgressIcon from './dataset-refresh-progress';
+var numFormat = format(',');
+var StyledDataRowCount = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  font-size: 11px;\n  color: ", ";\n  padding-left: 19px;\n  display: flex;\n  align-items: center;\n  gap: 8px;\n  flex-wrap: wrap;\n"])), function (props) {
+  return props.theme.subtextColor;
+});
+var StyledRefreshing = styled.span(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  display: inline-flex;\n  align-items: center;\n  gap: 4px;\n  color: ", ";\n"])), function (props) {
+  return props.theme.inputColor;
+});
+var StyledRefreshSettings = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  display: inline-flex;\n  align-items: center;\n  gap: 8px;\n  flex-wrap: wrap;\n"])));
+var StyledRefreshLabel = styled.label(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  display: inline-flex;\n  align-items: center;\n  gap: 4px;\n  margin: 0;\n"])));
+var StyledRefreshSelect = styled.select(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  ", ";\n  height: 18px;\n  font-size: 11px;\n  padding: 0 4px;\n  width: auto;\n  max-width: 96px;\n  cursor: pointer;\n  background-color: transparent;\n"])), function (props) {
+  return props.theme.input;
+});
+var StyledCustomSeconds = styled.input(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["\n  ", ";\n  height: 18px;\n  font-size: 11px;\n  padding: 0 4px;\n  width: 52px;\n  background-color: transparent;\n"])), function (props) {
+  return props.theme.input;
+});
+var StyledCustomUnit = styled.span(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["\n  font-size: 11px;\n"])));
+var StyledRefreshNow = styled.button(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["\n  display: inline-flex;\n  align-items: center;\n  justify-content: center;\n  margin: 0;\n  padding: 0;\n  border: 0;\n  background: transparent;\n  color: ", ";\n  cursor: pointer;\n  width: 14px;\n  height: 14px;\n\n  &:disabled {\n    cursor: default;\n    opacity: 0.5;\n  }\n\n  &:hover:not(:disabled) {\n    color: ", ";\n  }\n"])), function (props) {
+  return props.theme.subtextColor;
+}, function (props) {
+  return props.theme.textColorHl;
+});
+export default function DatasetInfoFactory() {
+  var DatasetInfo = function DatasetInfo(_ref) {
+    var _dataset$metadata, _dataset$metadata2, _dataset$metadata3;
+    var dataset = _ref.dataset,
+      showRefreshSettings = _ref.showRefreshSettings,
+      refreshDataset = _ref.refreshDataset,
+      updateDatasetProps = _ref.updateDatasetProps;
+    var intl = useIntl();
+    var isRemote = dataset.type === DatasetType.EXTERNALLY_HOSTED;
+    var intervalMs = getDatasetRefreshIntervalMs(dataset.metadata);
+    var matchingOption = DATASET_REFRESH_INTERVAL_OPTIONS.find(function (option) {
+      return option.value === intervalMs;
+    });
+    var isCustomInterval = intervalMs > 0 && !isPresetDatasetRefreshInterval(intervalMs);
+    var _useState = useState(isCustomInterval),
+      _useState2 = _slicedToArray(_useState, 2),
+      customMode = _useState2[0],
+      setCustomMode = _useState2[1];
+    var _useState3 = useState(function () {
+        return formatCustomRefreshSeconds(intervalMs || DATASET_REFRESH_DEFAULT_CUSTOM_MS);
+      }),
+      _useState4 = _slicedToArray(_useState3, 2),
+      customSeconds = _useState4[0],
+      setCustomSeconds = _useState4[1];
+    var showCustomInput = customMode || isCustomInterval;
+    var selectValue = showCustomInput ? DATASET_REFRESH_CUSTOM_VALUE : String(matchingOption ? matchingOption.value : 0);
+    useEffect(function () {
+      var ms = getDatasetRefreshIntervalMs(dataset.metadata);
+      var custom = ms > 0 && !isPresetDatasetRefreshInterval(ms);
+      setCustomMode(custom);
+      setCustomSeconds(formatCustomRefreshSeconds(ms || DATASET_REFRESH_DEFAULT_CUSTOM_MS));
+    }, [dataset.id, (_dataset$metadata = dataset.metadata) === null || _dataset$metadata === void 0 ? void 0 : _dataset$metadata.refreshIntervalMs]);
+    var spinning = ((_dataset$metadata2 = dataset.metadata) === null || _dataset$metadata2 === void 0 ? void 0 : _dataset$metadata2.refreshStatus) === 'loading';
+    var progress = typeof ((_dataset$metadata3 = dataset.metadata) === null || _dataset$metadata3 === void 0 ? void 0 : _dataset$metadata3.refreshProgress) === 'number' ? dataset.metadata.refreshProgress : undefined;
+    var showPercent = spinning && typeof progress === 'number' && progress > 0 && progress < 100;
+    var showRefreshControls = Boolean(showRefreshSettings && isRemote && (refreshDataset || updateDatasetProps));
+    var onRefreshNow = useCallback(function (event) {
+      event.stopPropagation();
+      if (!spinning) {
+        refreshDataset === null || refreshDataset === void 0 || refreshDataset(dataset.id);
+      }
+    }, [dataset.id, refreshDataset, spinning]);
+    var commitCustomInterval = useCallback(function (secondsText) {
+      var nextMs = parseCustomRefreshIntervalMs(secondsText);
+      if (nextMs == null) {
+        setCustomSeconds(formatCustomRefreshSeconds(intervalMs || DATASET_REFRESH_DEFAULT_CUSTOM_MS));
+        return;
+      }
+      setCustomSeconds(formatCustomRefreshSeconds(nextMs));
+      if (nextMs !== intervalMs) {
+        updateDatasetProps === null || updateDatasetProps === void 0 || updateDatasetProps(dataset.id, {
+          metadata: {
+            refreshIntervalMs: nextMs
+          }
+        });
+      }
+    }, [dataset.id, intervalMs, updateDatasetProps]);
+    var onRefreshIntervalChange = useCallback(function (event) {
+      event.stopPropagation();
+      var value = event.target.value;
+      if (value === DATASET_REFRESH_CUSTOM_VALUE) {
+        var secondsText = formatCustomRefreshSeconds(intervalMs || DATASET_REFRESH_DEFAULT_CUSTOM_MS);
+        var nextMs = parseCustomRefreshIntervalMs(secondsText);
+        setCustomMode(true);
+        setCustomSeconds(secondsText);
+        if (!intervalMs && nextMs != null) {
+          updateDatasetProps === null || updateDatasetProps === void 0 || updateDatasetProps(dataset.id, {
+            metadata: {
+              refreshIntervalMs: nextMs
+            }
+          });
+        }
+        return;
+      }
+      setCustomMode(false);
+      updateDatasetProps === null || updateDatasetProps === void 0 || updateDatasetProps(dataset.id, {
+        metadata: {
+          refreshIntervalMs: Number(value) || 0
+        }
+      });
+    }, [dataset.id, intervalMs, updateDatasetProps]);
+    return /*#__PURE__*/React.createElement(StyledDataRowCount, {
+      className: "source-data-rows",
+      "aria-busy": spinning
+    }, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: dataset.type === DatasetType.VECTOR_TILE ? 'datasetInfo.vectorTile' : dataset.type === DatasetType.RASTER_TILE ? 'datasetInfo.rasterTile' : dataset.type === DatasetType.WMS_TILE ? 'datasetInfo.wmsTile' : dataset.type === DatasetType.TILE_3D ? 'datasetInfo.tile3d' : dataset.type === DatasetType.BITMAP ? 'datasetInfo.bitmap' : isRemote ? 'datasetInfo.remoteFile' : 'datasetInfo.rowCount',
+      values: {
+        rowCount: numFormat(dataset.dataContainer.numRows())
+      }
+    }), spinning ? /*#__PURE__*/React.createElement(StyledRefreshing, {
+      className: "dataset-refresh-status"
+    }, /*#__PURE__*/React.createElement(DatasetRefreshProgressIcon, {
+      percent: progress,
+      size: 12
+    }), /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: showPercent ? 'datasetInfo.refreshingPercent' : 'datasetInfo.refreshing',
+      values: {
+        percent: Math.round(progress !== null && progress !== void 0 ? progress : 0)
+      }
+    })) : null, showRefreshControls ? /*#__PURE__*/React.createElement(StyledRefreshSettings, {
+      className: "dataset-refresh-settings",
+      onClick: function onClick(event) {
+        return event.stopPropagation();
+      }
+    }, updateDatasetProps ? /*#__PURE__*/React.createElement(StyledRefreshLabel, null, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: "datasetInfo.refreshInterval"
+    }), /*#__PURE__*/React.createElement(StyledRefreshSelect, {
+      "aria-label": intl.formatMessage({
+        id: 'datasetInfo.refreshInterval'
+      }),
+      value: selectValue,
+      onChange: onRefreshIntervalChange
+    }, DATASET_REFRESH_INTERVAL_OPTIONS.map(function (option) {
+      return /*#__PURE__*/React.createElement("option", {
+        key: option.value,
+        value: String(option.value)
+      }, intl.formatMessage({
+        id: option.labelId
+      }));
+    }), /*#__PURE__*/React.createElement("option", {
+      value: DATASET_REFRESH_CUSTOM_VALUE
+    }, intl.formatMessage({
+      id: 'datasetTitle.refreshCustom'
+    }))), showCustomInput ? /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(StyledCustomSeconds, {
+      type: "number",
+      min: DATASET_REFRESH_MIN_INTERVAL_MS / 1000,
+      step: 0.1,
+      inputMode: "decimal",
+      className: "dataset-refresh-custom-seconds",
+      "aria-label": intl.formatMessage({
+        id: 'datasetInfo.refreshCustomSeconds'
+      }),
+      value: customSeconds,
+      onChange: function onChange(event) {
+        event.stopPropagation();
+        setCustomSeconds(event.target.value);
+      },
+      onBlur: function onBlur(event) {
+        return commitCustomInterval(event.target.value);
+      },
+      onKeyDown: function onKeyDown(event) {
+        event.stopPropagation();
+        if (event.key === 'Enter') {
+          event.preventDefault();
+          commitCustomInterval(customSeconds);
+          event.target.blur();
+        }
+      }
+    }), /*#__PURE__*/React.createElement(StyledCustomUnit, null, "s")) : null) : null, refreshDataset ? /*#__PURE__*/React.createElement(StyledRefreshNow, {
+      type: "button",
+      className: "dataset-refresh-now",
+      "aria-label": intl.formatMessage({
+        id: 'datasetTitle.refreshDataset'
+      }),
+      "data-tip": true,
+      "data-for": "refresh-now-".concat(dataset.id),
+      disabled: spinning,
+      onClick: onRefreshNow
+    }, /*#__PURE__*/React.createElement(Reset, {
+      height: "14px"
+    }), /*#__PURE__*/React.createElement(Tooltip, {
+      id: "refresh-now-".concat(dataset.id),
+      effect: "solid"
+    }, /*#__PURE__*/React.createElement("span", null, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: 'datasetTitle.refreshDataset'
+    })))) : null) : null);
+  };
+  return DatasetInfo;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useEffect","useState","styled","format","useIntl","DatasetType","DATASET_REFRESH_CUSTOM_VALUE","DATASET_REFRESH_DEFAULT_CUSTOM_MS","DATASET_REFRESH_INTERVAL_OPTIONS","DATASET_REFRESH_MIN_INTERVAL_MS","formatCustomRefreshSeconds","getDatasetRefreshIntervalMs","isPresetDatasetRefreshInterval","parseCustomRefreshIntervalMs","FormattedMessage","Reset","Tooltip","DatasetRefreshProgressIcon","numFormat","StyledDataRowCount","div","_templateObject","_taggedTemplateLiteral","props","theme","subtextColor","StyledRefreshing","span","_templateObject2","inputColor","StyledRefreshSettings","_templateObject3","StyledRefreshLabel","label","_templateObject4","StyledRefreshSelect","select","_templateObject5","input","StyledCustomSeconds","_templateObject6","StyledCustomUnit","_templateObject7","StyledRefreshNow","button","_templateObject8","textColorHl","DatasetInfoFactory","DatasetInfo","_ref","_dataset$metadata","_dataset$metadata2","_dataset$metadata3","dataset","showRefreshSettings","refreshDataset","updateDatasetProps","intl","isRemote","type","EXTERNALLY_HOSTED","intervalMs","metadata","matchingOption","find","option","value","isCustomInterval","_useState","_useState2","_slicedToArray","customMode","setCustomMode","_useState3","_useState4","customSeconds","setCustomSeconds","showCustomInput","selectValue","String","ms","custom","id","refreshIntervalMs","spinning","refreshStatus","progress","refreshProgress","undefined","showPercent","showRefreshControls","Boolean","onRefreshNow","event","stopPropagation","commitCustomInterval","secondsText","nextMs","onRefreshIntervalChange","target","Number","createElement","className","VECTOR_TILE","RASTER_TILE","WMS_TILE","TILE_3D","BITMAP","values","rowCount","dataContainer","numRows","percent","size","Math","round","onClick","formatMessage","onChange","map","key","labelId","Fragment","min","step","inputMode","onBlur","onKeyDown","preventDefault","blur","concat","disabled","height","effect"],"sources":["../../../../src/side-panel/common/dataset-info.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useEffect, useState} from 'react';\nimport styled from 'styled-components';\nimport {format} from 'd3-format';\nimport {useIntl} from 'react-intl';\n\nimport {\n  DatasetType,\n  DATASET_REFRESH_CUSTOM_VALUE,\n  DATASET_REFRESH_DEFAULT_CUSTOM_MS,\n  DATASET_REFRESH_INTERVAL_OPTIONS,\n  DATASET_REFRESH_MIN_INTERVAL_MS,\n  formatCustomRefreshSeconds,\n  getDatasetRefreshIntervalMs,\n  isPresetDatasetRefreshInterval,\n  parseCustomRefreshIntervalMs\n} from '@kepler.gl/constants';\nimport {FormattedMessage} from '@kepler.gl/localization';\nimport {DataContainerInterface} from '@kepler.gl/utils';\nimport {VisStateActions, ActionHandler} from '@kepler.gl/actions';\nimport {Reset} from '../../common/icons';\nimport {Tooltip} from '../../common/styled-components';\nimport DatasetRefreshProgressIcon from './dataset-refresh-progress';\n\nconst numFormat = format(',');\n\ntype MiniDataset = {\n  id: string;\n  dataContainer: DataContainerInterface;\n  type?: string;\n  metadata?: {\n    refreshIntervalMs?: number;\n    refreshStatus?: string;\n    refreshProgress?: number;\n  };\n};\n\nexport type DatasetInfoProps = {\n  dataset: MiniDataset;\n  showRefreshSettings?: boolean;\n  refreshDataset?: ActionHandler<typeof VisStateActions.refreshDataset>;\n  updateDatasetProps?: ActionHandler<typeof VisStateActions.updateDatasetProps>;\n};\n\nconst StyledDataRowCount = styled.div`\n  font-size: 11px;\n  color: ${props => props.theme.subtextColor};\n  padding-left: 19px;\n  display: flex;\n  align-items: center;\n  gap: 8px;\n  flex-wrap: wrap;\n`;\n\nconst StyledRefreshing = styled.span`\n  display: inline-flex;\n  align-items: center;\n  gap: 4px;\n  color: ${props => props.theme.inputColor};\n`;\n\nconst StyledRefreshSettings = styled.div`\n  display: inline-flex;\n  align-items: center;\n  gap: 8px;\n  flex-wrap: wrap;\n`;\n\nconst StyledRefreshLabel = styled.label`\n  display: inline-flex;\n  align-items: center;\n  gap: 4px;\n  margin: 0;\n`;\n\nconst StyledRefreshSelect = styled.select`\n  ${props => props.theme.input};\n  height: 18px;\n  font-size: 11px;\n  padding: 0 4px;\n  width: auto;\n  max-width: 96px;\n  cursor: pointer;\n  background-color: transparent;\n`;\n\nconst StyledCustomSeconds = styled.input`\n  ${props => props.theme.input};\n  height: 18px;\n  font-size: 11px;\n  padding: 0 4px;\n  width: 52px;\n  background-color: transparent;\n`;\n\nconst StyledCustomUnit = styled.span`\n  font-size: 11px;\n`;\n\nconst StyledRefreshNow = styled.button`\n  display: inline-flex;\n  align-items: center;\n  justify-content: center;\n  margin: 0;\n  padding: 0;\n  border: 0;\n  background: transparent;\n  color: ${props => props.theme.subtextColor};\n  cursor: pointer;\n  width: 14px;\n  height: 14px;\n\n  &:disabled {\n    cursor: default;\n    opacity: 0.5;\n  }\n\n  &:hover:not(:disabled) {\n    color: ${props => props.theme.textColorHl};\n  }\n`;\n\nexport default function DatasetInfoFactory() {\n  const DatasetInfo: React.FC<DatasetInfoProps> = ({\n    dataset,\n    showRefreshSettings,\n    refreshDataset,\n    updateDatasetProps\n  }) => {\n    const intl = useIntl();\n    const isRemote = dataset.type === DatasetType.EXTERNALLY_HOSTED;\n    const intervalMs = getDatasetRefreshIntervalMs(dataset.metadata);\n    const matchingOption = DATASET_REFRESH_INTERVAL_OPTIONS.find(\n      option => option.value === intervalMs\n    );\n    const isCustomInterval = intervalMs > 0 && !isPresetDatasetRefreshInterval(intervalMs);\n    const [customMode, setCustomMode] = useState(isCustomInterval);\n    const [customSeconds, setCustomSeconds] = useState(() =>\n      formatCustomRefreshSeconds(intervalMs || DATASET_REFRESH_DEFAULT_CUSTOM_MS)\n    );\n    const showCustomInput = customMode || isCustomInterval;\n    const selectValue = showCustomInput\n      ? DATASET_REFRESH_CUSTOM_VALUE\n      : String(matchingOption ? matchingOption.value : 0);\n\n    useEffect(() => {\n      const ms = getDatasetRefreshIntervalMs(dataset.metadata);\n      const custom = ms > 0 && !isPresetDatasetRefreshInterval(ms);\n      setCustomMode(custom);\n      setCustomSeconds(formatCustomRefreshSeconds(ms || DATASET_REFRESH_DEFAULT_CUSTOM_MS));\n    }, [dataset.id, dataset.metadata?.refreshIntervalMs]);\n\n    const spinning = dataset.metadata?.refreshStatus === 'loading';\n    const progress =\n      typeof dataset.metadata?.refreshProgress === 'number'\n        ? dataset.metadata.refreshProgress\n        : undefined;\n    const showPercent = spinning && typeof progress === 'number' && progress > 0 && progress < 100;\n    const showRefreshControls = Boolean(\n      showRefreshSettings && isRemote && (refreshDataset || updateDatasetProps)\n    );\n\n    const onRefreshNow = useCallback(\n      (event: React.MouseEvent) => {\n        event.stopPropagation();\n        if (!spinning) {\n          refreshDataset?.(dataset.id);\n        }\n      },\n      [dataset.id, refreshDataset, spinning]\n    );\n\n    const commitCustomInterval = useCallback(\n      (secondsText: string) => {\n        const nextMs = parseCustomRefreshIntervalMs(secondsText);\n        if (nextMs == null) {\n          setCustomSeconds(\n            formatCustomRefreshSeconds(intervalMs || DATASET_REFRESH_DEFAULT_CUSTOM_MS)\n          );\n          return;\n        }\n        setCustomSeconds(formatCustomRefreshSeconds(nextMs));\n        if (nextMs !== intervalMs) {\n          updateDatasetProps?.(dataset.id, {metadata: {refreshIntervalMs: nextMs}});\n        }\n      },\n      [dataset.id, intervalMs, updateDatasetProps]\n    );\n\n    const onRefreshIntervalChange = useCallback(\n      (event: React.ChangeEvent<HTMLSelectElement>) => {\n        event.stopPropagation();\n        const value = event.target.value;\n        if (value === DATASET_REFRESH_CUSTOM_VALUE) {\n          const secondsText = formatCustomRefreshSeconds(\n            intervalMs || DATASET_REFRESH_DEFAULT_CUSTOM_MS\n          );\n          const nextMs = parseCustomRefreshIntervalMs(secondsText);\n          setCustomMode(true);\n          setCustomSeconds(secondsText);\n          if (!intervalMs && nextMs != null) {\n            updateDatasetProps?.(dataset.id, {\n              metadata: {refreshIntervalMs: nextMs}\n            });\n          }\n          return;\n        }\n        setCustomMode(false);\n        updateDatasetProps?.(dataset.id, {\n          metadata: {refreshIntervalMs: Number(value) || 0}\n        });\n      },\n      [dataset.id, intervalMs, updateDatasetProps]\n    );\n\n    return (\n      <StyledDataRowCount className=\"source-data-rows\" aria-busy={spinning}>\n        <FormattedMessage\n          id={\n            dataset.type === DatasetType.VECTOR_TILE\n              ? 'datasetInfo.vectorTile'\n              : dataset.type === DatasetType.RASTER_TILE\n              ? 'datasetInfo.rasterTile'\n              : dataset.type === DatasetType.WMS_TILE\n              ? 'datasetInfo.wmsTile'\n              : dataset.type === DatasetType.TILE_3D\n              ? 'datasetInfo.tile3d'\n              : dataset.type === DatasetType.BITMAP\n              ? 'datasetInfo.bitmap'\n              : isRemote\n              ? 'datasetInfo.remoteFile'\n              : 'datasetInfo.rowCount'\n          }\n          values={{rowCount: numFormat(dataset.dataContainer.numRows())}}\n        />\n        {spinning ? (\n          <StyledRefreshing className=\"dataset-refresh-status\">\n            <DatasetRefreshProgressIcon percent={progress} size={12} />\n            <FormattedMessage\n              id={showPercent ? 'datasetInfo.refreshingPercent' : 'datasetInfo.refreshing'}\n              values={{percent: Math.round(progress ?? 0)}}\n            />\n          </StyledRefreshing>\n        ) : null}\n        {showRefreshControls ? (\n          <StyledRefreshSettings\n            className=\"dataset-refresh-settings\"\n            onClick={event => event.stopPropagation()}\n          >\n            {updateDatasetProps ? (\n              <StyledRefreshLabel>\n                <FormattedMessage id=\"datasetInfo.refreshInterval\" />\n                <StyledRefreshSelect\n                  aria-label={intl.formatMessage({id: 'datasetInfo.refreshInterval'})}\n                  value={selectValue}\n                  onChange={onRefreshIntervalChange}\n                >\n                  {DATASET_REFRESH_INTERVAL_OPTIONS.map(option => (\n                    <option key={option.value} value={String(option.value)}>\n                      {intl.formatMessage({id: option.labelId})}\n                    </option>\n                  ))}\n                  <option value={DATASET_REFRESH_CUSTOM_VALUE}>\n                    {intl.formatMessage({id: 'datasetTitle.refreshCustom'})}\n                  </option>\n                </StyledRefreshSelect>\n                {showCustomInput ? (\n                  <>\n                    <StyledCustomSeconds\n                      type=\"number\"\n                      min={DATASET_REFRESH_MIN_INTERVAL_MS / 1000}\n                      step={0.1}\n                      inputMode=\"decimal\"\n                      className=\"dataset-refresh-custom-seconds\"\n                      aria-label={intl.formatMessage({id: 'datasetInfo.refreshCustomSeconds'})}\n                      value={customSeconds}\n                      onChange={event => {\n                        event.stopPropagation();\n                        setCustomSeconds(event.target.value);\n                      }}\n                      onBlur={event => commitCustomInterval(event.target.value)}\n                      onKeyDown={event => {\n                        event.stopPropagation();\n                        if (event.key === 'Enter') {\n                          event.preventDefault();\n                          commitCustomInterval(customSeconds);\n                          (event.target as HTMLInputElement).blur();\n                        }\n                      }}\n                    />\n                    <StyledCustomUnit>s</StyledCustomUnit>\n                  </>\n                ) : null}\n              </StyledRefreshLabel>\n            ) : null}\n            {refreshDataset ? (\n              <StyledRefreshNow\n                type=\"button\"\n                className=\"dataset-refresh-now\"\n                aria-label={intl.formatMessage({id: 'datasetTitle.refreshDataset'})}\n                data-tip\n                data-for={`refresh-now-${dataset.id}`}\n                disabled={spinning}\n                onClick={onRefreshNow}\n              >\n                <Reset height=\"14px\" />\n                <Tooltip id={`refresh-now-${dataset.id}`} effect=\"solid\">\n                  <span>\n                    <FormattedMessage id={'datasetTitle.refreshDataset'} />\n                  </span>\n                </Tooltip>\n              </StyledRefreshNow>\n            ) : null}\n          </StyledRefreshSettings>\n        ) : null}\n      </StyledDataRowCount>\n    );\n  };\n\n  return DatasetInfo;\n}\n"],"mappings":";;;AAAA;AACA;;AAEA,OAAOA,KAAK,IAAGC,WAAW,EAAEC,SAAS,EAAEC,QAAQ,QAAO,OAAO;AAC7D,OAAOC,MAAM,MAAM,mBAAmB;AACtC,SAAQC,MAAM,QAAO,WAAW;AAChC,SAAQC,OAAO,QAAO,YAAY;AAElC,SACEC,WAAW,EACXC,4BAA4B,EAC5BC,iCAAiC,EACjCC,gCAAgC,EAChCC,+BAA+B,EAC/BC,0BAA0B,EAC1BC,2BAA2B,EAC3BC,8BAA8B,EAC9BC,4BAA4B,QACvB,sBAAsB;AAC7B,SAAQC,gBAAgB,QAAO,yBAAyB;AAGxD,SAAQC,KAAK,QAAO,oBAAoB;AACxC,SAAQC,OAAO,QAAO,gCAAgC;AACtD,OAAOC,0BAA0B,MAAM,4BAA4B;AAEnE,IAAMC,SAAS,GAAGf,MAAM,CAAC,GAAG,CAAC;AAoB7B,IAAMgB,kBAAkB,GAAGjB,MAAM,CAACkB,GAAG,CAAAC,eAAA,KAAAA,eAAA,GAAAC,sBAAA,iJAE1B,UAAAC,KAAK;EAAA,OAAIA,KAAK,CAACC,KAAK,CAACC,YAAY;AAAA,EAM3C;AAED,IAAMC,gBAAgB,GAAGxB,MAAM,CAACyB,IAAI,CAAAC,gBAAA,KAAAA,gBAAA,GAAAN,sBAAA,yFAIzB,UAAAC,KAAK;EAAA,OAAIA,KAAK,CAACC,KAAK,CAACK,UAAU;AAAA,EACzC;AAED,IAAMC,qBAAqB,GAAG5B,MAAM,CAACkB,GAAG,CAAAW,gBAAA,KAAAA,gBAAA,GAAAT,sBAAA,4FAKvC;AAED,IAAMU,kBAAkB,GAAG9B,MAAM,CAAC+B,KAAK,CAAAC,gBAAA,KAAAA,gBAAA,GAAAZ,sBAAA,sFAKtC;AAED,IAAMa,mBAAmB,GAAGjC,MAAM,CAACkC,MAAM,CAAAC,gBAAA,KAAAA,gBAAA,GAAAf,sBAAA,sKACrC,UAAAC,KAAK;EAAA,OAAIA,KAAK,CAACC,KAAK,CAACc,KAAK;AAAA,EAQ7B;AAED,IAAMC,mBAAmB,GAAGrC,MAAM,CAACoC,KAAK,CAAAE,gBAAA,KAAAA,gBAAA,GAAAlB,sBAAA,8HACpC,UAAAC,KAAK;EAAA,OAAIA,KAAK,CAACC,KAAK,CAACc,KAAK;AAAA,EAM7B;AAED,IAAMG,gBAAgB,GAAGvC,MAAM,CAACyB,IAAI,CAAAe,gBAAA,KAAAA,gBAAA,GAAApB,sBAAA,8BAEnC;AAED,IAAMqB,gBAAgB,GAAGzC,MAAM,CAAC0C,MAAM,CAAAC,gBAAA,KAAAA,gBAAA,GAAAvB,sBAAA,yVAQ3B,UAAAC,KAAK;EAAA,OAAIA,KAAK,CAACC,KAAK,CAACC,YAAY;AAAA,GAW/B,UAAAF,KAAK;EAAA,OAAIA,KAAK,CAACC,KAAK,CAACsB,WAAW;AAAA,EAE5C;AAED,eAAe,SAASC,kBAAkBA,CAAA,EAAG;EAC3C,IAAMC,WAAuC,GAAG,SAA1CA,WAAuCA,CAAAC,IAAA,EAKvC;IAAA,IAAAC,iBAAA,EAAAC,kBAAA,EAAAC,kBAAA;IAAA,IAJJC,OAAO,GAAAJ,IAAA,CAAPI,OAAO;MACPC,mBAAmB,GAAAL,IAAA,CAAnBK,mBAAmB;MACnBC,cAAc,GAAAN,IAAA,CAAdM,cAAc;MACdC,kBAAkB,GAAAP,IAAA,CAAlBO,kBAAkB;IAElB,IAAMC,IAAI,GAAGrD,OAAO,CAAC,CAAC;IACtB,IAAMsD,QAAQ,GAAGL,OAAO,CAACM,IAAI,KAAKtD,WAAW,CAACuD,iBAAiB;IAC/D,IAAMC,UAAU,GAAGlD,2BAA2B,CAAC0C,OAAO,CAACS,QAAQ,CAAC;IAChE,IAAMC,cAAc,GAAGvD,gCAAgC,CAACwD,IAAI,CAC1D,UAAAC,MAAM;MAAA,OAAIA,MAAM,CAACC,KAAK,KAAKL,UAAU;IAAA,CACvC,CAAC;IACD,IAAMM,gBAAgB,GAAGN,UAAU,GAAG,CAAC,IAAI,CAACjD,8BAA8B,CAACiD,UAAU,CAAC;IACtF,IAAAO,SAAA,GAAoCnE,QAAQ,CAACkE,gBAAgB,CAAC;MAAAE,UAAA,GAAAC,cAAA,CAAAF,SAAA;MAAvDG,UAAU,GAAAF,UAAA;MAAEG,aAAa,GAAAH,UAAA;IAChC,IAAAI,UAAA,GAA0CxE,QAAQ,CAAC;QAAA,OACjDS,0BAA0B,CAACmD,UAAU,IAAItD,iCAAiC,CAAC;MAAA,CAC7E,CAAC;MAAAmE,UAAA,GAAAJ,cAAA,CAAAG,UAAA;MAFME,aAAa,GAAAD,UAAA;MAAEE,gBAAgB,GAAAF,UAAA;IAGtC,IAAMG,eAAe,GAAGN,UAAU,IAAIJ,gBAAgB;IACtD,IAAMW,WAAW,GAAGD,eAAe,GAC/BvE,4BAA4B,GAC5ByE,MAAM,CAAChB,cAAc,GAAGA,cAAc,CAACG,KAAK,GAAG,CAAC,CAAC;IAErDlE,SAAS,CAAC,YAAM;MACd,IAAMgF,EAAE,GAAGrE,2BAA2B,CAAC0C,OAAO,CAACS,QAAQ,CAAC;MACxD,IAAMmB,MAAM,GAAGD,EAAE,GAAG,CAAC,IAAI,CAACpE,8BAA8B,CAACoE,EAAE,CAAC;MAC5DR,aAAa,CAACS,MAAM,CAAC;MACrBL,gBAAgB,CAAClE,0BAA0B,CAACsE,EAAE,IAAIzE,iCAAiC,CAAC,CAAC;IACvF,CAAC,EAAE,CAAC8C,OAAO,CAAC6B,EAAE,GAAAhC,iBAAA,GAAEG,OAAO,CAACS,QAAQ,cAAAZ,iBAAA,uBAAhBA,iBAAA,CAAkBiC,iBAAiB,CAAC,CAAC;IAErD,IAAMC,QAAQ,GAAG,EAAAjC,kBAAA,GAAAE,OAAO,CAACS,QAAQ,cAAAX,kBAAA,uBAAhBA,kBAAA,CAAkBkC,aAAa,MAAK,SAAS;IAC9D,IAAMC,QAAQ,GACZ,SAAAlC,kBAAA,GAAOC,OAAO,CAACS,QAAQ,cAAAV,kBAAA,uBAAhBA,kBAAA,CAAkBmC,eAAe,MAAK,QAAQ,GACjDlC,OAAO,CAACS,QAAQ,CAACyB,eAAe,GAChCC,SAAS;IACf,IAAMC,WAAW,GAAGL,QAAQ,IAAI,OAAOE,QAAQ,KAAK,QAAQ,IAAIA,QAAQ,GAAG,CAAC,IAAIA,QAAQ,GAAG,GAAG;IAC9F,IAAMI,mBAAmB,GAAGC,OAAO,CACjCrC,mBAAmB,IAAII,QAAQ,KAAKH,cAAc,IAAIC,kBAAkB,CAC1E,CAAC;IAED,IAAMoC,YAAY,GAAG7F,WAAW,CAC9B,UAAC8F,KAAuB,EAAK;MAC3BA,KAAK,CAACC,eAAe,CAAC,CAAC;MACvB,IAAI,CAACV,QAAQ,EAAE;QACb7B,cAAc,aAAdA,cAAc,eAAdA,cAAc,CAAGF,OAAO,CAAC6B,EAAE,CAAC;MAC9B;IACF,CAAC,EACD,CAAC7B,OAAO,CAAC6B,EAAE,EAAE3B,cAAc,EAAE6B,QAAQ,CACvC,CAAC;IAED,IAAMW,oBAAoB,GAAGhG,WAAW,CACtC,UAACiG,WAAmB,EAAK;MACvB,IAAMC,MAAM,GAAGpF,4BAA4B,CAACmF,WAAW,CAAC;MACxD,IAAIC,MAAM,IAAI,IAAI,EAAE;QAClBrB,gBAAgB,CACdlE,0BAA0B,CAACmD,UAAU,IAAItD,iCAAiC,CAC5E,CAAC;QACD;MACF;MACAqE,gBAAgB,CAAClE,0BAA0B,CAACuF,MAAM,CAAC,CAAC;MACpD,IAAIA,MAAM,KAAKpC,UAAU,EAAE;QACzBL,kBAAkB,aAAlBA,kBAAkB,eAAlBA,kBAAkB,CAAGH,OAAO,CAAC6B,EAAE,EAAE;UAACpB,QAAQ,EAAE;YAACqB,iBAAiB,EAAEc;UAAM;QAAC,CAAC,CAAC;MAC3E;IACF,CAAC,EACD,CAAC5C,OAAO,CAAC6B,EAAE,EAAErB,UAAU,EAAEL,kBAAkB,CAC7C,CAAC;IAED,IAAM0C,uBAAuB,GAAGnG,WAAW,CACzC,UAAC8F,KAA2C,EAAK;MAC/CA,KAAK,CAACC,eAAe,CAAC,CAAC;MACvB,IAAM5B,KAAK,GAAG2B,KAAK,CAACM,MAAM,CAACjC,KAAK;MAChC,IAAIA,KAAK,KAAK5D,4BAA4B,EAAE;QAC1C,IAAM0F,WAAW,GAAGtF,0BAA0B,CAC5CmD,UAAU,IAAItD,iCAChB,CAAC;QACD,IAAM0F,MAAM,GAAGpF,4BAA4B,CAACmF,WAAW,CAAC;QACxDxB,aAAa,CAAC,IAAI,CAAC;QACnBI,gBAAgB,CAACoB,WAAW,CAAC;QAC7B,IAAI,CAACnC,UAAU,IAAIoC,MAAM,IAAI,IAAI,EAAE;UACjCzC,kBAAkB,aAAlBA,kBAAkB,eAAlBA,kBAAkB,CAAGH,OAAO,CAAC6B,EAAE,EAAE;YAC/BpB,QAAQ,EAAE;cAACqB,iBAAiB,EAAEc;YAAM;UACtC,CAAC,CAAC;QACJ;QACA;MACF;MACAzB,aAAa,CAAC,KAAK,CAAC;MACpBhB,kBAAkB,aAAlBA,kBAAkB,eAAlBA,kBAAkB,CAAGH,OAAO,CAAC6B,EAAE,EAAE;QAC/BpB,QAAQ,EAAE;UAACqB,iBAAiB,EAAEiB,MAAM,CAAClC,KAAK,CAAC,IAAI;QAAC;MAClD,CAAC,CAAC;IACJ,CAAC,EACD,CAACb,OAAO,CAAC6B,EAAE,EAAErB,UAAU,EAAEL,kBAAkB,CAC7C,CAAC;IAED,oBACE1D,KAAA,CAAAuG,aAAA,CAAClF,kBAAkB;MAACmF,SAAS,EAAC,kBAAkB;MAAC,aAAWlB;IAAS,gBACnEtF,KAAA,CAAAuG,aAAA,CAACvF,gBAAgB;MACfoE,EAAE,EACA7B,OAAO,CAACM,IAAI,KAAKtD,WAAW,CAACkG,WAAW,GACpC,wBAAwB,GACxBlD,OAAO,CAACM,IAAI,KAAKtD,WAAW,CAACmG,WAAW,GACxC,wBAAwB,GACxBnD,OAAO,CAACM,IAAI,KAAKtD,WAAW,CAACoG,QAAQ,GACrC,qBAAqB,GACrBpD,OAAO,CAACM,IAAI,KAAKtD,WAAW,CAACqG,OAAO,GACpC,oBAAoB,GACpBrD,OAAO,CAACM,IAAI,KAAKtD,WAAW,CAACsG,MAAM,GACnC,oBAAoB,GACpBjD,QAAQ,GACR,wBAAwB,GACxB,sBACL;MACDkD,MAAM,EAAE;QAACC,QAAQ,EAAE3F,SAAS,CAACmC,OAAO,CAACyD,aAAa,CAACC,OAAO,CAAC,CAAC;MAAC;IAAE,CAChE,CAAC,EACD3B,QAAQ,gBACPtF,KAAA,CAAAuG,aAAA,CAAC3E,gBAAgB;MAAC4E,SAAS,EAAC;IAAwB,gBAClDxG,KAAA,CAAAuG,aAAA,CAACpF,0BAA0B;MAAC+F,OAAO,EAAE1B,QAAS;MAAC2B,IAAI,EAAE;IAAG,CAAE,CAAC,eAC3DnH,KAAA,CAAAuG,aAAA,CAACvF,gBAAgB;MACfoE,EAAE,EAAEO,WAAW,GAAG,+BAA+B,GAAG,wBAAyB;MAC7EmB,MAAM,EAAE;QAACI,OAAO,EAAEE,IAAI,CAACC,KAAK,CAAC7B,QAAQ,aAARA,QAAQ,cAARA,QAAQ,GAAI,CAAC;MAAC;IAAE,CAC9C,CACe,CAAC,GACjB,IAAI,EACPI,mBAAmB,gBAClB5F,KAAA,CAAAuG,aAAA,CAACvE,qBAAqB;MACpBwE,SAAS,EAAC,0BAA0B;MACpCc,OAAO,EAAE,SAATA,OAAOA,CAAEvB,KAAK;QAAA,OAAIA,KAAK,CAACC,eAAe,CAAC,CAAC;MAAA;IAAC,GAEzCtC,kBAAkB,gBACjB1D,KAAA,CAAAuG,aAAA,CAACrE,kBAAkB,qBACjBlC,KAAA,CAAAuG,aAAA,CAACvF,gBAAgB;MAACoE,EAAE,EAAC;IAA6B,CAAE,CAAC,eACrDpF,KAAA,CAAAuG,aAAA,CAAClE,mBAAmB;MAClB,cAAYsB,IAAI,CAAC4D,aAAa,CAAC;QAACnC,EAAE,EAAE;MAA6B,CAAC,CAAE;MACpEhB,KAAK,EAAEY,WAAY;MACnBwC,QAAQ,EAAEpB;IAAwB,GAEjC1F,gCAAgC,CAAC+G,GAAG,CAAC,UAAAtD,MAAM;MAAA,oBAC1CnE,KAAA,CAAAuG,aAAA;QAAQmB,GAAG,EAAEvD,MAAM,CAACC,KAAM;QAACA,KAAK,EAAEa,MAAM,CAACd,MAAM,CAACC,KAAK;MAAE,GACpDT,IAAI,CAAC4D,aAAa,CAAC;QAACnC,EAAE,EAAEjB,MAAM,CAACwD;MAAO,CAAC,CAClC,CAAC;IAAA,CACV,CAAC,eACF3H,KAAA,CAAAuG,aAAA;MAAQnC,KAAK,EAAE5D;IAA6B,GACzCmD,IAAI,CAAC4D,aAAa,CAAC;MAACnC,EAAE,EAAE;IAA4B,CAAC,CAChD,CACW,CAAC,EACrBL,eAAe,gBACd/E,KAAA,CAAAuG,aAAA,CAAAvG,KAAA,CAAA4H,QAAA,qBACE5H,KAAA,CAAAuG,aAAA,CAAC9D,mBAAmB;MAClBoB,IAAI,EAAC,QAAQ;MACbgE,GAAG,EAAElH,+BAA+B,GAAG,IAAK;MAC5CmH,IAAI,EAAE,GAAI;MACVC,SAAS,EAAC,SAAS;MACnBvB,SAAS,EAAC,gCAAgC;MAC1C,cAAY7C,IAAI,CAAC4D,aAAa,CAAC;QAACnC,EAAE,EAAE;MAAkC,CAAC,CAAE;MACzEhB,KAAK,EAAES,aAAc;MACrB2C,QAAQ,EAAE,SAAVA,QAAQA,CAAEzB,KAAK,EAAI;QACjBA,KAAK,CAACC,eAAe,CAAC,CAAC;QACvBlB,gBAAgB,CAACiB,KAAK,CAACM,MAAM,CAACjC,KAAK,CAAC;MACtC,CAAE;MACF4D,MAAM,EAAE,SAARA,MAAMA,CAAEjC,KAAK;QAAA,OAAIE,oBAAoB,CAACF,KAAK,CAACM,MAAM,CAACjC,KAAK,CAAC;MAAA,CAAC;MAC1D6D,SAAS,EAAE,SAAXA,SAASA,CAAElC,KAAK,EAAI;QAClBA,KAAK,CAACC,eAAe,CAAC,CAAC;QACvB,IAAID,KAAK,CAAC2B,GAAG,KAAK,OAAO,EAAE;UACzB3B,KAAK,CAACmC,cAAc,CAAC,CAAC;UACtBjC,oBAAoB,CAACpB,aAAa,CAAC;UAClCkB,KAAK,CAACM,MAAM,CAAsB8B,IAAI,CAAC,CAAC;QAC3C;MACF;IAAE,CACH,CAAC,eACFnI,KAAA,CAAAuG,aAAA,CAAC5D,gBAAgB,QAAC,GAAmB,CACrC,CAAC,GACD,IACc,CAAC,GACnB,IAAI,EACPc,cAAc,gBACbzD,KAAA,CAAAuG,aAAA,CAAC1D,gBAAgB;MACfgB,IAAI,EAAC,QAAQ;MACb2C,SAAS,EAAC,qBAAqB;MAC/B,cAAY7C,IAAI,CAAC4D,aAAa,CAAC;QAACnC,EAAE,EAAE;MAA6B,CAAC,CAAE;MACpE,gBAAQ;MACR,2BAAAgD,MAAA,CAAyB7E,OAAO,CAAC6B,EAAE,CAAG;MACtCiD,QAAQ,EAAE/C,QAAS;MACnBgC,OAAO,EAAExB;IAAa,gBAEtB9F,KAAA,CAAAuG,aAAA,CAACtF,KAAK;MAACqH,MAAM,EAAC;IAAM,CAAE,CAAC,eACvBtI,KAAA,CAAAuG,aAAA,CAACrF,OAAO;MAACkE,EAAE,iBAAAgD,MAAA,CAAiB7E,OAAO,CAAC6B,EAAE,CAAG;MAACmD,MAAM,EAAC;IAAO,gBACtDvI,KAAA,CAAAuG,aAAA,4BACEvG,KAAA,CAAAuG,aAAA,CAACvF,gBAAgB;MAACoE,EAAE,EAAE;IAA8B,CAAE,CAClD,CACC,CACO,CAAC,GACjB,IACiB,CAAC,GACtB,IACc,CAAC;EAEzB,CAAC;EAED,OAAOlC,WAAW;AACpB","ignoreList":[]}

package/dist/esm/side-panel/common/dataset-refresh-progress.js

@@ -0,0 +1,56 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import styled, { css, keyframes } from 'styled-components';
+var spin = keyframes(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  to {\n    transform: rotate(360deg);\n  }\n"])));
+var StyledProgress = styled.svg(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  display: block;\n  flex-shrink: 0;\n  ", "\n"])), function (props) {
+  return props.$indeterminate && css(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n      animation: ", " 0.8s linear infinite;\n    "])), spin);
+});
+/**
+ * Circular refresh indicator: spinning arc while size is unknown, filling ring
+ * when Content-Length is available.
+ */
+export default function DatasetRefreshProgressIcon(_ref) {
+  var percent = _ref.percent,
+    _ref$size = _ref.size,
+    size = _ref$size === void 0 ? 14 : _ref$size;
+  var strokeWidth = 2;
+  var radius = (size - strokeWidth) / 2;
+  var circumference = 2 * Math.PI * radius;
+  var determinate = typeof percent === 'number' && percent > 0;
+  var clamped = determinate ? Math.max(0, Math.min(100, percent)) : 0;
+  var dashOffset = determinate ? circumference * (1 - clamped / 100) : circumference * 0.75;
+  return /*#__PURE__*/React.createElement(StyledProgress, {
+    $indeterminate: !determinate,
+    width: size,
+    height: size,
+    viewBox: "0 0 ".concat(size, " ").concat(size),
+    role: "progressbar",
+    "aria-valuemin": 0,
+    "aria-valuemax": 100,
+    "aria-valuenow": determinate ? Math.round(clamped) : undefined
+  }, /*#__PURE__*/React.createElement("circle", {
+    cx: size / 2,
+    cy: size / 2,
+    r: radius,
+    fill: "none",
+    stroke: "currentColor",
+    strokeWidth: strokeWidth,
+    opacity: 0.25
+  }), /*#__PURE__*/React.createElement("circle", {
+    cx: size / 2,
+    cy: size / 2,
+    r: radius,
+    fill: "none",
+    stroke: "currentColor",
+    strokeWidth: strokeWidth,
+    strokeLinecap: "round",
+    strokeDasharray: circumference,
+    strokeDashoffset: dashOffset,
+    transform: "rotate(-90 ".concat(size / 2, " ").concat(size / 2, ")")
+  }));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/side-panel/common/dataset-tag.js

@@ -0,0 +1,57 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import { FormattedMessage } from '@kepler.gl/localization';
+import styled from 'styled-components';
+import { DatasetSquare, Tooltip } from '../..';
+function nop() {
+  return;
+}
+var DatasetTagWrapper = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  display: flex;\n  color: ", ";\n  font-size: 11px;\n  letter-spacing: 0.2px;\n  overflow: auto;\n  display: flex;\n  align-items: center;\n  .dataset-color {\n    flex-shrink: 0;\n  }\n\n  .dataset-name {\n    white-space: nowrap;\n    overflow: hidden;\n    text-overflow: ellipsis;\n  }\n"])), function (props) {
+  return props.theme.textColor;
+});
+var DatasetColorPicker = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  display: flex;\n"])));
+var UpdateTableColor = function UpdateTableColor(_ref) {
+  var children = _ref.children,
+    id = _ref.id;
+  return /*#__PURE__*/React.createElement(DatasetColorPicker, {
+    className: "dataset-action update-color",
+    "data-tip": true,
+    "data-for": "update-color-".concat(id)
+  }, children);
+};
+export default function DatasetTagFactory() {
+  var DatasetTag = function DatasetTag(_ref2) {
+    var _ref2$onClick = _ref2.onClick,
+      onClick = _ref2$onClick === void 0 ? nop : _ref2$onClick,
+      _ref2$onClickSquare = _ref2.onClickSquare,
+      onClickSquare = _ref2$onClickSquare === void 0 ? nop : _ref2$onClickSquare,
+      dataset = _ref2.dataset,
+      updateTableColor = _ref2.updateTableColor;
+    return /*#__PURE__*/React.createElement(DatasetTagWrapper, {
+      className: "source-data-tag"
+    }, /*#__PURE__*/React.createElement(UpdateTableColor, {
+      id: dataset.id
+    }, /*#__PURE__*/React.createElement(DatasetSquare, {
+      className: "dataset-color",
+      backgroundColor: dataset.color,
+      onClick: onClickSquare,
+      "data-tip": true,
+      "data-for": "update-color-".concat(dataset.id)
+    }), updateTableColor ? /*#__PURE__*/React.createElement(Tooltip, {
+      id: "update-color-".concat(dataset.id),
+      effect: "solid"
+    }, /*#__PURE__*/React.createElement("span", null, /*#__PURE__*/React.createElement(FormattedMessage, {
+      id: 'Update color'
+    }))) : null), /*#__PURE__*/React.createElement("div", {
+      className: "dataset-name",
+      title: dataset.label,
+      onClick: onClick
+    }, dataset.label));
+  };
+  return DatasetTag;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJSZWFjdCIsIkZvcm1hdHRlZE1lc3NhZ2UiLCJzdHlsZWQiLCJEYXRhc2V0U3F1YXJlIiwiVG9vbHRpcCIsIm5vcCIsIkRhdGFzZXRUYWdXcmFwcGVyIiwiZGl2IiwiX3RlbXBsYXRlT2JqZWN0IiwiX3RhZ2dlZFRlbXBsYXRlTGl0ZXJhbCIsInByb3BzIiwidGhlbWUiLCJ0ZXh0Q29sb3IiLCJEYXRhc2V0Q29sb3JQaWNrZXIiLCJfdGVtcGxhdGVPYmplY3QyIiwiVXBkYXRlVGFibGVDb2xvciIsIl9yZWYiLCJjaGlsZHJlbiIsImlkIiwiY3JlYXRlRWxlbWVudCIsImNsYXNzTmFtZSIsImNvbmNhdCIsIkRhdGFzZXRUYWdGYWN0b3J5IiwiRGF0YXNldFRhZyIsIl9yZWYyIiwiX3JlZjIkb25DbGljayIsIm9uQ2xpY2siLCJfcmVmMiRvbkNsaWNrU3F1YXJlIiwib25DbGlja1NxdWFyZSIsImRhdGFzZXQiLCJ1cGRhdGVUYWJsZUNvbG9yIiwiYmFja2dyb3VuZENvbG9yIiwiY29sb3IiLCJlZmZlY3QiLCJ0aXRsZSIsImxhYmVsIl0sInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3NpZGUtcGFuZWwvY29tbW9uL2RhdGFzZXQtdGFnLnRzeCJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUXG4vLyBDb3B5cmlnaHQgY29udHJpYnV0b3JzIHRvIHRoZSBrZXBsZXIuZ2wgcHJvamVjdFxuXG5pbXBvcnQgUmVhY3QgZnJvbSAncmVhY3QnO1xuaW1wb3J0IHtGb3JtYXR0ZWRNZXNzYWdlfSBmcm9tICdAa2VwbGVyLmdsL2xvY2FsaXphdGlvbic7XG5pbXBvcnQgc3R5bGVkIGZyb20gJ3N0eWxlZC1jb21wb25lbnRzJztcbmltcG9ydCB7RGF0YXNldFNxdWFyZSwgVG9vbHRpcH0gZnJvbSAnLi4vLi4nO1xuaW1wb3J0IHtVcGRhdGVUYWJsZUNvbG9yVHlwZXN9IGZyb20gJy4vdHlwZXMnO1xuaW1wb3J0IHtSR0JDb2xvcn0gZnJvbSAnQGtlcGxlci5nbC90eXBlcyc7XG5pbXBvcnQge1Zpc1N0YXRlQWN0aW9ucywgQWN0aW9uSGFuZGxlcn0gZnJvbSAnQGtlcGxlci5nbC9hY3Rpb25zJztcblxuZnVuY3Rpb24gbm9wKCkge1xuICByZXR1cm47XG59XG5cbmNvbnN0IERhdGFzZXRUYWdXcmFwcGVyID0gc3R5bGVkLmRpdmBcbiAgZGlzcGxheTogZmxleDtcbiAgY29sb3I6ICR7cHJvcHMgPT4gcHJvcHMudGhlbWUudGV4dENvbG9yfTtcbiAgZm9udC1zaXplOiAxMXB4O1xuICBsZXR0ZXItc3BhY2luZzogMC4ycHg7XG4gIG92ZXJmbG93OiBhdXRvO1xuICBkaXNwbGF5OiBmbGV4O1xuICBhbGlnbi1pdGVtczogY2VudGVyO1xuICAuZGF0YXNldC1jb2xvciB7XG4gICAgZmxleC1zaHJpbms6IDA7XG4gIH1cblxuICAuZGF0YXNldC1uYW1lIHtcbiAgICB3aGl0ZS1zcGFjZTogbm93cmFwO1xuICAgIG92ZXJmbG93OiBoaWRkZW47XG4gICAgdGV4dC1vdmVyZmxvdzogZWxsaXBzaXM7XG4gIH1cbmA7XG5cbmNvbnN0IERhdGFzZXRDb2xvclBpY2tlciA9IHN0eWxlZC5kaXZgXG4gIGRpc3BsYXk6IGZsZXg7XG5gO1xuXG5jb25zdCBVcGRhdGVUYWJsZUNvbG9yID0gKHtjaGlsZHJlbiwgaWR9OiBVcGRhdGVUYWJsZUNvbG9yVHlwZXMpID0+IChcbiAgPERhdGFzZXRDb2xvclBpY2tlclxuICAgIGNsYXNzTmFtZT1cImRhdGFzZXQtYWN0aW9uIHVwZGF0ZS1jb2xvclwiXG4gICAgZGF0YS10aXBcbiAgICBkYXRhLWZvcj17YHVwZGF0ZS1jb2xvci0ke2lkfWB9XG4gID5cbiAgICB7Y2hpbGRyZW59XG4gIDwvRGF0YXNldENvbG9yUGlja2VyPlxuKTtcblxudHlwZSBNaW5pRGF0YXNldCA9IHtcbiAgaWQ6IHN0cmluZztcbiAgY29sb3I6IFJHQkNvbG9yO1xuICBsYWJlbD86IHN0cmluZztcbn07XG5cbmV4cG9ydCB0eXBlIERhdGFzZXRUYWdQcm9wcyA9IHtcbiAgaWQ/OiBzdHJpbmc7XG4gIGRhdGFzZXQ6IE1pbmlEYXRhc2V0O1xuICB1cGRhdGVUYWJsZUNvbG9yPzogQWN0aW9uSGFuZGxlcjx0eXBlb2YgVmlzU3RhdGVBY3Rpb25zLnVwZGF0ZVRhYmxlQ29sb3I+O1xuICBvbkNsaWNrPzogUmVhY3QuTW91c2VFdmVudEhhbmRsZXI8SFRNTERpdkVsZW1lbnQ+O1xuICBvbkNsaWNrU3F1YXJlPzogUmVhY3QuTW91c2VFdmVudEhhbmRsZXI8SFRNTERpdkVsZW1lbnQ+O1xufTtcblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gRGF0YXNldFRhZ0ZhY3RvcnkoKTogUmVhY3QuRkM8RGF0YXNldFRhZ1Byb3BzPiB7XG4gIGNvbnN0IERhdGFzZXRUYWcgPSAoe1xuICAgIG9uQ2xpY2sgPSBub3AsXG4gICAgb25DbGlja1NxdWFyZSA9IG5vcCxcbiAgICBkYXRhc2V0LFxuICAgIHVwZGF0ZVRhYmxlQ29sb3JcbiAgfTogRGF0YXNldFRhZ1Byb3BzKSA9PiAoXG4gICAgPERhdGFzZXRUYWdXcmFwcGVyIGNsYXNzTmFtZT1cInNvdXJjZS1kYXRhLXRhZ1wiPlxuICAgICAgPFVwZGF0ZVRhYmxlQ29sb3IgaWQ9e2RhdGFzZXQuaWR9PlxuICAgICAgICA8RGF0YXNldFNxdWFyZVxuICAgICAgICAgIGNsYXNzTmFtZT1cImRhdGFzZXQtY29sb3JcIlxuICAgICAgICAgIGJhY2tncm91bmRDb2xvcj17ZGF0YXNldC5jb2xvcn1cbiAgICAgICAgICBvbkNsaWNrPXtvbkNsaWNrU3F1YXJlfVxuICAgICAgICAgIGRhdGEtdGlwXG4gICAgICAgICAgZGF0YS1mb3I9e2B1cGRhdGUtY29sb3ItJHtkYXRhc2V0LmlkfWB9XG4gICAgICAgIC8+XG4gICAgICAgIHt1cGRhdGVUYWJsZUNvbG9yID8gKFxuICAgICAgICAgIDxUb29sdGlwIGlkPXtgdXBkYXRlLWNvbG9yLSR7ZGF0YXNldC5pZH1gfSBlZmZlY3Q9XCJzb2xpZFwiPlxuICAgICAgICAgICAgPHNwYW4+XG4gICAgICAgICAgICAgIDxGb3JtYXR0ZWRNZXNzYWdlIGlkPXsnVXBkYXRlIGNvbG9yJ30gLz5cbiAgICAgICAgICAgIDwvc3Bhbj5cbiAgICAgICAgICA8L1Rvb2x0aXA+XG4gICAgICAgICkgOiBudWxsfVxuICAgICAgPC9VcGRhdGVUYWJsZUNvbG9yPlxuICAgICAgPGRpdiBjbGFzc05hbWU9XCJkYXRhc2V0LW5hbWVcIiB0aXRsZT17ZGF0YXNldC5sYWJlbH0gb25DbGljaz17b25DbGlja30+XG4gICAgICAgIHtkYXRhc2V0LmxhYmVsfVxuICAgICAgPC9kaXY+XG4gICAgPC9EYXRhc2V0VGFnV3JhcHBlcj5cbiAgKTtcblxuICByZXR1cm4gRGF0YXNldFRhZztcbn1cbiJdLCJtYXBwaW5ncyI6Ijs7QUFBQTtBQUNBOztBQUVBLE9BQU9BLEtBQUssTUFBTSxPQUFPO0FBQ3pCLFNBQVFDLGdCQUFnQixRQUFPLHlCQUF5QjtBQUN4RCxPQUFPQyxNQUFNLE1BQU0sbUJBQW1CO0FBQ3RDLFNBQVFDLGFBQWEsRUFBRUMsT0FBTyxRQUFPLE9BQU87QUFLNUMsU0FBU0MsR0FBR0EsQ0FBQSxFQUFHO0VBQ2I7QUFDRjtBQUVBLElBQU1DLGlCQUFpQixHQUFHSixNQUFNLENBQUNLLEdBQUcsQ0FBQUMsZUFBQSxLQUFBQSxlQUFBLEdBQUFDLHNCQUFBLCtTQUV6QixVQUFBQyxLQUFLO0VBQUEsT0FBSUEsS0FBSyxDQUFDQyxLQUFLLENBQUNDLFNBQVM7QUFBQSxFQWV4QztBQUVELElBQU1DLGtCQUFrQixHQUFHWCxNQUFNLENBQUNLLEdBQUcsQ0FBQU8sZ0JBQUEsS0FBQUEsZ0JBQUEsR0FBQUwsc0JBQUEsNEJBRXBDO0FBRUQsSUFBTU0sZ0JBQWdCLEdBQUcsU0FBbkJBLGdCQUFnQkEsQ0FBQUMsSUFBQTtFQUFBLElBQUtDLFFBQVEsR0FBQUQsSUFBQSxDQUFSQyxRQUFRO0lBQUVDLEVBQUUsR0FBQUYsSUFBQSxDQUFGRSxFQUFFO0VBQUEsb0JBQ3JDbEIsS0FBQSxDQUFBbUIsYUFBQSxDQUFDTixrQkFBa0I7SUFDakJPLFNBQVMsRUFBQyw2QkFBNkI7SUFDdkMsZ0JBQVE7SUFDUiw0QkFBQUMsTUFBQSxDQUEwQkgsRUFBRTtFQUFHLEdBRTlCRCxRQUNpQixDQUFDO0FBQUEsQ0FDdEI7QUFnQkQsZUFBZSxTQUFTSyxpQkFBaUJBLENBQUEsRUFBOEI7RUFDckUsSUFBTUMsVUFBVSxHQUFHLFNBQWJBLFVBQVVBLENBQUFDLEtBQUE7SUFBQSxJQUFBQyxhQUFBLEdBQUFELEtBQUEsQ0FDZEUsT0FBTztNQUFQQSxPQUFPLEdBQUFELGFBQUEsY0FBR3BCLEdBQUcsR0FBQW9CLGFBQUE7TUFBQUUsbUJBQUEsR0FBQUgsS0FBQSxDQUNiSSxhQUFhO01BQWJBLGFBQWEsR0FBQUQsbUJBQUEsY0FBR3RCLEdBQUcsR0FBQXNCLG1CQUFBO01BQ25CRSxPQUFPLEdBQUFMLEtBQUEsQ0FBUEssT0FBTztNQUNQQyxnQkFBZ0IsR0FBQU4sS0FBQSxDQUFoQk0sZ0JBQWdCO0lBQUEsb0JBRWhCOUIsS0FBQSxDQUFBbUIsYUFBQSxDQUFDYixpQkFBaUI7TUFBQ2MsU0FBUyxFQUFDO0lBQWlCLGdCQUM1Q3BCLEtBQUEsQ0FBQW1CLGFBQUEsQ0FBQ0osZ0JBQWdCO01BQUNHLEVBQUUsRUFBRVcsT0FBTyxDQUFDWDtJQUFHLGdCQUMvQmxCLEtBQUEsQ0FBQW1CLGFBQUEsQ0FBQ2hCLGFBQWE7TUFDWmlCLFNBQVMsRUFBQyxlQUFlO01BQ3pCVyxlQUFlLEVBQUVGLE9BQU8sQ0FBQ0csS0FBTTtNQUMvQk4sT0FBTyxFQUFFRSxhQUFjO01BQ3ZCLGdCQUFRO01BQ1IsNEJBQUFQLE1BQUEsQ0FBMEJRLE9BQU8sQ0FBQ1gsRUFBRTtJQUFHLENBQ3hDLENBQUMsRUFDRFksZ0JBQWdCLGdCQUNmOUIsS0FBQSxDQUFBbUIsYUFBQSxDQUFDZixPQUFPO01BQUNjLEVBQUUsa0JBQUFHLE1BQUEsQ0FBa0JRLE9BQU8sQ0FBQ1gsRUFBRSxDQUFHO01BQUNlLE1BQU0sRUFBQztJQUFPLGdCQUN2RGpDLEtBQUEsQ0FBQW1CLGFBQUEsNEJBQ0VuQixLQUFBLENBQUFtQixhQUFBLENBQUNsQixnQkFBZ0I7TUFBQ2lCLEVBQUUsRUFBRTtJQUFlLENBQUUsQ0FDbkMsQ0FDQyxDQUFDLEdBQ1IsSUFDWSxDQUFDLGVBQ25CbEIsS0FBQSxDQUFBbUIsYUFBQTtNQUFLQyxTQUFTLEVBQUMsY0FBYztNQUFDYyxLQUFLLEVBQUVMLE9BQU8sQ0FBQ00sS0FBTTtNQUFDVCxPQUFPLEVBQUVBO0lBQVEsR0FDbEVHLE9BQU8sQ0FBQ00sS0FDTixDQUNZLENBQUM7RUFBQSxDQUNyQjtFQUVELE9BQU9aLFVBQVU7QUFDbkIiLCJpZ25vcmVMaXN0IjpbXX0=