@kepler.gl/utils 3.1.0-alpha.1 → 3.1.0-alpha.2

package/dist/aggregation.d.ts

@@ -0,0 +1,13 @@
+import { ValueOf } from '@kepler.gl/types';
+import { AggregationTypes } from '@kepler.gl/constants';
+export declare const getFrequency: (data: any[], accessor?: (any: any) => any) => {
+    [key: string]: number;
+    [key: number]: number;
+};
+export declare const getMode: (data: any, accessor: any) => string;
+export declare const countUnique: (data: any, accessor?: (d: any) => any) => number;
+export declare const percentMean: (data: any, accessor: any) => number;
+export declare function aggregate(data: any[], technique: ValueOf<AggregationTypes>, accessor?: (any: any) => any): any;
+export declare const AGGREGATION_NAME: {
+    [key: string]: string;
+};

package/dist/aggregation.js

@@ -0,0 +1,84 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AGGREGATION_NAME = void 0;
+exports.aggregate = aggregate;
+exports.percentMean = exports.getMode = exports.getFrequency = exports.countUnique = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _d3Array = require("d3-array");
+var _constants = require("@kepler.gl/constants");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+var identity = function identity(d) {
+  return d;
+};
+var getFrequency = exports.getFrequency = function getFrequency(data) {
+  var accessor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : identity;
+  var occur = {};
+  for (var i = 0; i < data.length; i++) {
+    var val = accessor(data[i]);
+    occur[val] = (occur[val] || 0) + 1;
+  }
+  return occur;
+};
+var getMode = exports.getMode = function getMode(data, accessor) {
+  var occur = getFrequency(data, accessor);
+  return Object.keys(occur).reduce(function (prev, key) {
+    return occur[prev] >= occur[key] ? prev : key;
+  }, Object.keys(occur)[0]);
+};
+var countUnique = exports.countUnique = function countUnique(data) {
+  var accessor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : identity;
+  return Object.keys(data.reduce(function (uniques, d) {
+    var val = accessor(d);
+    uniques[val] = uniques[val] || 0;
+    uniques[val] += 1;
+    return uniques;
+  }, {})).length;
+};
+var percentMean = exports.percentMean = function percentMean(data, accessor) {
+  var getNumerator = accessor.getNumerator,
+    getDenominator = accessor.getDenominator;
+  var denominator = aggregate(data, _constants.AGGREGATION_TYPES.sum, getDenominator);
+  if (denominator <= 0) {
+    return 0;
+  }
+  var result = aggregate(data, _constants.AGGREGATION_TYPES.sum, getNumerator) / denominator;
+  return result;
+};
+function aggregate(data, technique) {
+  var accessor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : identity;
+  switch (technique) {
+    case _constants.AGGREGATION_TYPES.average:
+      return (0, _d3Array.mean)(data, accessor);
+    case 'mean_of_percent':
+      return percentMean(data, accessor);
+    case _constants.AGGREGATION_TYPES.countUnique:
+      return countUnique(data, accessor);
+    case _constants.AGGREGATION_TYPES.mode:
+      return getMode(data, accessor);
+    case _constants.AGGREGATION_TYPES.maximum:
+      return (0, _d3Array.max)(data, accessor);
+    case _constants.AGGREGATION_TYPES.minimum:
+      return (0, _d3Array.min)(data, accessor);
+    case _constants.AGGREGATION_TYPES.median:
+      return (0, _d3Array.median)(data, accessor);
+    case _constants.AGGREGATION_TYPES.stdev:
+      return (0, _d3Array.deviation)(data, accessor);
+    case _constants.AGGREGATION_TYPES.sum:
+      return (0, _d3Array.sum)(data, accessor);
+    case _constants.AGGREGATION_TYPES.variance:
+      return (0, _d3Array.variance)(data, accessor);
+    default:
+      return data.length;
+  }
+}
+var AGGREGATION_NAME = exports.AGGREGATION_NAME = (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _constants.AGGREGATION_TYPES.average, 'Average'), _constants.AGGREGATION_TYPES.countUnique, 'Number of Unique'), _constants.AGGREGATION_TYPES.mode, 'Most Often'), _constants.AGGREGATION_TYPES.maximum, 'Max'), _constants.AGGREGATION_TYPES.minimum, 'Min'), _constants.AGGREGATION_TYPES.median, 'Median'), _constants.AGGREGATION_TYPES.stdev, 'Std Deviation'), _constants.AGGREGATION_TYPES.sum, 'Total'), _constants.AGGREGATION_TYPES.variance, 'Variance');
+
+// ratio: both denominator & numerator precent
+// average, min, max, median,
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_d3Array","require","_constants","identity","d","getFrequency","exports","data","accessor","arguments","length","undefined","occur","i","val","getMode","Object","keys","reduce","prev","key","countUnique","uniques","percentMean","getNumerator","getDenominator","denominator","aggregate","AGGREGATION_TYPES","sum","result","technique","average","mean","mode","maximum","max","minimum","min","median","stdev","deviation","variance","AGGREGATION_NAME","_defineProperty2"],"sources":["../src/aggregation.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {deviation, min, max, mean, median, sum, variance} from 'd3-array';\nimport {ValueOf} from '@kepler.gl/types';\nimport {AGGREGATION_TYPES, AggregationTypes} from '@kepler.gl/constants';\nconst identity = d => d;\n\nexport const getFrequency = (\n  data: any[],\n  accessor: (any: any) => any = identity\n): {[key: string | number]: number} => {\n  const occur = {};\n  for (let i = 0; i < data.length; i++) {\n    const val = accessor(data[i]);\n    occur[val] = (occur[val] || 0) + 1;\n  }\n  return occur;\n};\n\nexport const getMode = (data, accessor) => {\n  const occur = getFrequency(data, accessor);\n  return Object.keys(occur).reduce(\n    (prev, key) => (occur[prev] >= occur[key] ? prev : key),\n    Object.keys(occur)[0]\n  );\n};\n\nexport const countUnique = (data, accessor = identity) => {\n  return Object.keys(\n    data.reduce((uniques, d) => {\n      const val = accessor(d);\n      uniques[val] = uniques[val] || 0;\n      uniques[val] += 1;\n      return uniques;\n    }, {})\n  ).length;\n};\n\nexport const percentMean = (data, accessor) => {\n  const {getNumerator, getDenominator} = accessor;\n  const denominator = aggregate(data, AGGREGATION_TYPES.sum, getDenominator);\n  if (denominator <= 0) {\n    return 0;\n  }\n  const result = aggregate(data, AGGREGATION_TYPES.sum, getNumerator) / denominator;\n  return result;\n};\n\nexport function aggregate(\n  data: any[],\n  technique: ValueOf<AggregationTypes>,\n  accessor: (any: any) => any = identity\n): any {\n  switch (technique) {\n    case AGGREGATION_TYPES.average:\n      return mean(data, accessor);\n    case 'mean_of_percent':\n      return percentMean(data, accessor);\n    case AGGREGATION_TYPES.countUnique:\n      return countUnique(data, accessor);\n    case AGGREGATION_TYPES.mode:\n      return getMode(data, accessor);\n    case AGGREGATION_TYPES.maximum:\n      return max(data, accessor);\n    case AGGREGATION_TYPES.minimum:\n      return min(data, accessor);\n    case AGGREGATION_TYPES.median:\n      return median(data, accessor);\n    case AGGREGATION_TYPES.stdev:\n      return deviation(data, accessor);\n    case AGGREGATION_TYPES.sum:\n      return sum(data, accessor);\n    case AGGREGATION_TYPES.variance:\n      return variance(data, accessor);\n    default:\n      return data.length;\n  }\n}\n\nexport const AGGREGATION_NAME: {\n  [key: string]: string;\n} = {\n  [AGGREGATION_TYPES.average]: 'Average',\n  [AGGREGATION_TYPES.countUnique]: 'Number of Unique',\n  [AGGREGATION_TYPES.mode]: 'Most Often',\n  [AGGREGATION_TYPES.maximum]: 'Max',\n  [AGGREGATION_TYPES.minimum]: 'Min',\n  [AGGREGATION_TYPES.median]: 'Median',\n  [AGGREGATION_TYPES.stdev]: 'Std Deviation',\n  [AGGREGATION_TYPES.sum]: 'Total',\n  [AGGREGATION_TYPES.variance]: 'Variance'\n};\n\n// ratio: both denominator & numerator precent\n// average, min, max, median,\n"],"mappings":"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","ignoreList":[]}

package/dist/application-config.d.ts

@@ -0,0 +1,25 @@
+import { MapLib } from 'react-map-gl';
+export declare type MapLibInstance = MapLib<any>;
+/**
+ * A mechanism to override default Kepler values/settings so that we
+ * without having to make application-specific changes to the kepler repo.
+ */
+export declare type KeplerApplicationConfig<Map> = {
+    /** Default name of export HTML file, can be overridden by user */
+    defaultHtmlName?: string;
+    defaultImageName?: string;
+    defaultJsonName?: string;
+    defaultDataName?: string;
+    defaultExportJsonSettings?: {
+        hasData?: boolean;
+    };
+    getMapLib?: () => Promise<MapLibInstance>;
+    getMap?: (ref: any) => Map;
+    mapLibCssClass?: string;
+    mapLibName?: string;
+    mapLibUrl?: string;
+    plugins?: any[];
+    table?: any;
+};
+export declare const getApplicationConfig: () => Required<KeplerApplicationConfig<mapboxgl.Map>>;
+export declare function initApplicationConfig<M>(appConfig?: KeplerApplicationConfig<M>): void;

package/dist/application-config.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getApplicationConfig = void 0;
+exports.initApplicationConfig = initApplicationConfig;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != (0, _typeof2["default"])(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * A mechanism to override default Kepler values/settings so that we
+ * without having to make application-specific changes to the kepler repo.
+ */
+
+var DEFAULT_APPLICATION_CONFIG = {
+  defaultHtmlName: 'kepler.gl.html',
+  defaultImageName: 'kepler.gl.png',
+  defaultJsonName: 'kepler.gl.json',
+  defaultDataName: 'kepler.gl',
+  defaultExportJsonSettings: {
+    hasData: true
+  },
+  getMapLib: function getMapLib() {
+    return Promise.resolve().then(function () {
+      return _interopRequireWildcard(require('maplibre-gl'));
+    });
+  },
+  getMap: function getMap(mapRef) {
+    return mapRef === null || mapRef === void 0 ? void 0 : mapRef.getMap();
+  },
+  mapLibCssClass: 'maplibregl',
+  mapLibName: 'MapLibre',
+  mapLibUrl: 'https://www.maplibre.org/',
+  plugins: [],
+  // The default table class is KeplerTable.
+  // TODO include KeplerTable here when the circular dependency with @kepler.gl/table and @kepler.gl/utils are resolved.
+  table: null
+};
+var applicationConfig = DEFAULT_APPLICATION_CONFIG;
+var getApplicationConfig = exports.getApplicationConfig = function getApplicationConfig() {
+  return applicationConfig;
+};
+function initApplicationConfig() {
+  var appConfig = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  Object.assign(applicationConfig, appConfig);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/arrow-data-container.d.ts

@@ -0,0 +1,62 @@
+import * as arrow from 'apache-arrow';
+import { DATA_TYPES as AnalyzerDATA_TYPES } from 'type-analyzer';
+import { ProtoDatasetField } from '@kepler.gl/types';
+import { DataRow, SharedRowOptions } from './data-row';
+import { DataContainerInterface, RangeOptions } from './data-container-interface';
+declare type ArrowDataContainerInput = {
+    cols: arrow.Vector[];
+    fields?: ProtoDatasetField[];
+};
+/**
+ * A data container where all data is stored in raw Arrow table
+ */
+export declare class ArrowDataContainer implements DataContainerInterface {
+    _cols: arrow.Vector[];
+    _numColumns: number;
+    _numRows: number;
+    _fields: ProtoDatasetField[];
+    _numChunks: number;
+    /** An arrow table recreated from vectors */
+    _arrowTable: arrow.Table;
+    constructor(data: ArrowDataContainerInput);
+    /**
+     * Restores internal Arrow table from vectors.
+     * TODO: consider using original arrow table, as it could contain extra metadata, not passed to the fields.
+     */
+    private _createTable;
+    getTable(): arrow.Table<any>;
+    update(updateData: arrow.Vector<any>[]): void;
+    numChunks(): number;
+    numRows(): number;
+    numColumns(): number;
+    valueAt(rowIndex: number, columnIndex: number): any;
+    row(rowIndex: number, sharedRow?: SharedRowOptions): DataRow;
+    rowAsArray(rowIndex: number): any[];
+    rows(sharedRow: SharedRowOptions): any;
+    column(columnIndex: number): Generator<any, void, unknown>;
+    getColumn(columnIndex: number): arrow.Vector;
+    getField(columnIndex: number): ProtoDatasetField;
+    flattenData(): any[][];
+    getPlainIndex(): number[];
+    map<T>(func: (row: DataRow, index: number) => T, sharedRow?: SharedRowOptions, options?: RangeOptions): T[];
+    mapIndex<T>(func: ({ index }: {
+        index: any;
+    }, dc: DataContainerInterface) => T, options?: RangeOptions): T[];
+    find(func: (row: DataRow, index: number) => boolean, sharedRow?: SharedRowOptions): DataRow | undefined;
+    reduce<T>(func: (acc: T, row: DataRow, index: number) => T, initialValue: T, sharedRow?: SharedRowOptions): T;
+}
+/**
+ * Convert arrow data type to kepler.gl field types
+ *
+ * @param arrowType the arrow data type
+ * @returns corresponding type in `ALL_FIELD_TYPES`
+ */
+export declare function arrowDataTypeToFieldType(arrowType: arrow.DataType): string;
+/**
+ * Convert arrow data type to analyzer type
+ *
+ * @param arrowType the arrow data type
+ * @returns corresponding type in `AnalyzerDATA_TYPES`
+ */
+export declare function arrowDataTypeToAnalyzerDataType(arrowType: arrow.DataType): typeof AnalyzerDATA_TYPES;
+export {};

package/dist/arrow-data-container.js

@@ -0,0 +1,331 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArrowDataContainer = void 0;
+exports.arrowDataTypeToAnalyzerDataType = arrowDataTypeToAnalyzerDataType;
+exports.arrowDataTypeToFieldType = arrowDataTypeToFieldType;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var arrow = _interopRequireWildcard(require("apache-arrow"));
+var _window = require("global/window");
+var _typeAnalyzer = require("type-analyzer");
+var _constants = require("@kepler.gl/constants");
+var _dataRow = require("./data-row");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+var _marked = /*#__PURE__*/_regenerator["default"].mark(rowsIterator),
+  _marked2 = /*#__PURE__*/_regenerator["default"].mark(columnIterator); // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+/**
+ * @param dataContainer
+ * @param sharedRow
+ */
+function rowsIterator(dataContainer, sharedRow) {
+  var numRows, rowIndex;
+  return _regenerator["default"].wrap(function rowsIterator$(_context) {
+    while (1) switch (_context.prev = _context.next) {
+      case 0:
+        numRows = dataContainer.numRows();
+        rowIndex = 0;
+      case 2:
+        if (!(rowIndex < numRows)) {
+          _context.next = 8;
+          break;
+        }
+        _context.next = 5;
+        return dataContainer.row(rowIndex, sharedRow);
+      case 5:
+        ++rowIndex;
+        _context.next = 2;
+        break;
+      case 8:
+      case "end":
+        return _context.stop();
+    }
+  }, _marked);
+}
+
+/**
+ * @param dataContainer
+ * @param columnIndex
+ */
+function columnIterator(dataContainer, columnIndex) {
+  var numRows, rowIndex;
+  return _regenerator["default"].wrap(function columnIterator$(_context2) {
+    while (1) switch (_context2.prev = _context2.next) {
+      case 0:
+        numRows = dataContainer.numRows();
+        rowIndex = 0;
+      case 2:
+        if (!(rowIndex < numRows)) {
+          _context2.next = 8;
+          break;
+        }
+        _context2.next = 5;
+        return dataContainer.valueAt(rowIndex, columnIndex);
+      case 5:
+        ++rowIndex;
+        _context2.next = 2;
+        break;
+      case 8:
+      case "end":
+        return _context2.stop();
+    }
+  }, _marked2);
+}
+
+/**
+ * A data container where all data is stored in raw Arrow table
+ */
+var ArrowDataContainer = exports.ArrowDataContainer = /*#__PURE__*/function () {
+  function ArrowDataContainer(data) {
+    (0, _classCallCheck2["default"])(this, ArrowDataContainer);
+    (0, _defineProperty2["default"])(this, "_cols", void 0);
+    (0, _defineProperty2["default"])(this, "_numColumns", void 0);
+    (0, _defineProperty2["default"])(this, "_numRows", void 0);
+    (0, _defineProperty2["default"])(this, "_fields", void 0);
+    (0, _defineProperty2["default"])(this, "_numChunks", void 0);
+    // cache column data to make valueAt() faster
+    // _colData: any[][];
+    /** An arrow table recreated from vectors */
+    (0, _defineProperty2["default"])(this, "_arrowTable", void 0);
+    if (!data.cols) {
+      throw Error('ArrowDataContainer: no columns provided');
+    }
+    if (!Array.isArray(data.cols)) {
+      throw Error("ArrowDataContainer: columns object isn't an array");
+    }
+    this._cols = data.cols;
+    this._numColumns = data.cols.length;
+    this._numRows = data.cols[0].length;
+    this._fields = data.fields || [];
+    this._numChunks = data.cols[0].data.length;
+    // this._colData = data.cols.map(c => c.toArray());
+
+    this._arrowTable = this._createTable();
+  }
+
+  /**
+   * Restores internal Arrow table from vectors.
+   * TODO: consider using original arrow table, as it could contain extra metadata, not passed to the fields.
+   */
+  return (0, _createClass2["default"])(ArrowDataContainer, [{
+    key: "_createTable",
+    value: function _createTable() {
+      var _this = this;
+      var creaOpts = {};
+      this._fields.map(function (field, index) {
+        creaOpts[field.name] = _this._cols[index];
+      });
+      return new arrow.Table(creaOpts);
+    }
+  }, {
+    key: "getTable",
+    value: function getTable() {
+      return this._arrowTable;
+    }
+  }, {
+    key: "update",
+    value: function update(updateData) {
+      this._cols = updateData;
+      this._numColumns = this._cols.length;
+      this._numRows = this._cols[0].length;
+      this._numChunks = this._cols[0].data.length;
+      this._arrowTable = this._createTable();
+
+      // cache column data to make valueAt() faster
+      // this._colData = this._cols.map(c => c.toArray());
+    }
+  }, {
+    key: "numChunks",
+    value: function numChunks() {
+      return this._numChunks;
+    }
+  }, {
+    key: "numRows",
+    value: function numRows() {
+      return this._numRows;
+    }
+  }, {
+    key: "numColumns",
+    value: function numColumns() {
+      return this._numColumns;
+    }
+  }, {
+    key: "valueAt",
+    value: function valueAt(rowIndex, columnIndex) {
+      // return this._colData[columnIndex][rowIndex];
+      return this._cols[columnIndex].get(rowIndex);
+    }
+  }, {
+    key: "row",
+    value: function row(rowIndex, sharedRow) {
+      var tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+      if (tSharedRow) {
+        tSharedRow.setSource(this, rowIndex);
+        return tSharedRow;
+      }
+      return new _dataRow.DataRow(this, rowIndex);
+    }
+  }, {
+    key: "rowAsArray",
+    value: function rowAsArray(rowIndex) {
+      // return this._colData.map(col => col[rowIndex]);
+      return this._cols.map(function (col) {
+        return col.get(rowIndex);
+      });
+    }
+  }, {
+    key: "rows",
+    value: function rows(sharedRow) {
+      var tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+      return rowsIterator(this, tSharedRow);
+    }
+  }, {
+    key: "column",
+    value: function column(columnIndex) {
+      return columnIterator(this, columnIndex);
+    }
+  }, {
+    key: "getColumn",
+    value: function getColumn(columnIndex) {
+      return this._cols[columnIndex];
+    }
+  }, {
+    key: "getField",
+    value: function getField(columnIndex) {
+      return this._fields[columnIndex];
+    }
+  }, {
+    key: "flattenData",
+    value: function flattenData() {
+      var data = [];
+      for (var i = 0; i < this._numRows; ++i) {
+        data.push(this.rowAsArray(i));
+      }
+      return data;
+    }
+  }, {
+    key: "getPlainIndex",
+    value: function getPlainIndex() {
+      return (0, _toConsumableArray2["default"])(Array(this._numRows).keys());
+    }
+  }, {
+    key: "map",
+    value: function map(func, sharedRow) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+      var _options$start = options.start,
+        start = _options$start === void 0 ? 0 : _options$start,
+        _options$end = options.end,
+        end = _options$end === void 0 ? this.numRows() : _options$end;
+      var endRow = Math.min(this.numRows(), end);
+      var out = [];
+      for (var rowIndex = start; rowIndex < endRow; ++rowIndex) {
+        var row = this.row(rowIndex, tSharedRow);
+        out.push(func(row, rowIndex));
+      }
+      return out;
+    }
+  }, {
+    key: "mapIndex",
+    value: function mapIndex(func) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var _options$start2 = options.start,
+        start = _options$start2 === void 0 ? 0 : _options$start2,
+        _options$end2 = options.end,
+        end = _options$end2 === void 0 ? this.numRows() : _options$end2;
+      var endRow = Math.min(this.numRows(), end);
+      var out = [];
+      for (var rowIndex = start; rowIndex < endRow; ++rowIndex) {
+        out.push(func({
+          index: rowIndex
+        }, this));
+      }
+      return out;
+    }
+  }, {
+    key: "find",
+    value: function find(func, sharedRow) {
+      var tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+      for (var rowIndex = 0; rowIndex < this._numRows; ++rowIndex) {
+        var row = this.row(rowIndex, tSharedRow);
+        if (func(row, rowIndex)) {
+          return row;
+        }
+      }
+      return undefined;
+    }
+  }, {
+    key: "reduce",
+    value: function reduce(func, initialValue, sharedRow) {
+      var tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+      for (var rowIndex = 0; rowIndex < this._numRows; ++rowIndex) {
+        var row = this.row(rowIndex, tSharedRow);
+        initialValue = func(initialValue, row, rowIndex);
+      }
+      return initialValue;
+    }
+  }]);
+}();
+/**
+ * Convert arrow data type to kepler.gl field types
+ *
+ * @param arrowType the arrow data type
+ * @returns corresponding type in `ALL_FIELD_TYPES`
+ */
+function arrowDataTypeToFieldType(arrowType) {
+  // Note: this function doesn't return ALL_FIELD_TYPES.geojson or ALL_FIELD_TYPES.array, which
+  // should be further detected by caller
+  if (arrow.DataType.isDate(arrowType)) {
+    return _constants.ALL_FIELD_TYPES.date;
+  } else if (arrow.DataType.isTimestamp(arrowType) || arrow.DataType.isTime(arrowType)) {
+    return _constants.ALL_FIELD_TYPES.timestamp;
+  } else if (arrow.DataType.isFloat(arrowType)) {
+    return _constants.ALL_FIELD_TYPES.real;
+  } else if (arrow.DataType.isInt(arrowType)) {
+    return _constants.ALL_FIELD_TYPES.integer;
+  } else if (arrow.DataType.isBool(arrowType)) {
+    return _constants.ALL_FIELD_TYPES["boolean"];
+  } else if (arrow.DataType.isUtf8(arrowType) || arrow.DataType.isNull(arrowType)) {
+    return _constants.ALL_FIELD_TYPES.string;
+  } else if (arrow.DataType.isBinary(arrowType) || arrow.DataType.isDictionary(arrowType) || arrow.DataType.isFixedSizeBinary(arrowType) || arrow.DataType.isFixedSizeList(arrowType) || arrow.DataType.isList(arrowType) || arrow.DataType.isMap(arrowType) || arrow.DataType.isStruct(arrowType)) {
+    return _constants.ALL_FIELD_TYPES.object;
+  }
+  _window.console.warn("Unsupported arrow type: ".concat(arrowType));
+  return _constants.ALL_FIELD_TYPES.string;
+}
+
+/**
+ * Convert arrow data type to analyzer type
+ *
+ * @param arrowType the arrow data type
+ * @returns corresponding type in `AnalyzerDATA_TYPES`
+ */
+function arrowDataTypeToAnalyzerDataType(arrowType) {
+  if (arrow.DataType.isDate(arrowType)) {
+    return _typeAnalyzer.DATA_TYPES.DATE;
+  } else if (arrow.DataType.isTimestamp(arrowType) || arrow.DataType.isTime(arrowType)) {
+    return _typeAnalyzer.DATA_TYPES.DATETIME;
+  } else if (arrow.DataType.isFloat(arrowType)) {
+    return _typeAnalyzer.DATA_TYPES.FLOAT;
+  } else if (arrow.DataType.isInt(arrowType)) {
+    return _typeAnalyzer.DATA_TYPES.INT;
+  } else if (arrow.DataType.isBool(arrowType)) {
+    return _typeAnalyzer.DATA_TYPES.BOOLEAN;
+  } else if (arrow.DataType.isUtf8(arrowType) || arrow.DataType.isNull(arrowType)) {
+    return _typeAnalyzer.DATA_TYPES.STRING;
+  } else if (arrow.DataType.isBinary(arrowType) || arrow.DataType.isDictionary(arrowType) || arrow.DataType.isFixedSizeBinary(arrowType) || arrow.DataType.isFixedSizeList(arrowType) || arrow.DataType.isList(arrowType) || arrow.DataType.isMap(arrowType) || arrow.DataType.isStruct(arrowType)) {
+    return _typeAnalyzer.DATA_TYPES.OBJECT;
+  }
+  _window.console.warn("Unsupported arrow type: ".concat(arrowType));
+  return _typeAnalyzer.DATA_TYPES.STRING;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["arrow","_interopRequireWildcard","require","_window","_typeAnalyzer","_constants","_dataRow","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","_marked","_regenerator","mark","rowsIterator","_marked2","columnIterator","dataContainer","sharedRow","numRows","rowIndex","wrap","rowsIterator$","_context","prev","next","row","stop","columnIndex","columnIterator$","_context2","valueAt","ArrowDataContainer","exports","data","_classCallCheck2","_defineProperty2","cols","Error","Array","isArray","_cols","_numColumns","length","_numRows","_fields","fields","_numChunks","_arrowTable","_createTable","_createClass2","key","value","_this","creaOpts","map","field","index","name","Table","getTable","update","updateData","numChunks","numColumns","tSharedRow","DataRow","createSharedRow","setSource","rowAsArray","col","rows","column","getColumn","getField","flattenData","push","getPlainIndex","_toConsumableArray2","keys","func","options","arguments","undefined","_options$start","start","_options$end","end","endRow","Math","min","out","mapIndex","_options$start2","_options$end2","find","reduce","initialValue","arrowDataTypeToFieldType","arrowType","DataType","isDate","ALL_FIELD_TYPES","date","isTimestamp","isTime","timestamp","isFloat","real","isInt","integer","isBool","isUtf8","isNull","string","isBinary","isDictionary","isFixedSizeBinary","isFixedSizeList","isList","isMap","isStruct","object","globalConsole","warn","concat","arrowDataTypeToAnalyzerDataType","AnalyzerDATA_TYPES","DATE","DATETIME","FLOAT","INT","BOOLEAN","STRING","OBJECT"],"sources":["../src/arrow-data-container.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport * as arrow from 'apache-arrow';\nimport {console as globalConsole} from 'global/window';\nimport {DATA_TYPES as AnalyzerDATA_TYPES} from 'type-analyzer';\nimport {ProtoDatasetField} from '@kepler.gl/types';\nimport {ALL_FIELD_TYPES} from '@kepler.gl/constants';\n\nimport {DataRow, SharedRowOptions} from './data-row';\nimport {DataContainerInterface, RangeOptions} from './data-container-interface';\n\ntype ArrowDataContainerInput = {\n  cols: arrow.Vector[];\n  fields?: ProtoDatasetField[];\n};\n\n/**\n * @param dataContainer\n * @param sharedRow\n */\nfunction* rowsIterator(dataContainer: DataContainerInterface, sharedRow: SharedRowOptions) {\n  const numRows = dataContainer.numRows();\n  for (let rowIndex = 0; rowIndex < numRows; ++rowIndex) {\n    yield dataContainer.row(rowIndex, sharedRow);\n  }\n}\n\n/**\n * @param dataContainer\n * @param columnIndex\n */\nfunction* columnIterator(dataContainer: DataContainerInterface, columnIndex: number) {\n  const numRows = dataContainer.numRows();\n  for (let rowIndex = 0; rowIndex < numRows; ++rowIndex) {\n    yield dataContainer.valueAt(rowIndex, columnIndex);\n  }\n}\n\n/**\n * A data container where all data is stored in raw Arrow table\n */\nexport class ArrowDataContainer implements DataContainerInterface {\n  _cols: arrow.Vector[];\n  _numColumns: number;\n  _numRows: number;\n  _fields: ProtoDatasetField[];\n  _numChunks: number;\n  // cache column data to make valueAt() faster\n  // _colData: any[][];\n\n  /** An arrow table recreated from vectors */\n  _arrowTable: arrow.Table;\n\n  constructor(data: ArrowDataContainerInput) {\n    if (!data.cols) {\n      throw Error('ArrowDataContainer: no columns provided');\n    }\n\n    if (!Array.isArray(data.cols)) {\n      throw Error(\"ArrowDataContainer: columns object isn't an array\");\n    }\n\n    this._cols = data.cols;\n    this._numColumns = data.cols.length;\n    this._numRows = data.cols[0].length;\n    this._fields = data.fields || [];\n    this._numChunks = data.cols[0].data.length;\n    // this._colData = data.cols.map(c => c.toArray());\n\n    this._arrowTable = this._createTable();\n  }\n\n  /**\n   * Restores internal Arrow table from vectors.\n   * TODO: consider using original arrow table, as it could contain extra metadata, not passed to the fields.\n   */\n  private _createTable() {\n    const creaOpts = {};\n    this._fields.map((field, index) => {\n      creaOpts[field.name] = this._cols[index];\n    });\n    return new arrow.Table(creaOpts);\n  }\n\n  getTable() {\n    return this._arrowTable;\n  }\n\n  update(updateData: arrow.Vector<any>[]) {\n    this._cols = updateData;\n    this._numColumns = this._cols.length;\n    this._numRows = this._cols[0].length;\n    this._numChunks = this._cols[0].data.length;\n\n    this._arrowTable = this._createTable();\n\n    // cache column data to make valueAt() faster\n    // this._colData = this._cols.map(c => c.toArray());\n  }\n\n  numChunks(): number {\n    return this._numChunks;\n  }\n\n  numRows(): number {\n    return this._numRows;\n  }\n\n  numColumns(): number {\n    return this._numColumns;\n  }\n\n  valueAt(rowIndex: number, columnIndex: number): any {\n    // return this._colData[columnIndex][rowIndex];\n    return this._cols[columnIndex].get(rowIndex);\n  }\n\n  row(rowIndex: number, sharedRow?: SharedRowOptions): DataRow {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n    if (tSharedRow) {\n      tSharedRow.setSource(this, rowIndex);\n      return tSharedRow;\n    }\n\n    return new DataRow(this, rowIndex);\n  }\n\n  rowAsArray(rowIndex: number): any[] {\n    // return this._colData.map(col => col[rowIndex]);\n    return this._cols.map(col => col.get(rowIndex));\n  }\n\n  rows(sharedRow: SharedRowOptions) {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n    return rowsIterator(this, tSharedRow);\n  }\n\n  column(columnIndex: number) {\n    return columnIterator(this, columnIndex);\n  }\n\n  getColumn(columnIndex: number): arrow.Vector {\n    return this._cols[columnIndex];\n  }\n\n  getField(columnIndex: number): ProtoDatasetField {\n    return this._fields[columnIndex];\n  }\n\n  flattenData(): any[][] {\n    const data: any[][] = [];\n    for (let i = 0; i < this._numRows; ++i) {\n      data.push(this.rowAsArray(i));\n    }\n    return data;\n  }\n\n  getPlainIndex(): number[] {\n    return [...Array(this._numRows).keys()];\n  }\n\n  map<T>(\n    func: (row: DataRow, index: number) => T,\n    sharedRow?: SharedRowOptions,\n    options: RangeOptions = {}\n  ): T[] {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    const {start = 0, end = this.numRows()} = options;\n    const endRow = Math.min(this.numRows(), end);\n\n    const out: T[] = [];\n    for (let rowIndex = start; rowIndex < endRow; ++rowIndex) {\n      const row = this.row(rowIndex, tSharedRow);\n      out.push(func(row, rowIndex));\n    }\n    return out;\n  }\n\n  mapIndex<T>(func: ({index}, dc: DataContainerInterface) => T, options: RangeOptions = {}): T[] {\n    const {start = 0, end = this.numRows()} = options;\n    const endRow = Math.min(this.numRows(), end);\n\n    const out: T[] = [];\n    for (let rowIndex = start; rowIndex < endRow; ++rowIndex) {\n      out.push(func({index: rowIndex}, this));\n    }\n    return out;\n  }\n\n  find(\n    func: (row: DataRow, index: number) => boolean,\n    sharedRow?: SharedRowOptions\n  ): DataRow | undefined {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    for (let rowIndex = 0; rowIndex < this._numRows; ++rowIndex) {\n      const row = this.row(rowIndex, tSharedRow);\n      if (func(row, rowIndex)) {\n        return row;\n      }\n    }\n    return undefined;\n  }\n\n  reduce<T>(\n    func: (acc: T, row: DataRow, index: number) => T,\n    initialValue: T,\n    sharedRow?: SharedRowOptions\n  ): T {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    for (let rowIndex = 0; rowIndex < this._numRows; ++rowIndex) {\n      const row = this.row(rowIndex, tSharedRow);\n      initialValue = func(initialValue, row, rowIndex);\n    }\n    return initialValue;\n  }\n}\n\n/**\n * Convert arrow data type to kepler.gl field types\n *\n * @param arrowType the arrow data type\n * @returns corresponding type in `ALL_FIELD_TYPES`\n */\nexport function arrowDataTypeToFieldType(arrowType: arrow.DataType): string {\n  // Note: this function doesn't return ALL_FIELD_TYPES.geojson or ALL_FIELD_TYPES.array, which\n  // should be further detected by caller\n  if (arrow.DataType.isDate(arrowType)) {\n    return ALL_FIELD_TYPES.date;\n  } else if (arrow.DataType.isTimestamp(arrowType) || arrow.DataType.isTime(arrowType)) {\n    return ALL_FIELD_TYPES.timestamp;\n  } else if (arrow.DataType.isFloat(arrowType)) {\n    return ALL_FIELD_TYPES.real;\n  } else if (arrow.DataType.isInt(arrowType)) {\n    return ALL_FIELD_TYPES.integer;\n  } else if (arrow.DataType.isBool(arrowType)) {\n    return ALL_FIELD_TYPES.boolean;\n  } else if (arrow.DataType.isUtf8(arrowType) || arrow.DataType.isNull(arrowType)) {\n    return ALL_FIELD_TYPES.string;\n  } else if (\n    arrow.DataType.isBinary(arrowType) ||\n    arrow.DataType.isDictionary(arrowType) ||\n    arrow.DataType.isFixedSizeBinary(arrowType) ||\n    arrow.DataType.isFixedSizeList(arrowType) ||\n    arrow.DataType.isList(arrowType) ||\n    arrow.DataType.isMap(arrowType) ||\n    arrow.DataType.isStruct(arrowType)\n  ) {\n    return ALL_FIELD_TYPES.object;\n  }\n  globalConsole.warn(`Unsupported arrow type: ${arrowType}`);\n  return ALL_FIELD_TYPES.string;\n}\n\n/**\n * Convert arrow data type to analyzer type\n *\n * @param arrowType the arrow data type\n * @returns corresponding type in `AnalyzerDATA_TYPES`\n */\nexport function arrowDataTypeToAnalyzerDataType(\n  arrowType: arrow.DataType\n): typeof AnalyzerDATA_TYPES {\n  if (arrow.DataType.isDate(arrowType)) {\n    return AnalyzerDATA_TYPES.DATE;\n  } else if (arrow.DataType.isTimestamp(arrowType) || arrow.DataType.isTime(arrowType)) {\n    return AnalyzerDATA_TYPES.DATETIME;\n  } else if (arrow.DataType.isFloat(arrowType)) {\n    return AnalyzerDATA_TYPES.FLOAT;\n  } else if (arrow.DataType.isInt(arrowType)) {\n    return AnalyzerDATA_TYPES.INT;\n  } else if (arrow.DataType.isBool(arrowType)) {\n    return AnalyzerDATA_TYPES.BOOLEAN;\n  } else if (arrow.DataType.isUtf8(arrowType) || arrow.DataType.isNull(arrowType)) {\n    return AnalyzerDATA_TYPES.STRING;\n  } else if (\n    arrow.DataType.isBinary(arrowType) ||\n    arrow.DataType.isDictionary(arrowType) ||\n    arrow.DataType.isFixedSizeBinary(arrowType) ||\n    arrow.DataType.isFixedSizeList(arrowType) ||\n    arrow.DataType.isList(arrowType) ||\n    arrow.DataType.isMap(arrowType) ||\n    arrow.DataType.isStruct(arrowType)\n  ) {\n    return AnalyzerDATA_TYPES.OBJECT;\n  }\n  globalConsole.warn(`Unsupported arrow type: ${arrowType}`);\n  return AnalyzerDATA_TYPES.STRING;\n}\n"],"mappings":"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","ignoreList":[]}