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

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

@@ -0,0 +1,194 @@
+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;
+var GEOMETRY_FIELD_TYPES = {
+  geojson: true,
+  geoarrow: true
+};
+
+// GeoJSON payloads can be huge; do not size the column from cell text.
+var MAX_GEOMETRY_CELL_SIZE = 180;
+/**
+ * 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 isGeometryColumn = Boolean(GEOMETRY_FIELD_TYPES[type]);
+  var maxWidth = isGeometryColumn ? MAX_GEOMETRY_CELL_SIZE : maxCellSize;
+  var rowWidth = minCellSize + cellPadding;
+  if (!isGeometryColumn) {
+    var rowsToSample = _toConsumableArray(Array(numRowsToCalculate)).map(function () {
+      return Math.floor(Math.random() * Math.max(dataContainer.numRows() - 1, 0));
+    });
+
+    // If we have less than 10 rows, lets measure all of them
+    if (dataContainer.numRows() <= numRowsToCalculate) {
+      rowsToSample = Array.from(Array(dataContainer.numRows()).keys());
+    }
+    rowWidth = Math.max.apply(Math, [rowWidth].concat(_toConsumableArray(rowsToSample.map(function (rowIdx) {
+      var value = parseFieldValue(dataContainer.valueAt(rowIdx, colIdx), type);
+      // measuring large text cause slow performance
+      if (value.length > maxWidth) {
+        return maxWidth;
+      }
+      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, maxWidth, 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 colSize = cellSizeCache[col];
+    if (!colSize) {
+      return accu;
+    }
+    var size = colSize.row;
+    if (colSize.row < colSize.header && remaining > 0) {
+      // if we are cutting off the header, expand to fit it
+      size = colSize.header - colSize.row < remaining ? colSize.header : colSize.row + remaining;
+      remaining -= size - colSize.row;
+    }
+    return _objectSpread(_objectSpread({}, accu), {}, _defineProperty({}, col, size));
+  }, {});
+  var ghost = null;
+  if (remaining > 0 && remaining < MIN_GHOST_CELL_SIZE) {
+    var lastCell = columnOrder[columnOrder.length - 1];
+    if (lastCell && expandedCellSize[lastCell] != null) {
+      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","GEOMETRY_FIELD_TYPES","geojson","geoarrow","MAX_GEOMETRY_CELL_SIZE","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","isGeometryColumn","Boolean","maxWidth","rowWidth","rowsToSample","_toConsumableArray","Array","map","Math","floor","random","max","numRows","from","keys","apply","concat","rowIdx","value","valueAt","length","textWidth","measureText","width","ceil","headerWidth","minRowWidth","minHeaderWidth","clampedRowWidth","clamp","clampedHeaderWidth","parentElement","removeChild","min","getColumnOrder","pinnedColumns","arguments","undefined","unpinnedColumns","getMinCellSize","cellSizeCache","Object","reduce","accu","col","_objectSpread","_defineProperty","getSizeSum","sizeCache","key","acc","val","expandCellSize","columnOrder","containerWidth","roomToFill","remaining","expandedCellSize","colSize","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\nconst GEOMETRY_FIELD_TYPES: Record<string, boolean> = {\n  geojson: true,\n  geoarrow: true\n};\n\n// GeoJSON payloads can be huge; do not size the column from cell text.\nconst MAX_GEOMETRY_CELL_SIZE = 180;\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  const isGeometryColumn = Boolean(GEOMETRY_FIELD_TYPES[type]);\n  const maxWidth = isGeometryColumn ? MAX_GEOMETRY_CELL_SIZE : maxCellSize;\n\n  let rowWidth = minCellSize + cellPadding;\n  if (!isGeometryColumn) {\n    let rowsToSample = [...Array(numRowsToCalculate)].map(() =>\n      Math.floor(Math.random() * Math.max(dataContainer.numRows() - 1, 0))\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    rowWidth = Math.max(\n      rowWidth,\n      ...rowsToSample.map(rowIdx => {\n        const value = parseFieldValue(dataContainer.valueAt(rowIdx, colIdx), type);\n        // measuring large text cause slow performance\n        if (value.length > maxWidth) {\n          return maxWidth;\n        }\n        const textWidth = context.measureText(value).width;\n        return Math.ceil(textWidth) + cellPadding;\n      })\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, maxWidth, 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    const colSize = cellSizeCache[col];\n    if (!colSize) {\n      return accu;\n    }\n\n    let size = colSize.row;\n    if (colSize.row < colSize.header && remaining > 0) {\n      // if we are cutting off the header, expand to fit it\n      size =\n        colSize.header - colSize.row < remaining ? colSize.header : colSize.row + remaining;\n      remaining -= size - colSize.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    const lastCell = columnOrder[columnOrder.length - 1];\n    if (lastCell && expandedCellSize[lastCell] != null) {\n      expandedCellSize[lastCell] += remaining;\n    }\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/column-statistics-categoric.js

@@ -0,0 +1,33 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useMemo } from 'react';
+import styled from 'styled-components';
+import { isNumber } from '@kepler.gl/utils';
+import { ColumnStatisticsContainer, StatisticRowContainer, StatisticRow, StyledStatsName, TopPlotContainer, STATS_MARGIN, STATS_WIDTH, formatPercent } from './column-statistics-components';
+var StyledHighlightNumber = styled.div(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  font-size: 24px;\n  color: ", ";\n  width: 100%;\n  text-align: center;\n"])), function (props) {
+  return props.theme.activeColorLT;
+});
+var ColumnStatisticsCategorical = function ColumnStatisticsCategorical(_ref) {
+  var _ref$width = _ref.width,
+    width = _ref$width === void 0 ? STATS_WIDTH : _ref$width,
+    _ref$margin = _ref.margin,
+    margin = _ref$margin === void 0 ? STATS_MARGIN : _ref$margin,
+    uniqueValues = _ref.uniqueValues,
+    percentNulls = _ref.percentNulls;
+  var nullsRight = useMemo(function () {
+    return isNumber(percentNulls) ? formatPercent(percentNulls) : null;
+  }, [percentNulls]);
+  return /*#__PURE__*/React.createElement(ColumnStatisticsContainer, {
+    width: width,
+    margin: margin
+  }, /*#__PURE__*/React.createElement(TopPlotContainer, null, /*#__PURE__*/React.createElement(StatisticRowContainer, null, /*#__PURE__*/React.createElement(StyledStatsName, null, "Unique Values")), /*#__PURE__*/React.createElement(StyledHighlightNumber, null, uniqueValues)), /*#__PURE__*/React.createElement(StatisticRow, {
+    left: "Nulls",
+    isBad: isNumber(percentNulls) && percentNulls > 0,
+    right: nullsRight
+  }));
+};
+export default ColumnStatisticsCategorical;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/common/data-table/column-statistics-components.js

@@ -0,0 +1,59 @@
+import _taggedTemplateLiteral from "@babel/runtime/helpers/esm/taggedTemplateLiteral";
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React from 'react';
+import styled from 'styled-components';
+export var STATS_WIDTH = 180;
+export var STATS_MARGIN = {
+  top: 10,
+  left: 10,
+  right: 10,
+  bottom: 10
+};
+export var HISTOGRAM_MARGIN = {
+  top: 10,
+  left: 0,
+  right: 0,
+  bottom: 10
+};
+export var HISTOGRAM_HEIGHT = 50;
+export var ColumnStatisticsContainer = styled.div.withConfig({
+  shouldForwardProp: function shouldForwardProp(prop) {
+    return prop !== 'width' && prop !== 'margin';
+  }
+})(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  width: 100%;\n  box-sizing: border-box;\n  padding-top: ", "px;\n  padding-bottom: ", "px;\n  padding-left: ", "px;\n  padding-right: ", "px;\n  hr {\n    border: 0;\n    border-top: 1px solid ", ";\n    margin: 8px 0;\n  }\n"])), function (props) {
+  return props.margin.top;
+}, function (props) {
+  return props.margin.bottom;
+}, function (props) {
+  return props.margin.left;
+}, function (props) {
+  return props.margin.right;
+}, function (props) {
+  return props.theme.cellBorderColor;
+});
+export var StatisticRowContainer = styled.div(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n  display: flex;\n  justify-content: space-between;\n  align-items: baseline;\n  column-gap: 8px;\n  flex-wrap: wrap;\n  margin-bottom: 8px;\n  font-size: ", "px;\n  line-height: 1.2;\n  &:last-child {\n    margin-bottom: 0;\n  }\n"])), function (props) {
+  return props.theme.cellFontSize;
+});
+export var StyledStatsName = styled.div(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["\n  flex-shrink: 0;\n  color: ", ";\n"])), function (props) {
+  var _props$theme$notifica;
+  return props.$isBad ? ((_props$theme$notifica = props.theme.notificationColors) === null || _props$theme$notifica === void 0 ? void 0 : _props$theme$notifica.error) || '#f25138' : props.theme.subtextColor;
+});
+export var StyledStatsValue = styled.div(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["\n  color: ", ";\n  white-space: nowrap;\n  text-align: right;\n  margin-left: auto;\n"])), function (props) {
+  return props.theme.dataTableTextColor;
+});
+export var TopPlotContainer = styled.div(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["\n  margin-bottom: 12px;\n  height: ", "px;\n"])), HISTOGRAM_HEIGHT + HISTOGRAM_MARGIN.top + HISTOGRAM_MARGIN.bottom);
+export var StatisticRow = function StatisticRow(_ref) {
+  var left = _ref.left,
+    isBad = _ref.isBad,
+    right = _ref.right;
+  return /*#__PURE__*/React.createElement(StatisticRowContainer, null, /*#__PURE__*/React.createElement(StyledStatsName, {
+    $isBad: isBad
+  }, left), typeof right === 'string' ? /*#__PURE__*/React.createElement(StyledStatsValue, null, right) : null);
+};
+export function formatPercent(n) {
+  return "".concat((n * 100).toFixed(1), "%");
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/esm/common/data-table/column-statistics-numeric.js

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useMemo } from 'react';
+import { formatNumber, isNumber, roundToFour } from '@kepler.gl/utils';
+import HistogramPlotFactory from '../histogram-plot';
+import { STATS_WIDTH, STATS_MARGIN, HISTOGRAM_MARGIN, HISTOGRAM_HEIGHT, TopPlotContainer, ColumnStatisticsContainer, StatisticRow, formatPercent } from './column-statistics-components';
+var VALUE = [-Infinity, Infinity];
+ColumnStatisticsNumericFactory.deps = [HistogramPlotFactory];
+function ColumnStatisticsNumericFactory(HistogramPlot) {
+  var ColumnStatisticsNumeric = function ColumnStatisticsNumeric(_ref) {
+    var bins = _ref.bins,
+      _ref$quantiles = _ref.quantiles,
+      quantiles = _ref$quantiles === void 0 ? [] : _ref$quantiles,
+      mean = _ref.mean,
+      std = _ref.std,
+      percentNulls = _ref.percentNulls,
+      _ref$width = _ref.width,
+      width = _ref$width === void 0 ? STATS_WIDTH : _ref$width,
+      _ref$margin = _ref.margin,
+      margin = _ref$margin === void 0 ? STATS_MARGIN : _ref$margin;
+    var histogramWidth = width - margin.left - margin.right;
+    var histogramsByGroup = useMemo(function () {
+      return {
+        bins: bins
+      };
+    }, [bins]);
+    var nullsRight = useMemo(function () {
+      return isNumber(percentNulls) ? formatPercent(percentNulls) : null;
+    }, [percentNulls]);
+    var meanRight = useMemo(function () {
+      return isNumber(mean) ? formatNumber(mean, 'real') : null;
+    }, [mean]);
+    var stdRight = useMemo(function () {
+      return isNumber(std) ? formatNumber(std, 'real') : null;
+    }, [std]);
+    var quantileDisplays = useMemo(function () {
+      return quantiles.map(function (row) {
+        return {
+          label: row.label,
+          value: isNumber(row.value) ? String(Number.isInteger(row.value) ? row.value : roundToFour(row.value)) : null
+        };
+      });
+    }, [quantiles]);
+    return /*#__PURE__*/React.createElement(ColumnStatisticsContainer, {
+      width: width,
+      margin: margin
+    }, /*#__PURE__*/React.createElement(TopPlotContainer, null, /*#__PURE__*/React.createElement(HistogramPlot, {
+      histogramsByGroup: histogramsByGroup,
+      margin: HISTOGRAM_MARGIN,
+      width: histogramWidth,
+      height: HISTOGRAM_HEIGHT,
+      value: VALUE
+    })), /*#__PURE__*/React.createElement(StatisticRow, {
+      left: "Nulls",
+      isBad: isNumber(percentNulls) && percentNulls > 0,
+      right: nullsRight
+    }), /*#__PURE__*/React.createElement(StatisticRow, {
+      left: "Mean",
+      right: meanRight
+    }), /*#__PURE__*/React.createElement(StatisticRow, {
+      left: "Std. Dev.",
+      right: stdRight
+    }), /*#__PURE__*/React.createElement("hr", null), /*#__PURE__*/React.createElement(StatisticRow, {
+      left: "Quantiles",
+      right: null
+    }), quantileDisplays.map(function (row, index) {
+      return /*#__PURE__*/React.createElement(StatisticRow, {
+        left: row.label,
+        right: row.value,
+        key: index
+      });
+    }));
+  };
+  return ColumnStatisticsNumeric;
+}
+export default ColumnStatisticsNumericFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMemo","formatNumber","isNumber","roundToFour","HistogramPlotFactory","STATS_WIDTH","STATS_MARGIN","HISTOGRAM_MARGIN","HISTOGRAM_HEIGHT","TopPlotContainer","ColumnStatisticsContainer","StatisticRow","formatPercent","VALUE","Infinity","ColumnStatisticsNumericFactory","deps","HistogramPlot","ColumnStatisticsNumeric","_ref","bins","_ref$quantiles","quantiles","mean","std","percentNulls","_ref$width","width","_ref$margin","margin","histogramWidth","left","right","histogramsByGroup","nullsRight","meanRight","stdRight","quantileDisplays","map","row","label","value","String","Number","isInteger","createElement","height","isBad","index","key"],"sources":["../../../../src/common/data-table/column-statistics-numeric.tsx"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport React, {useMemo} from 'react';\n\nimport {NumericColumnStats, formatNumber, isNumber, roundToFour} from '@kepler.gl/utils';\n\nimport HistogramPlotFactory, {HistogramPlotProps} from '../histogram-plot';\nimport {\n  STATS_WIDTH,\n  STATS_MARGIN,\n  HISTOGRAM_MARGIN,\n  HISTOGRAM_HEIGHT,\n  TopPlotContainer,\n  ColumnStatisticsContainer,\n  StatisticRow,\n  formatPercent\n} from './column-statistics-components';\n\nexport type ColumnStatisticsNumericProps = NumericColumnStats & {\n  width?: number;\n  margin?: {top: number; left: number; right: number; bottom: number};\n  type?: string;\n};\n\nconst VALUE = [-Infinity, Infinity];\n\nColumnStatisticsNumericFactory.deps = [HistogramPlotFactory];\nfunction ColumnStatisticsNumericFactory(\n  HistogramPlot: React.FC<HistogramPlotProps>\n): React.FC<ColumnStatisticsNumericProps> {\n  const ColumnStatisticsNumeric: React.FC<ColumnStatisticsNumericProps> = ({\n    bins,\n    quantiles = [],\n    mean,\n    std,\n    percentNulls,\n    width = STATS_WIDTH,\n    margin = STATS_MARGIN\n  }) => {\n    const histogramWidth = width - margin.left - margin.right;\n    const histogramsByGroup = useMemo(\n      () => ({\n        bins\n      }),\n      [bins]\n    );\n    const nullsRight = useMemo(\n      () => (isNumber(percentNulls) ? formatPercent(percentNulls) : null),\n      [percentNulls]\n    );\n    const meanRight = useMemo(() => (isNumber(mean) ? formatNumber(mean, 'real') : null), [mean]);\n    const stdRight = useMemo(() => (isNumber(std) ? formatNumber(std, 'real') : null), [std]);\n    const quantileDisplays = useMemo(\n      () =>\n        quantiles.map(row => ({\n          label: row.label,\n          value: isNumber(row.value)\n            ? String(Number.isInteger(row.value) ? row.value : roundToFour(row.value))\n            : null\n        })),\n      [quantiles]\n    );\n\n    return (\n      <ColumnStatisticsContainer width={width} margin={margin}>\n        <TopPlotContainer>\n          <HistogramPlot\n            histogramsByGroup={histogramsByGroup}\n            margin={HISTOGRAM_MARGIN}\n            width={histogramWidth}\n            height={HISTOGRAM_HEIGHT}\n            value={VALUE}\n          />\n        </TopPlotContainer>\n        <StatisticRow\n          left=\"Nulls\"\n          isBad={isNumber(percentNulls) && percentNulls > 0}\n          right={nullsRight}\n        />\n        <StatisticRow left=\"Mean\" right={meanRight} />\n        <StatisticRow left=\"Std. Dev.\" right={stdRight} />\n        <hr />\n        <StatisticRow left=\"Quantiles\" right={null} />\n        {quantileDisplays.map((row, index) => (\n          <StatisticRow left={row.label} right={row.value} key={index} />\n        ))}\n      </ColumnStatisticsContainer>\n    );\n  };\n\n  return ColumnStatisticsNumeric;\n}\nexport default ColumnStatisticsNumericFactory;\n"],"mappings":"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","ignoreList":[]}

package/dist/esm/common/data-table/column-statistics-time.js

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+import React, { useMemo } from 'react';
+import { datetimeFormatter, isNumber } from '@kepler.gl/utils';
+import HistogramPlotFactory from '../histogram-plot';
+import { STATS_WIDTH, STATS_MARGIN, HISTOGRAM_MARGIN, HISTOGRAM_HEIGHT, StatisticRow, ColumnStatisticsContainer, TopPlotContainer, formatPercent } from './column-statistics-components';
+var HISTOGRAM_VALUE = [-Infinity, Infinity];
+ColumnStatisticsTimeFactory.deps = [HistogramPlotFactory];
+function ColumnStatisticsTimeFactory(HistogramPlot) {
+  var ColumnStatisticsTime = function ColumnStatisticsTime(_ref) {
+    var bins = _ref.bins,
+      min = _ref.min,
+      max = _ref.max,
+      percentNulls = _ref.percentNulls,
+      _ref$width = _ref.width,
+      width = _ref$width === void 0 ? STATS_WIDTH : _ref$width,
+      _ref$margin = _ref.margin,
+      margin = _ref$margin === void 0 ? STATS_MARGIN : _ref$margin,
+      format = _ref.format;
+    var histogramWidth = width - margin.left - margin.right;
+    var histogramsByGroup = useMemo(function () {
+      return {
+        bins: bins
+      };
+    }, [bins]);
+    var nullsRight = useMemo(function () {
+      return isNumber(percentNulls) ? formatPercent(percentNulls) : null;
+    }, [percentNulls]);
+    var startRight = useMemo(function () {
+      return isNumber(min) ? datetimeFormatter(null)(format)(min) : null;
+    }, [min, format]);
+    var endRight = useMemo(function () {
+      return isNumber(max) ? datetimeFormatter(null)(format)(max) : null;
+    }, [max, format]);
+    return /*#__PURE__*/React.createElement(ColumnStatisticsContainer, {
+      width: width,
+      margin: margin
+    }, /*#__PURE__*/React.createElement(TopPlotContainer, null, /*#__PURE__*/React.createElement(HistogramPlot, {
+      histogramsByGroup: histogramsByGroup,
+      margin: HISTOGRAM_MARGIN,
+      width: histogramWidth,
+      height: HISTOGRAM_HEIGHT,
+      value: HISTOGRAM_VALUE
+    })), /*#__PURE__*/React.createElement(StatisticRow, {
+      left: "Nulls",
+      isBad: isNumber(percentNulls) && percentNulls > 0,
+      right: nullsRight
+    }), /*#__PURE__*/React.createElement(StatisticRow, {
+      left: "Start",
+      right: startRight
+    }), /*#__PURE__*/React.createElement(StatisticRow, {
+      left: "End",
+      right: endRight
+    }));
+  };
+  return ColumnStatisticsTime;
+}
+export default ColumnStatisticsTimeFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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