@kepler.gl/utils 3.0.0-alpha.0 → 3.0.0-alpha.2

package/dist/aggregate-utils.js

@@ -1,23 +1,3 @@
-// Copyright (c) 2022 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
@@ -92,4 +72,4 @@ function aggregate(data, technique) {
       return data.length;
   }
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9hZ2dyZWdhdGUtdXRpbHMudHMiXSwibmFtZXMiOlsiZ2V0RnJlcXVlbmN5IiwiZGF0YSIsInJlZHVjZSIsInVuaXF1ZXMiLCJ2YWwiLCJnZXRNb2RlIiwib2NjdXIiLCJPYmplY3QiLCJrZXlzIiwicHJldiIsImtleSIsImFnZ3JlZ2F0ZSIsInRlY2huaXF1ZSIsIkFHR1JFR0FUSU9OX1RZUEVTIiwiYXZlcmFnZSIsImNvdW50VW5pcXVlIiwibGVuZ3RoIiwibW9kZSIsIm1heGltdW0iLCJtaW5pbXVtIiwibWVkaWFuIiwic3RkZXYiLCJzdW0iLCJ2YXJpYW5jZSJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBb0JBOztBQUNBOzs7Ozs7QUFFTyxJQUFNQSxZQUFZLEdBQUcsU0FBZkEsWUFBZSxDQUFBQyxJQUFJO0FBQUEsU0FDOUJBLElBQUksQ0FBQ0MsTUFBTCxDQUNFLFVBQUNDLE9BQUQsRUFBVUMsR0FBVjtBQUFBLDJDQUNLRCxPQURMLDRDQUVHQyxHQUZILEVBRVMsQ0FBQ0QsT0FBTyxDQUFDQyxHQUFELENBQVAsSUFBZ0IsQ0FBakIsSUFBc0IsQ0FGL0I7QUFBQSxHQURGLEVBS0UsRUFMRixDQUQ4QjtBQUFBLENBQXpCOzs7O0FBU0EsSUFBTUMsT0FBTyxHQUFHLFNBQVZBLE9BQVUsQ0FBQUosSUFBSSxFQUFJO0FBQzdCLE1BQU1LLEtBQUssR0FBR04sWUFBWSxDQUFDQyxJQUFELENBQTFCO0FBQ0EsU0FBT00sTUFBTSxDQUFDQyxJQUFQLENBQVlGLEtBQVosRUFBbUJKLE1BQW5CLENBQ0wsVUFBQ08sSUFBRCxFQUFPQyxHQUFQO0FBQUEsV0FBZ0JKLEtBQUssQ0FBQ0csSUFBRCxDQUFMLElBQWVILEtBQUssQ0FBQ0ksR0FBRCxDQUFwQixHQUE0QkQsSUFBNUIsR0FBbUNDLEdBQW5EO0FBQUEsR0FESyxFQUVMSCxNQUFNLENBQUNDLElBQVAsQ0FBWUYsS0FBWixFQUFtQixDQUFuQixDQUZLLENBQVA7QUFJRCxDQU5NOzs7O0FBUUEsU0FBU0ssU0FBVCxDQUFtQlYsSUFBbkIsRUFBeUJXLFNBQXpCLEVBQW9DO0FBQ3pDLFVBQVFBLFNBQVI7QUFDRSxTQUFLQyw2QkFBa0JDLE9BQXZCO0FBQ0UsYUFBTyxtQkFBS2IsSUFBTCxDQUFQOztBQUNGLFNBQUtZLDZCQUFrQkUsV0FBdkI7QUFDRSxhQUFPUixNQUFNLENBQUNDLElBQVAsQ0FDTFAsSUFBSSxDQUFDQyxNQUFMLENBQVksVUFBQ0MsT0FBRCxFQUFVQyxHQUFWLEVBQWtCO0FBQzVCRCxRQUFBQSxPQUFPLENBQUNDLEdBQUQsQ0FBUCxHQUFlRCxPQUFPLENBQUNDLEdBQUQsQ0FBUCxJQUFnQixDQUEvQjtBQUNBRCxRQUFBQSxPQUFPLENBQUNDLEdBQUQsQ0FBUCxJQUFnQixDQUFoQjtBQUNBLGVBQU9ELE9BQVA7QUFDRCxPQUpELEVBSUcsRUFKSCxDQURLLEVBTUxhLE1BTkY7O0FBT0YsU0FBS0gsNkJBQWtCSSxJQUF2QjtBQUNFLGFBQU9aLE9BQU8sQ0FBQ0osSUFBRCxDQUFkOztBQUVGLFNBQUtZLDZCQUFrQkssT0FBdkI7QUFDRSxhQUFPLGtCQUFJakIsSUFBSixDQUFQOztBQUNGLFNBQUtZLDZCQUFrQk0sT0FBdkI7QUFDRSxhQUFPLGtCQUFJbEIsSUFBSixDQUFQOztBQUNGLFNBQUtZLDZCQUFrQk8sTUFBdkI7QUFDRSxhQUFPLHFCQUFPbkIsSUFBUCxDQUFQOztBQUNGLFNBQUtZLDZCQUFrQlEsS0FBdkI7QUFDRSxhQUFPLHdCQUFVcEIsSUFBVixDQUFQOztBQUNGLFNBQUtZLDZCQUFrQlMsR0FBdkI7QUFDRSxhQUFPLGtCQUFJckIsSUFBSixDQUFQOztBQUNGLFNBQUtZLDZCQUFrQlUsUUFBdkI7QUFDRSxhQUFPLHVCQUFTdEIsSUFBVCxDQUFQOztBQUNGO0FBQ0UsYUFBT0EsSUFBSSxDQUFDZSxNQUFaO0FBM0JKO0FBNkJEIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IChjKSAyMDIyIFViZXIgVGVjaG5vbG9naWVzLCBJbmMuXG4vL1xuLy8gUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24gb2J0YWluaW5nIGEgY29weVxuLy8gb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgXCJTb2Z0d2FyZVwiKSwgdG8gZGVhbFxuLy8gaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0c1xuLy8gdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNlbnNlLCBhbmQvb3Igc2VsbFxuLy8gY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3YXJlIGlzXG4vLyBmdXJuaXNoZWQgdG8gZG8gc28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOlxuLy9cbi8vIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluXG4vLyBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS5cbi8vXG4vLyBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgXCJBUyBJU1wiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9SXG4vLyBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSxcbi8vIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5HRU1FTlQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRVxuLy8gQVVUSE9SUyBPUiBDT1BZUklHSFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBPVEhFUlxuLy8gTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsIEFSSVNJTkcgRlJPTSxcbi8vIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVBTElOR1MgSU5cbi8vIFRIRSBTT0ZUV0FSRS5cblxuaW1wb3J0IHtkZXZpYXRpb24sIG1pbiwgbWF4LCBtZWFuLCBtZWRpYW4sIHN1bSwgdmFyaWFuY2V9IGZyb20gJ2QzLWFycmF5JztcbmltcG9ydCB7QUdHUkVHQVRJT05fVFlQRVN9IGZyb20gJ0BrZXBsZXIuZ2wvY29uc3RhbnRzJztcblxuZXhwb3J0IGNvbnN0IGdldEZyZXF1ZW5jeSA9IGRhdGEgPT5cbiAgZGF0YS5yZWR1Y2UoXG4gICAgKHVuaXF1ZXMsIHZhbCkgPT4gKHtcbiAgICAgIC4uLnVuaXF1ZXMsXG4gICAgICBbdmFsXTogKHVuaXF1ZXNbdmFsXSB8fCAwKSArIDFcbiAgICB9KSxcbiAgICB7fVxuICApO1xuXG5leHBvcnQgY29uc3QgZ2V0TW9kZSA9IGRhdGEgPT4ge1xuICBjb25zdCBvY2N1ciA9IGdldEZyZXF1ZW5jeShkYXRhKTtcbiAgcmV0dXJuIE9iamVjdC5rZXlzKG9jY3VyKS5yZWR1Y2UoXG4gICAgKHByZXYsIGtleSkgPT4gKG9jY3VyW3ByZXZdID49IG9jY3VyW2tleV0gPyBwcmV2IDoga2V5KSxcbiAgICBPYmplY3Qua2V5cyhvY2N1cilbMF1cbiAgKTtcbn07XG5cbmV4cG9ydCBmdW5jdGlvbiBhZ2dyZWdhdGUoZGF0YSwgdGVjaG5pcXVlKSB7XG4gIHN3aXRjaCAodGVjaG5pcXVlKSB7XG4gICAgY2FzZSBBR0dSRUdBVElPTl9UWVBFUy5hdmVyYWdlOlxuICAgICAgcmV0dXJuIG1lYW4oZGF0YSk7XG4gICAgY2FzZSBBR0dSRUdBVElPTl9UWVBFUy5jb3VudFVuaXF1ZTpcbiAgICAgIHJldHVybiBPYmplY3Qua2V5cyhcbiAgICAgICAgZGF0YS5yZWR1Y2UoKHVuaXF1ZXMsIHZhbCkgPT4ge1xuICAgICAgICAgIHVuaXF1ZXNbdmFsXSA9IHVuaXF1ZXNbdmFsXSB8fCAwO1xuICAgICAgICAgIHVuaXF1ZXNbdmFsXSArPSAxO1xuICAgICAgICAgIHJldHVybiB1bmlxdWVzO1xuICAgICAgICB9LCB7fSlcbiAgICAgICkubGVuZ3RoO1xuICAgIGNhc2UgQUdHUkVHQVRJT05fVFlQRVMubW9kZTpcbiAgICAgIHJldHVybiBnZXRNb2RlKGRhdGEpO1xuXG4gICAgY2FzZSBBR0dSRUdBVElPTl9UWVBFUy5tYXhpbXVtOlxuICAgICAgcmV0dXJuIG1heChkYXRhKTtcbiAgICBjYXNlIEFHR1JFR0FUSU9OX1RZUEVTLm1pbmltdW06XG4gICAgICByZXR1cm4gbWluKGRhdGEpO1xuICAgIGNhc2UgQUdHUkVHQVRJT05fVFlQRVMubWVkaWFuOlxuICAgICAgcmV0dXJuIG1lZGlhbihkYXRhKTtcbiAgICBjYXNlIEFHR1JFR0FUSU9OX1RZUEVTLnN0ZGV2OlxuICAgICAgcmV0dXJuIGRldmlhdGlvbihkYXRhKTtcbiAgICBjYXNlIEFHR1JFR0FUSU9OX1RZUEVTLnN1bTpcbiAgICAgIHJldHVybiBzdW0oZGF0YSk7XG4gICAgY2FzZSBBR0dSRUdBVElPTl9UWVBFUy52YXJpYW5jZTpcbiAgICAgIHJldHVybiB2YXJpYW5jZShkYXRhKTtcbiAgICBkZWZhdWx0OlxuICAgICAgcmV0dXJuIGRhdGEubGVuZ3RoO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,54 @@
+import * as arrow from 'apache-arrow';
+import { DATA_TYPES as AnalyzerDATA_TYPES } from 'type-analyzer';
+import { Field } from '@kepler.gl/types';
+import { DataRow, SharedRowOptions } from './data-row';
+import { DataContainerInterface, RangeOptions } from './data-container-interface';
+declare type ArrowDataContainerInput = {
+    cols: arrow.Vector[];
+    fields?: Field[];
+};
+/**
+ * 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: Field[];
+    _numChunks: number;
+    constructor(data: ArrowDataContainerInput);
+    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): Field;
+    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,360 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.arrowDataTypeToFieldType = arrowDataTypeToFieldType;
+exports.arrowDataTypeToAnalyzerDataType = arrowDataTypeToAnalyzerDataType;
+exports.ArrowDataContainer = void 0;
+
+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");
+
+var _marked = /*#__PURE__*/_regenerator["default"].mark(rowsIterator),
+    _marked2 = /*#__PURE__*/_regenerator["default"].mark(columnIterator);
+
+/**
+ * @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 = /*#__PURE__*/function () {
+  // cache column data to make valueAt() faster
+  // _colData: any[][];
+  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);
+
+    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());
+  }
+
+  (0, _createClass2["default"])(ArrowDataContainer, [{
+    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; // 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 _row2 = this.row(rowIndex, tSharedRow);
+
+        if (func(_row2, rowIndex)) {
+          return _row2;
+        }
+      }
+
+      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 _row3 = this.row(rowIndex, tSharedRow);
+
+        initialValue = func(initialValue, _row3, rowIndex);
+      }
+
+      return initialValue;
+    }
+  }]);
+  return ArrowDataContainer;
+}();
+/**
+ * Convert arrow data type to kepler.gl field types
+ *
+ * @param arrowType the arrow data type
+ * @returns corresponding type in `ALL_FIELD_TYPES`
+ */
+
+
+exports.ArrowDataContainer = ArrowDataContainer;
+
+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;
+  } else {
+    _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;
+  } else {
+    _window.console.warn("Unsupported arrow type: ".concat(arrowType));
+
+    return _typeAnalyzer.DATA_TYPES.STRING;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/arrow-data-container.ts"],"names":["rowsIterator","columnIterator","dataContainer","sharedRow","numRows","rowIndex","row","columnIndex","valueAt","ArrowDataContainer","data","cols","Error","Array","isArray","_cols","_numColumns","length","_numRows","_fields","fields","_numChunks","updateData","get","tSharedRow","DataRow","createSharedRow","setSource","map","col","i","push","rowAsArray","keys","func","options","start","end","endRow","Math","min","out","index","undefined","initialValue","arrowDataTypeToFieldType","arrowType","arrow","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","arrowDataTypeToAnalyzerDataType","AnalyzerDATA_TYPES","DATE","DATETIME","FLOAT","INT","BOOLEAN","STRING","OBJECT"],"mappings":"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","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 {Field} 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?: Field[];\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: Field[];\n  _numChunks: number;\n  // cache column data to make valueAt() faster\n  // _colData: any[][];\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\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    // 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): Field {\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  } else {\n    globalConsole.warn(`Unsupported arrow type: ${arrowType}`);\n    return ALL_FIELD_TYPES.string;\n  }\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  } else {\n    globalConsole.warn(`Unsupported arrow type: ${arrowType}`);\n    return AnalyzerDATA_TYPES.STRING;\n  }\n}\n"]}

package/dist/color-utils.d.ts

@@ -36,8 +36,16 @@ export declare function reverseColorRange(reversed: boolean, colorRange: ColorRa
  * @return
  */
 export declare function createLinearGradient(direction: string, colors: RGBColor[]): string;
+/**
+ * Convert color to RGB
+ */
+export declare function colorMaybeToRGB(color: unknown): RGBColor | null;
 /**
  * Whether color is rgb
  * @returns
  */
 export declare function isRgbColor(color: unknown): boolean;
+/**
+ * Take color values in 0-255 range and map to [0, 1]
+ */
+export declare function normalizeColor(color: number[]): number[];

package/dist/color-utils.js

@@ -1,23 +1,3 @@
-// Copyright (c) 2022 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
@@ -31,15 +11,21 @@ exports.rgbToHex = rgbToHex;
 exports.getColorGroupByName = getColorGroupByName;
 exports.reverseColorRange = reverseColorRange;
 exports.createLinearGradient = createLinearGradient;
+exports.colorMaybeToRGB = colorMaybeToRGB;
 exports.isRgbColor = isRgbColor;
+exports.normalizeColor = normalizeColor;
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 
+var _d3Color = require("d3-color");
+
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }/**
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+/**
  * get r g b from hex code
  *
  * @param hex
@@ -131,6 +117,26 @@ function createLinearGradient(direction, colors) {
   });
   return "linear-gradient(to ".concat(direction, ", ").concat(bands.join(','), ")");
 }
+/**
+ * Convert color to RGB
+ */
+
+
+function colorMaybeToRGB(color) {
+  if (isRgbColor(color)) {
+    return color;
+  }
+
+  if (typeof color === 'string') {
+    var rgbObj = (0, _d3Color.rgb)(color);
+
+    if (Number.isFinite(rgbObj === null || rgbObj === void 0 ? void 0 : rgbObj.r) && Number.isFinite(rgbObj === null || rgbObj === void 0 ? void 0 : rgbObj.g) && Number.isFinite(rgbObj === null || rgbObj === void 0 ? void 0 : rgbObj.b)) {
+      return [rgbObj.r, rgbObj.g, rgbObj.b];
+    }
+  }
+
+  return null;
+}
 /**
  * Whether color is rgb
  * @returns
@@ -142,4 +148,14 @@ function isRgbColor(color) {
     return Number.isFinite(n) && n <= 255 && n >= 0;
   }));
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/color-utils.ts"],"names":["hexToRgb","hex","result","isHexColor","r","parseInt","g","b","exec","PadNum","c","toString","length","rgbToHex","map","n","join","toUpperCase","getColorGroupByName","colorRange","name","replace","reverseColorRange","reversed","colors","slice","reverse","createLinearGradient","direction","step","parseFloat","toFixed","bands","rgb","index","isRgbColor","color","Boolean","Array","isArray","every","Number","isFinite"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {ColorRange} from '@kepler.gl/constants';\nimport {HexColor, RGBColor} from '@kepler.gl/types';\n\n/**\n * get r g b from hex code\n *\n * @param hex\n * @returns array of r g bs\n */\nexport function hexToRgb(hex: string): RGBColor {\n  const result = isHexColor(hex);\n\n  if (!result) {\n    return [0, 0, 0];\n  }\n\n  const r = parseInt(result[1], 16);\n  const g = parseInt(result[2], 16);\n  const b = parseInt(result[3], 16);\n\n  return [r, g, b];\n}\n\nexport function isHexColor(hex: string): RegExpExecArray | null {\n  const result = /^#?([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})$/i.exec(hex);\n\n  return result;\n}\n\nfunction PadNum(c) {\n  const hex = c.toString(16);\n  return hex.length === 1 ? `0${hex}` : hex;\n}\n\n/**\n * get hex from r g b\n *\n * @param rgb\n * @returns hex string\n */\nexport function rgbToHex([r, g, b]: RGBColor): HexColor {\n  return `#${[r, g, b].map(n => PadNum(n)).join('')}`.toUpperCase();\n}\n\n/**\n * Get color group name by parsing name, discard step in the name\n * e.g. Global Warming 6 -> Global Warming\n *\n * @param {Object} colorRange\n * @return {string | null}\n */\nexport function getColorGroupByName(colorRange: ColorRange): string | null {\n  if (!colorRange || typeof colorRange.name !== 'string') {\n    return null;\n  }\n\n  return colorRange.name.replace(/\\b[^a-zA-Z]+$/, '');\n}\n\n/**\n * Get a reversed colorRange\n * @param reversed\n * @param colorRange\n */\nexport function reverseColorRange(reversed: boolean, colorRange: ColorRange): ColorRange | null {\n  if (!colorRange) return null;\n  // if (colorRange.reversed) return colorRange;\n  return {\n    ...colorRange,\n    reversed,\n    colors: colorRange.colors.slice().reverse()\n  };\n}\n\n/**\n * given a list of rgb arrays it will generate a linear gradient css rule\n * @param direction\n * @param colors\n * @return\n */\nexport function createLinearGradient(direction: string, colors: RGBColor[]) {\n  const step = parseFloat((100.0 / colors.length).toFixed(2));\n  const bands = colors.map((rgb, index) => {\n    return `rgba(${rgb.join(',')}, 1) ${step * index}%, rgba(${rgb.join(',')}, 1) ${step *\n      (index + 1)}%`;\n  });\n\n  return `linear-gradient(to ${direction}, ${bands.join(',')})`;\n}\n\n/**\n * Whether color is rgb\n * @returns\n */\nexport function isRgbColor(color: unknown): boolean {\n  return Boolean(\n    color &&\n      Array.isArray(color) &&\n      color.length === 3 &&\n      color.every(n => Number.isFinite(n) && n <= 255 && n >= 0)\n  );\n}\n"]}
+/**
+ * Take color values in 0-255 range and map to [0, 1]
+ */
+
+
+function normalizeColor(color) {
+  return color.map(function (component) {
+    return component / 255.0;
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/color-utils.ts"],"names":["hexToRgb","hex","result","isHexColor","r","parseInt","g","b","exec","PadNum","c","toString","length","rgbToHex","map","n","join","toUpperCase","getColorGroupByName","colorRange","name","replace","reverseColorRange","reversed","colors","slice","reverse","createLinearGradient","direction","step","parseFloat","toFixed","bands","rgb","index","colorMaybeToRGB","color","isRgbColor","rgbObj","Number","isFinite","Boolean","Array","isArray","every","normalizeColor","component"],"mappings":"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","sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {rgb as d3Rgb} from 'd3-color';\nimport {ColorRange} from '@kepler.gl/constants';\nimport {HexColor, RGBColor} from '@kepler.gl/types';\n\n/**\n * get r g b from hex code\n *\n * @param hex\n * @returns array of r g bs\n */\nexport function hexToRgb(hex: string): RGBColor {\n  const result = isHexColor(hex);\n\n  if (!result) {\n    return [0, 0, 0];\n  }\n\n  const r = parseInt(result[1], 16);\n  const g = parseInt(result[2], 16);\n  const b = parseInt(result[3], 16);\n\n  return [r, g, b];\n}\n\nexport function isHexColor(hex: string): RegExpExecArray | null {\n  const result = /^#?([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})$/i.exec(hex);\n\n  return result;\n}\n\nfunction PadNum(c) {\n  const hex = c.toString(16);\n  return hex.length === 1 ? `0${hex}` : hex;\n}\n\n/**\n * get hex from r g b\n *\n * @param rgb\n * @returns hex string\n */\nexport function rgbToHex([r, g, b]: RGBColor): HexColor {\n  return `#${[r, g, b].map(n => PadNum(n)).join('')}`.toUpperCase();\n}\n\n/**\n * Get color group name by parsing name, discard step in the name\n * e.g. Global Warming 6 -> Global Warming\n *\n * @param {Object} colorRange\n * @return {string | null}\n */\nexport function getColorGroupByName(colorRange: ColorRange): string | null {\n  if (!colorRange || typeof colorRange.name !== 'string') {\n    return null;\n  }\n\n  return colorRange.name.replace(/\\b[^a-zA-Z]+$/, '');\n}\n\n/**\n * Get a reversed colorRange\n * @param reversed\n * @param colorRange\n */\nexport function reverseColorRange(reversed: boolean, colorRange: ColorRange): ColorRange | null {\n  if (!colorRange) return null;\n  // if (colorRange.reversed) return colorRange;\n  return {\n    ...colorRange,\n    reversed,\n    colors: colorRange.colors.slice().reverse()\n  };\n}\n\n/**\n * given a list of rgb arrays it will generate a linear gradient css rule\n * @param direction\n * @param colors\n * @return\n */\nexport function createLinearGradient(direction: string, colors: RGBColor[]) {\n  const step = parseFloat((100.0 / colors.length).toFixed(2));\n  const bands = colors.map((rgb, index) => {\n    return `rgba(${rgb.join(',')}, 1) ${step * index}%, rgba(${rgb.join(',')}, 1) ${step *\n      (index + 1)}%`;\n  });\n\n  return `linear-gradient(to ${direction}, ${bands.join(',')})`;\n}\n\n/**\n * Convert color to RGB\n */\nexport function colorMaybeToRGB(color: unknown): RGBColor | null {\n  if (isRgbColor(color)) {\n    return color as RGBColor;\n  }\n\n  if (typeof color === 'string') {\n    const rgbObj = d3Rgb(color);\n    if (Number.isFinite(rgbObj?.r) && Number.isFinite(rgbObj?.g) && Number.isFinite(rgbObj?.b)) {\n      return [rgbObj.r, rgbObj.g, rgbObj.b];\n    }\n  }\n\n  return null;\n}\n\n/**\n * Whether color is rgb\n * @returns\n */\nexport function isRgbColor(color: unknown): boolean {\n  return Boolean(\n    color &&\n      Array.isArray(color) &&\n      color.length === 3 &&\n      color.every(n => Number.isFinite(n) && n <= 255 && n >= 0)\n  );\n}\n\n/**\n * Take color values in 0-255 range and map to [0, 1]\n */\nexport function normalizeColor(color: number[]): number[] {\n  return color.map(component => component / 255.0);\n}\n"]}