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

package/dist/esm/common/data-table/cell-size.js

@@ -0,0 +1,177 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import document from 'global/document';
+import { parseFieldValue } from '@kepler.gl/utils';
+var MIN_GHOST_CELL_SIZE = 200;
+var MIN_CELL_SIZE = 45;
+// first column have padding on the left
+var EDGE_COLUMN_PADDING = 10;
+
+// in case cell content is small, column name is big, we allow max empty space to
+// be added to min cell width in order to show column name
+var MAX_EMPTY_COLUMN_SPACE = 60;
+/**
+ * Measure rows and column content to determine min width for each column
+ * @param {RenderSizeParam} param0
+ */
+export function renderedSize(_ref) {
+  var _ref$text = _ref.text,
+    dataContainer = _ref$text.dataContainer,
+    column = _ref$text.column,
+    _ref$type = _ref.type,
+    type = _ref$type === void 0 ? 'string' : _ref$type,
+    colIdx = _ref.colIdx,
+    _ref$numRowsToCalcula = _ref.numRowsToCalculate,
+    numRowsToCalculate = _ref$numRowsToCalcula === void 0 ? 10 : _ref$numRowsToCalcula,
+    _ref$fontSize = _ref.fontSize,
+    fontSize = _ref$fontSize === void 0 ? 12 : _ref$fontSize,
+    _ref$font = _ref.font,
+    font = _ref$font === void 0 ? 'Lato' : _ref$font,
+    _ref$cellPadding = _ref.cellPadding,
+    cellPadding = _ref$cellPadding === void 0 ? 40 : _ref$cellPadding,
+    _ref$maxCellSize = _ref.maxCellSize,
+    maxCellSize = _ref$maxCellSize === void 0 ? 500 : _ref$maxCellSize,
+    _ref$maxHeaderSize = _ref.maxHeaderSize,
+    maxHeaderSize = _ref$maxHeaderSize === void 0 ? 500 : _ref$maxHeaderSize,
+    _ref$minCellSize = _ref.minCellSize,
+    minCellSize = _ref$minCellSize === void 0 ? MIN_CELL_SIZE : _ref$minCellSize,
+    _ref$optionsButton = _ref.optionsButton,
+    optionsButton = _ref$optionsButton === void 0 ? 44 : _ref$optionsButton;
+  if (!document) {
+    return {
+      row: 0,
+      header: 0
+    };
+  }
+  var textCanvas = document.createElement('canvas');
+  document.body.appendChild(textCanvas);
+  var context = textCanvas.getContext('2d');
+  context.font = [fontSize, font].join('px ');
+  var rowsToSample = _toConsumableArray(Array(numRowsToCalculate)).map(function () {
+    return Math.floor(Math.random() * (dataContainer.numRows() - 1));
+  });
+
+  // If we have less than 10 rows, lets measure all of them
+  if (dataContainer.numRows() <= numRowsToCalculate) {
+    rowsToSample = Array.from(Array(dataContainer.numRows()).keys());
+  }
+  var rowWidth = Math.max.apply(Math, _toConsumableArray(rowsToSample.map(function (rowIdx) {
+    var value = parseFieldValue(dataContainer.valueAt(rowIdx, colIdx), type);
+    // measuring large text cause slow performance
+    if (value.length > maxCellSize) {
+      return maxCellSize;
+    }
+    var textWidth = context.measureText(value).width;
+    return Math.ceil(textWidth) + cellPadding;
+  })));
+  // header cell only has left padding
+  var headerWidth = Math.ceil(context.measureText(column).width) + cellPadding / 2 + optionsButton;
+
+  // min row width is measured by cell content
+  var minRowWidth = minCellSize + cellPadding;
+  // min header width is measured by cell
+  var minHeaderWidth = minCellSize + cellPadding / 2 + optionsButton;
+  var clampedRowWidth = clamp(minRowWidth, maxCellSize, rowWidth);
+  var clampedHeaderWidth = clamp(minHeaderWidth, maxHeaderSize, headerWidth);
+
+  // cleanup
+  textCanvas.parentElement.removeChild(textCanvas);
+  return {
+    row: clampedRowWidth,
+    header: clampedHeaderWidth
+  };
+}
+function clamp(min, max, value) {
+  return Math.max(Math.min(max, value), min);
+}
+function getColumnOrder() {
+  var pinnedColumns = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var unpinnedColumns = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return [].concat(_toConsumableArray(pinnedColumns), _toConsumableArray(unpinnedColumns));
+}
+
+// If total min cell size is bigger than containerWidth adjust column
+function getMinCellSize(cellSizeCache) {
+  return Object.keys(cellSizeCache).reduce(function (accu, col) {
+    return _objectSpread(_objectSpread({}, accu), {}, _defineProperty({}, col, cellSizeCache[col].row > cellSizeCache[col].header ? cellSizeCache[col].row :
+    // if row is smaller than header, use the smaller of MAX_EMPTY_COLUMN_SPACE + row width and header
+    Math.min(cellSizeCache[col].header, cellSizeCache[col].row + MAX_EMPTY_COLUMN_SPACE)));
+  }, {});
+}
+function getSizeSum(sizeCache, key) {
+  return Object.keys(sizeCache).reduce(function (acc, val) {
+    return acc + (key ? sizeCache[val][key] : sizeCache[val]);
+  }, 0);
+}
+
+/**
+ * Expand cell to fit both row and header, if there is still room left,
+ * expand last cell to fit the entire width of the container
+ * @param {CellSizeCache} cellSizeCache
+ * @param {string[]} columnOrder
+ * @param {number} containerWidth
+ * @param {number} roomToFill
+ */
+function expandCellSize(cellSizeCache, columnOrder, containerWidth, roomToFill) {
+  var remaining = roomToFill;
+  var expandedCellSize = columnOrder.reduce(function (accu, col) {
+    var size = cellSizeCache[col].row;
+    if (cellSizeCache[col].row < cellSizeCache[col].header && remaining > 0) {
+      // if we are cutting off the header, expand to fit it
+      size = cellSizeCache[col].header - cellSizeCache[col].row < remaining ? cellSizeCache[col].header : cellSizeCache[col].row + remaining;
+      remaining -= size - cellSizeCache[col].row;
+    }
+    return _objectSpread(_objectSpread({}, accu), {}, _defineProperty({}, col, size));
+  }, {});
+  var ghost = null;
+  if (remaining > 0 && remaining < MIN_GHOST_CELL_SIZE) {
+    // expand last cell
+    var lastCell = columnOrder[columnOrder.length - 1];
+    expandedCellSize[lastCell] += remaining;
+  } else if (remaining >= MIN_GHOST_CELL_SIZE) {
+    // if too much left add a ghost cell
+    ghost = remaining;
+  }
+  return {
+    cellSizeCache: expandedCellSize,
+    ghost: ghost
+  };
+}
+function addPaddingToFirstColumn(cellSizeCache) {
+  var columnOrder = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var firstCol = columnOrder[0];
+  if (firstCol && cellSizeCache[firstCol]) {
+    return _objectSpread(_objectSpread({}, cellSizeCache), {}, _defineProperty({}, firstCol, {
+      header: cellSizeCache[firstCol].header + EDGE_COLUMN_PADDING,
+      row: cellSizeCache[firstCol].row + EDGE_COLUMN_PADDING
+    }));
+  }
+  return cellSizeCache;
+}
+
+/**
+ * Adjust cell size based on container width
+ * @param {number} containerWidth
+ * @param {CellSizeCache} cellSizeCache
+ * @param {string[]} pinnedColumns
+ * @param {string[]} unpinnedColumns
+ */
+export function adjustCellsToContainer(containerWidth, cellSizeCache, pinnedColumns, unpinnedColumns) {
+  var columnOrder = getColumnOrder(pinnedColumns, unpinnedColumns);
+  var paddedCellSize = addPaddingToFirstColumn(cellSizeCache, columnOrder);
+  var minRowSum = getSizeSum(paddedCellSize, 'row');
+  if (minRowSum >= containerWidth) {
+    // we apply the min Width to all cells
+    return {
+      cellSizeCache: getMinCellSize(paddedCellSize)
+    };
+  }
+  // if we have some room to expand
+  return expandCellSize(paddedCellSize, columnOrder, containerWidth, containerWidth - minRowSum);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["document","parseFieldValue","MIN_GHOST_CELL_SIZE","MIN_CELL_SIZE","EDGE_COLUMN_PADDING","MAX_EMPTY_COLUMN_SPACE","renderedSize","_ref","_ref$text","text","dataContainer","column","_ref$type","type","colIdx","_ref$numRowsToCalcula","numRowsToCalculate","_ref$fontSize","fontSize","_ref$font","font","_ref$cellPadding","cellPadding","_ref$maxCellSize","maxCellSize","_ref$maxHeaderSize","maxHeaderSize","_ref$minCellSize","minCellSize","_ref$optionsButton","optionsButton","row","header","textCanvas","createElement","body","appendChild","context","getContext","join","rowsToSample","_toConsumableArray","Array","map","Math","floor","random","numRows","from","keys","rowWidth","max","apply","rowIdx","value","valueAt","length","textWidth","measureText","width","ceil","headerWidth","minRowWidth","minHeaderWidth","clampedRowWidth","clamp","clampedHeaderWidth","parentElement","removeChild","min","getColumnOrder","pinnedColumns","arguments","undefined","unpinnedColumns","concat","getMinCellSize","cellSizeCache","Object","reduce","accu","col","_objectSpread","_defineProperty","getSizeSum","sizeCache","key","acc","val","expandCellSize","columnOrder","containerWidth","roomToFill","remaining","expandedCellSize","size","ghost","lastCell","addPaddingToFirstColumn","firstCol","adjustCellsToContainer","paddedCellSize","minRowSum"],"sources":["../../../../src/common/data-table/cell-size.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport document from 'global/document';\nimport {DataContainerInterface, parseFieldValue} from '@kepler.gl/utils';\n\nconst MIN_GHOST_CELL_SIZE = 200;\nconst MIN_CELL_SIZE = 45;\n// first column have padding on the left\nconst EDGE_COLUMN_PADDING = 10;\n\n// in case cell content is small, column name is big, we allow max empty space to\n// be added to min cell width in order to show column name\nconst MAX_EMPTY_COLUMN_SPACE = 60;\n\ntype RenderSizeParam = {\n  text: {dataContainer: DataContainerInterface; column: string};\n  type?: string;\n  colIdx: number;\n  numRowsToCalculate?: number;\n  fontSize?: number;\n  font?: string;\n  cellPadding?: number;\n  maxCellSize?: number;\n  maxHeaderSize?: number;\n  minCellSize?: number;\n  optionsButton?: number;\n};\n\nexport type CellSizeCache = {\n  [key: string]: {\n    row: number;\n    header: number;\n  };\n};\n\n/**\n * Measure rows and column content to determine min width for each column\n * @param {RenderSizeParam} param0\n */\nexport function renderedSize({\n  text: {dataContainer, column},\n  type = 'string',\n  colIdx,\n  numRowsToCalculate = 10,\n  fontSize = 12,\n  font = 'Lato',\n  cellPadding = 40,\n  maxCellSize = 500,\n  maxHeaderSize = 500,\n  minCellSize = MIN_CELL_SIZE,\n  optionsButton = 44\n}: RenderSizeParam): {row: number; header: number} {\n  if (!document) {\n    return {\n      row: 0,\n      header: 0\n    };\n  }\n\n  const textCanvas = document.createElement('canvas');\n  document.body.appendChild(textCanvas);\n  const context = textCanvas.getContext('2d');\n  context.font = [fontSize, font].join('px ');\n\n  let rowsToSample = [...Array(numRowsToCalculate)].map(() =>\n    Math.floor(Math.random() * (dataContainer.numRows() - 1))\n  );\n\n  // If we have less than 10 rows, lets measure all of them\n  if (dataContainer.numRows() <= numRowsToCalculate) {\n    rowsToSample = Array.from(Array(dataContainer.numRows()).keys());\n  }\n  const rowWidth = Math.max(\n    ...rowsToSample.map(rowIdx => {\n      const value = parseFieldValue(dataContainer.valueAt(rowIdx, colIdx), type);\n      // measuring large text cause slow performance\n      if (value.length > maxCellSize) {\n        return maxCellSize;\n      }\n      const textWidth = context.measureText(value).width;\n      return Math.ceil(textWidth) + cellPadding;\n    })\n  );\n  // header cell only has left padding\n  const headerWidth =\n    Math.ceil(context.measureText(column).width) + cellPadding / 2 + optionsButton;\n\n  // min row width is measured by cell content\n  const minRowWidth = minCellSize + cellPadding;\n  // min header width is measured by cell\n  const minHeaderWidth = minCellSize + cellPadding / 2 + optionsButton;\n\n  const clampedRowWidth = clamp(minRowWidth, maxCellSize, rowWidth);\n  const clampedHeaderWidth = clamp(minHeaderWidth, maxHeaderSize, headerWidth);\n\n  // cleanup\n  textCanvas.parentElement.removeChild(textCanvas);\n\n  return {\n    row: clampedRowWidth,\n    header: clampedHeaderWidth\n  };\n}\n\nfunction clamp(min, max, value) {\n  return Math.max(Math.min(max, value), min);\n}\n\nfunction getColumnOrder(pinnedColumns: string[] = [], unpinnedColumns: string[] = []) {\n  return [...pinnedColumns, ...unpinnedColumns];\n}\n\n// If total min cell size is bigger than containerWidth adjust column\nfunction getMinCellSize(cellSizeCache: CellSizeCache) {\n  return Object.keys(cellSizeCache).reduce(\n    (accu, col) => ({\n      ...accu,\n      // if row is larger than header, use row\n      [col]:\n        cellSizeCache[col].row > cellSizeCache[col].header\n          ? cellSizeCache[col].row\n          : // if row is smaller than header, use the smaller of MAX_EMPTY_COLUMN_SPACE + row width and header\n            Math.min(cellSizeCache[col].header, cellSizeCache[col].row + MAX_EMPTY_COLUMN_SPACE)\n    }),\n    {}\n  );\n}\n\nfunction getSizeSum(sizeCache, key) {\n  return Object.keys(sizeCache).reduce(\n    (acc, val) => acc + (key ? sizeCache[val][key] : sizeCache[val]),\n    0\n  );\n}\n\n/**\n * Expand cell to fit both row and header, if there is still room left,\n * expand last cell to fit the entire width of the container\n * @param {CellSizeCache} cellSizeCache\n * @param {string[]} columnOrder\n * @param {number} containerWidth\n * @param {number} roomToFill\n */\nfunction expandCellSize(\n  cellSizeCache: CellSizeCache,\n  columnOrder: string[],\n  containerWidth: number,\n  roomToFill: number\n): {\n  cellSizeCache: CellSizeCache;\n  ghost: number | null;\n} {\n  let remaining = roomToFill;\n\n  const expandedCellSize = columnOrder.reduce((accu, col) => {\n    let size = cellSizeCache[col].row;\n    if (cellSizeCache[col].row < cellSizeCache[col].header && remaining > 0) {\n      // if we are cutting off the header, expand to fit it\n      size =\n        cellSizeCache[col].header - cellSizeCache[col].row < remaining\n          ? cellSizeCache[col].header\n          : cellSizeCache[col].row + remaining;\n      remaining -= size - cellSizeCache[col].row;\n    }\n\n    return {\n      ...accu,\n      [col]: size\n    };\n  }, {});\n\n  let ghost: number | null = null;\n  if (remaining > 0 && remaining < MIN_GHOST_CELL_SIZE) {\n    // expand last cell\n    const lastCell = columnOrder[columnOrder.length - 1];\n    expandedCellSize[lastCell] += remaining;\n  } else if (remaining >= MIN_GHOST_CELL_SIZE) {\n    // if too much left add a ghost cell\n    ghost = remaining;\n  }\n\n  return {\n    cellSizeCache: expandedCellSize,\n    ghost\n  };\n}\n\nfunction addPaddingToFirstColumn(\n  cellSizeCache: CellSizeCache,\n  columnOrder: string[] = []\n): CellSizeCache {\n  const firstCol = columnOrder[0];\n\n  if (firstCol && cellSizeCache[firstCol]) {\n    return {\n      ...cellSizeCache,\n      [firstCol]: {\n        header: cellSizeCache[firstCol].header + EDGE_COLUMN_PADDING,\n        row: cellSizeCache[firstCol].row + EDGE_COLUMN_PADDING\n      }\n    };\n  }\n  return cellSizeCache;\n}\n\n/**\n * Adjust cell size based on container width\n * @param {number} containerWidth\n * @param {CellSizeCache} cellSizeCache\n * @param {string[]} pinnedColumns\n * @param {string[]} unpinnedColumns\n */\nexport function adjustCellsToContainer(\n  containerWidth: number,\n  cellSizeCache: CellSizeCache,\n  pinnedColumns: string[],\n  unpinnedColumns: string[]\n): {\n  cellSizeCache: CellSizeCache;\n  ghost?: number | null;\n} {\n  const columnOrder = getColumnOrder(pinnedColumns, unpinnedColumns);\n  const paddedCellSize = addPaddingToFirstColumn(cellSizeCache, columnOrder);\n  const minRowSum = getSizeSum(paddedCellSize, 'row');\n\n  if (minRowSum >= containerWidth) {\n    // we apply the min Width to all cells\n    return {cellSizeCache: getMinCellSize(paddedCellSize)};\n  }\n  // if we have some room to expand\n  return expandCellSize(paddedCellSize, columnOrder, containerWidth, containerWidth - minRowSum);\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/common/data-table/display-format.js

@@ -0,0 +1,118 @@
+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, useState } from 'react';
+import styled from 'styled-components';
+import { getFieldFormatLabels } from '@kepler.gl/utils';
+import { ALL_FIELD_TYPES } from '@kepler.gl/constants';
+import { InputLight } from '../../common/styled-components';
+import { FormatterDropdown } from './option-dropdown';
+var StyledConfigPanel = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  background-color: ", ";\n  box-shadow: 0 10px 18px 0 rgb(0 0 0 / 36%);\n  flex-grow: 1;\n"])), function (props) {
+  return props.theme.headerCellBackground;
+});
+var StyledConfigPanelContent = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  padding: 20px;\n  min-width: 230px;\n  max-height: 400px;\n  overflow: overlay;\n"])));
+var StyledTableConfigGroup = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  margin-bottom: 10px;\n  display: flex;\n  align-items: center;\n\n  input {\n    cursor: pointer !important;\n    width: 184px;\n    height: 22px;\n  }\n"])));
+export var NumberFormatConfig = function NumberFormatConfig(_ref) {
+  var title = _ref.title,
+    id = _ref.id,
+    defaultFormat = _ref.defaultFormat,
+    options = _ref.options,
+    columns = _ref.columns,
+    setColumnDisplayFormat = _ref.setColumnDisplayFormat,
+    onClose = _ref.onClose;
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    showFormatter = _useState2[0],
+    setShowFormatter = _useState2[1];
+  var _useState3 = useState(defaultFormat),
+    _useState4 = _slicedToArray(_useState3, 2),
+    format = _useState4[0],
+    setFormat = _useState4[1];
+  var onSetDisplayFormat = useCallback(function (option) {
+    setFormat(option.label);
+    var formats = columns.reduce(function (prev, col) {
+      prev[col.name] = option.format;
+      return prev;
+    }, {});
+    setColumnDisplayFormat(formats);
+    onClose();
+  }, [columns, setColumnDisplayFormat, onClose]);
+  return /*#__PURE__*/React.createElement(StyledTableConfigGroup, null, /*#__PURE__*/React.createElement(InputLight, {
+    id: id,
+    type: "text",
+    value: title,
+    "data-tip": format,
+    readOnly: true,
+    onClick: function onClick() {
+      return setShowFormatter(true);
+    }
+  }), /*#__PURE__*/React.createElement(FormatterDropdown, {
+    left: -185,
+    top: 10,
+    isOpened: showFormatter,
+    displayFormat: format,
+    setDisplayFormat: onSetDisplayFormat,
+    onClose: function onClose() {
+      return setShowFormatter(false);
+    },
+    formatLabels: options
+  }));
+};
+function DataTableConfigFactory() {
+  var getColumnsByFieldType = function getColumnsByFieldType(columns, colMeta, fieldType) {
+    var result = [];
+    columns.forEach(function (colName) {
+      var _colMeta$colName;
+      if (((_colMeta$colName = colMeta[colName]) === null || _colMeta$colName === void 0 ? void 0 : _colMeta$colName.type) === fieldType) {
+        result.push(colMeta[colName]);
+      }
+    });
+    return result;
+  };
+  var DataTableConfig = function DataTableConfig(_ref2) {
+    var columns = _ref2.columns,
+      colMeta = _ref2.colMeta,
+      setColumnDisplayFormat = _ref2.setColumnDisplayFormat,
+      onClose = _ref2.onClose;
+    var formatConfigs = [{
+      title: '# Set Integer Number Format',
+      id: 'input-iteger-format',
+      displayType: ALL_FIELD_TYPES.integer
+    }, {
+      title: '# Set Float Number Format',
+      id: 'input-float-format',
+      displayType: ALL_FIELD_TYPES.real
+    }, {
+      title: '# Set Timestamp Format',
+      id: 'input-datetime-format',
+      displayType: ALL_FIELD_TYPES.timestamp
+    }, {
+      title: '# Set Date Format',
+      id: 'input-date-format',
+      displayType: ALL_FIELD_TYPES.date
+    }, {
+      title: '# Set Boolean Format',
+      id: 'input-bool-format',
+      displayType: ALL_FIELD_TYPES["boolean"]
+    }];
+    return /*#__PURE__*/React.createElement(StyledConfigPanel, null, /*#__PURE__*/React.createElement(StyledConfigPanelContent, null, formatConfigs.map(function (config, index) {
+      return /*#__PURE__*/React.createElement(NumberFormatConfig, {
+        title: "".concat(config.title),
+        key: index,
+        id: config.id,
+        defaultFormat: 'None',
+        colMeta: colMeta,
+        options: getFieldFormatLabels("".concat(config.displayType)),
+        columns: getColumnsByFieldType(columns, colMeta, "".concat(config.displayType)),
+        setColumnDisplayFormat: setColumnDisplayFormat,
+        onClose: onClose
+      });
+    })));
+  };
+  return DataTableConfig;
+}
+export default DataTableConfigFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useCallback","useState","styled","getFieldFormatLabels","ALL_FIELD_TYPES","InputLight","FormatterDropdown","StyledConfigPanel","div","_templateObject","_taggedTemplateLiteral","props","theme","headerCellBackground","StyledConfigPanelContent","_templateObject2","StyledTableConfigGroup","_templateObject3","NumberFormatConfig","_ref","title","id","defaultFormat","options","columns","setColumnDisplayFormat","onClose","_useState","_useState2","_slicedToArray","showFormatter","setShowFormatter","_useState3","_useState4","format","setFormat","onSetDisplayFormat","option","label","formats","reduce","prev","col","name","createElement","type","value","readOnly","onClick","left","top","isOpened","displayFormat","setDisplayFormat","formatLabels","DataTableConfigFactory","getColumnsByFieldType","colMeta","fieldType","result","forEach","colName","_colMeta$colName","push","DataTableConfig","_ref2","formatConfigs","displayType","integer","real","timestamp","date","map","config","index","concat","key"],"sources":["../../../../src/common/data-table/display-format.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useCallback, useState} from 'react';\nimport styled from 'styled-components';\n\nimport {getFieldFormatLabels} from '@kepler.gl/utils';\nimport {ALL_FIELD_TYPES, TooltipFormat} from '@kepler.gl/constants';\nimport {ColMeta, ColMetaProps} from '@kepler.gl/types';\n\nimport {InputLight} from '../../common/styled-components';\nimport {FormatterDropdown} from './option-dropdown';\n\nconst StyledConfigPanel = styled.div`\n  background-color: ${props => props.theme.headerCellBackground};\n  box-shadow: 0 10px 18px 0 rgb(0 0 0 / 36%);\n  flex-grow: 1;\n`;\nconst StyledConfigPanelContent = styled.div`\n  padding: 20px;\n  min-width: 230px;\n  max-height: 400px;\n  overflow: overlay;\n`;\n\nconst StyledTableConfigGroup = styled.div`\n  margin-bottom: 10px;\n  display: flex;\n  align-items: center;\n\n  input {\n    cursor: pointer !important;\n    width: 184px;\n    height: 22px;\n  }\n`;\n\nexport type DataTableConfigProps = {\n  title: string;\n  id: string;\n  defaultFormat: string;\n  options: TooltipFormat[];\n  columns: {name: string}[];\n  colMeta: ColMeta;\n  setColumnDisplayFormat: (formats: {[key: string]: string}) => void;\n  onClose: () => void;\n};\n\nexport const NumberFormatConfig: React.FC<DataTableConfigProps> = ({\n  title,\n  id,\n  defaultFormat,\n  options,\n  columns,\n  setColumnDisplayFormat,\n  onClose\n}: DataTableConfigProps) => {\n  const [showFormatter, setShowFormatter] = useState(false);\n  const [format, setFormat] = useState(defaultFormat);\n\n  const onSetDisplayFormat = useCallback(\n    (option: TooltipFormat) => {\n      setFormat(option.label);\n      const formats: {[key: string]: string} = columns.reduce((prev, col) => {\n        prev[col.name] = option.format;\n        return prev;\n      }, {});\n      setColumnDisplayFormat(formats);\n      onClose();\n    },\n    [columns, setColumnDisplayFormat, onClose]\n  );\n\n  return (\n    <StyledTableConfigGroup>\n      <InputLight\n        id={id}\n        type=\"text\"\n        value={title}\n        data-tip={format}\n        readOnly\n        onClick={() => setShowFormatter(true)}\n      />\n      <FormatterDropdown\n        left={-185}\n        top={10}\n        isOpened={showFormatter}\n        displayFormat={format}\n        setDisplayFormat={onSetDisplayFormat}\n        onClose={() => setShowFormatter(false)}\n        formatLabels={options}\n      />\n    </StyledTableConfigGroup>\n  );\n};\n\nfunction DataTableConfigFactory() {\n  const getColumnsByFieldType = (columns: string[], colMeta: ColMeta, fieldType: string) => {\n    const result: ColMetaProps[] = [];\n    columns.forEach(colName => {\n      if (colMeta[colName]?.type === fieldType) {\n        result.push(colMeta[colName]);\n      }\n    });\n    return result;\n  };\n\n  const DataTableConfig = ({columns, colMeta, setColumnDisplayFormat, onClose}) => {\n    const formatConfigs = [\n      {\n        title: '# Set Integer Number Format',\n        id: 'input-iteger-format',\n        displayType: ALL_FIELD_TYPES.integer\n      },\n      {\n        title: '# Set Float Number Format',\n        id: 'input-float-format',\n        displayType: ALL_FIELD_TYPES.real\n      },\n      {\n        title: '# Set Timestamp Format',\n        id: 'input-datetime-format',\n        displayType: ALL_FIELD_TYPES.timestamp\n      },\n      {\n        title: '# Set Date Format',\n        id: 'input-date-format',\n        displayType: ALL_FIELD_TYPES.date\n      },\n      {\n        title: '# Set Boolean Format',\n        id: 'input-bool-format',\n        displayType: ALL_FIELD_TYPES.boolean\n      }\n    ];\n\n    return (\n      <StyledConfigPanel>\n        <StyledConfigPanelContent>\n          {formatConfigs.map((config, index) => (\n            <NumberFormatConfig\n              title={`${config.title}`}\n              key={index}\n              id={config.id}\n              defaultFormat={'None'}\n              colMeta={colMeta}\n              options={getFieldFormatLabels(`${config.displayType}`)}\n              columns={getColumnsByFieldType(columns, colMeta, `${config.displayType}`)}\n              setColumnDisplayFormat={setColumnDisplayFormat}\n              onClose={onClose}\n            />\n          ))}\n        </StyledConfigPanelContent>\n      </StyledConfigPanel>\n    );\n  };\n  return DataTableConfig;\n}\n\nexport default DataTableConfigFactory;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/common/data-table/grid.js

@@ -0,0 +1,100 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+var _excluded = ["setGridRef"];
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(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; })(); }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { PureComponent } from 'react';
+import { Grid } from 'react-virtualized';
+import isEqual from 'lodash/isEqual';
+var GridHack = /*#__PURE__*/function (_PureComponent) {
+  function GridHack() {
+    var _this;
+    _classCallCheck(this, GridHack);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _callSuper(this, GridHack, [].concat(args));
+    _defineProperty(_this, "grid", null);
+    _defineProperty(_this, "_preventScrollBack", function (e) {
+      var scrollLeft = _this.props.scrollLeft;
+      if (scrollLeft !== undefined && scrollLeft <= 0 && e.deltaX < 0) {
+        // Prevent Scroll On Scrollable Elements, avoid browser backward navigation
+        // https://alvarotrigo.com/blog/prevent-scroll-on-scrollable-element-js/
+        e.preventDefault();
+        e.stopPropagation();
+        return false;
+      }
+      return;
+    });
+    _defineProperty(_this, "_updateRef", function (x) {
+      if (!_this.grid && x) {
+        var _this$grid;
+        _this.grid = x;
+        /*
+         * This hack exists because we need to add wheel event listener to the div rendered by Grid
+         *
+         */
+        // @ts-expect-error _scrollingContainer not typed in Grid
+        (_this$grid = _this.grid) === null || _this$grid === void 0 || (_this$grid = _this$grid._scrollingContainer) === null || _this$grid === void 0 || _this$grid.addEventListener('wheel', _this._preventScrollBack, {
+          passive: false
+        });
+      }
+    });
+    return _this;
+  }
+  _inherits(GridHack, _PureComponent);
+  return _createClass(GridHack, [{
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(preProps) {
+      /*
+       * This hack exists because in react-virtualized the
+       * _columnWidthGetter is only called in the constructor
+       * even though it is reassigned with new props resulting in
+       * a new width for cells not being calculated so we must
+       * force trigger a resize.
+       *
+       * https://github.com/bvaughn/react-virtualized/blob/master/source/Grid/Grid.js#L322
+       *
+       */
+      if (!isEqual(preProps.cellSizeCache, this.props.cellSizeCache)) {
+        var _this$grid2;
+        (_this$grid2 = this.grid) === null || _this$grid2 === void 0 || _this$grid2.recomputeGridSize();
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      var _this$grid3;
+      // @ts-expect-error _scrollingContainer not typed in Grid
+      (_this$grid3 = this.grid) === null || _this$grid3 === void 0 || (_this$grid3 = _this$grid3._scrollingContainer) === null || _this$grid3 === void 0 || _this$grid3.removeEventListener('wheel', this._preventScrollBack, {
+        passive: false
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var _this$props = this.props,
+        setGridRef = _this$props.setGridRef,
+        rest = _objectWithoutProperties(_this$props, _excluded);
+      return /*#__PURE__*/React.createElement(Grid, _extends({
+        ref: function ref(x) {
+          if (setGridRef) setGridRef(x);
+          _this2._updateRef(x);
+        },
+        key: "grid-hack"
+      }, rest));
+    }
+  }]);
+}(PureComponent);
+export { GridHack as default };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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