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

package/dist/position-utils.d.ts

@@ -0,0 +1,6 @@
+import { LayerColumn } from '@kepler.gl/types';
+import { DataContainerInterface } from './data-container-interface';
+export declare function getPositionFromHexValue(token: any): number[] | null;
+export declare function maybeHexToGeo(dc: DataContainerInterface, d: {
+    index: number;
+}, lat: LayerColumn, lng: LayerColumn): number[] | null;

package/dist/position-utils.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPositionFromHexValue = getPositionFromHexValue;
+exports.maybeHexToGeo = maybeHexToGeo;
+var _h3Js = require("h3-js");
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+function getPositionFromHexValue(token) {
+  var pos = (0, _h3Js.h3ToGeo)(token);
+  if (Array.isArray(pos) && pos.every(Number.isFinite)) {
+    return [pos[1], pos[0]];
+  }
+  return null;
+}
+function maybeHexToGeo(dc, d, lat, lng) {
+  // lat or lng column could be hex column
+  // we assume string value is hex and try to convert it to geo lat lng
+  var latVal = dc.valueAt(d.index, lat.fieldIdx);
+  var lngVal = dc.valueAt(d.index, lng.fieldIdx);
+  return typeof latVal === 'string' ? getPositionFromHexValue(latVal) : typeof lngVal === 'string' ? getPositionFromHexValue(lngVal) : null;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/projection-utils.d.ts

@@ -0,0 +1,22 @@
+import WebMercatorViewport from 'viewport-mercator-project';
+export declare const MAPBOX_TILE_SIZE = 512;
+/**
+ * bounds should be [minLng, minLat, maxLng, maxLat]
+ * @param {*} bounds
+ */
+export declare function validateBounds(bounds: any): any[] | null;
+export declare function getCenterAndZoomFromBounds(bounds: any, { width, height }: {
+    width: any;
+    height: any;
+}): {
+    zoom: number;
+    center: number[];
+} | null;
+/**
+ * Add extra info about screen space position and world position to the event.
+ * @param {*} event Event to normalize.
+ * @param {*} viewport Current viewport.
+ * @returns Normalized event with extra information compatible with React-map-gl MapLayerMouseEvent
+ * https://visgl.github.io/react-map-gl/docs/api-reference/types#maplayermouseevent
+ */
+export declare function normalizeEvent(event: any, viewport: WebMercatorViewport): any;

package/dist/projection-utils.js

@@ -0,0 +1,83 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MAPBOX_TILE_SIZE = void 0;
+exports.getCenterAndZoomFromBounds = getCenterAndZoomFromBounds;
+exports.normalizeEvent = normalizeEvent;
+exports.validateBounds = validateBounds;
+var _geoViewport = _interopRequireDefault(require("@mapbox/geo-viewport"));
+var _console = _interopRequireDefault(require("global/console"));
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+var MAPBOX_TILE_SIZE = exports.MAPBOX_TILE_SIZE = 512;
+function isLat(num) {
+  return Number.isFinite(num) && num <= 90 && num >= -90;
+}
+function isLng(num) {
+  return Number.isFinite(num) && num <= 180 && num >= -180;
+}
+
+/**
+ * bounds should be [minLng, minLat, maxLng, maxLat]
+ * @param {*} bounds
+ */
+function validateBounds(bounds) {
+  // array: [ -180, -85.05112877980659, 180, 85.0511287798066 ]
+  // validate bounds
+  if (Array.isArray(bounds) && bounds.length === 4 && [bounds[0], bounds[2]].every(isLng) && [bounds[1], bounds[3]].every(isLat)) {
+    return bounds;
+  }
+  return null;
+}
+function getCenterAndZoomFromBounds(bounds, _ref) {
+  var width = _ref.width,
+    height = _ref.height;
+  var validBounds = validateBounds(bounds);
+  if (!validBounds) {
+    _console["default"].warn('invalid map bounds provided');
+    return null;
+  }
+
+  // viewport(bounds, dimensions, minzoom, maxzoom, tileSize, allowFloat)
+  var _geoViewport$viewport = _geoViewport["default"].viewport(bounds, [width, height], undefined, undefined, MAPBOX_TILE_SIZE),
+    zoom = _geoViewport$viewport.zoom;
+  // center being calculated by geo-vieweport.viewport has a complex logic that
+  // projects and then unprojects the coordinates to determine the center
+  // Calculating a simple average instead as that is the expected behavior in most of cases
+  var center = [(bounds[0] + bounds[2]) / 2, (bounds[1] + bounds[3]) / 2];
+  return {
+    zoom: zoom,
+    center: center
+  };
+}
+
+/**
+ * Add extra info about screen space position and world position to the event.
+ * @param {*} event Event to normalize.
+ * @param {*} viewport Current viewport.
+ * @returns Normalized event with extra information compatible with React-map-gl MapLayerMouseEvent
+ * https://visgl.github.io/react-map-gl/docs/api-reference/types#maplayermouseevent
+ */
+function normalizeEvent(event, viewport) {
+  var _event$target;
+  var bounds = (_event$target = event.target) === null || _event$target === void 0 ? void 0 : _event$target.getBoundingClientRect();
+  if (!bounds) {
+    return event;
+  }
+  var x = event.clientX - bounds.left;
+  var y = event.clientY - bounds.top;
+  if (!Number.isFinite(x) || !Number.isFinite(y)) {
+    return event;
+  }
+  event.point = [x, y];
+  var location = viewport.unproject(event.point, {
+    targetZ: 0
+  });
+  event.lngLat = [location[0], location[1]];
+  return event;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/quick-insertion-sort.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Inplace quick insertion sorting algorithm for numeric values
+ * 1. using a stack to eliminate recursion
+ * 2. sorting inplace to reduce memory usage
+ * 3. using insertion sort for small partition sizes
+ * The original source code is from:
+ * https://www.measurethat.net/Benchmarks/Show/3549/0/javascript-sorting-algorithms
+ * https://quick.work/?page=view-blog&id=24
+ *
+ * @param arr
+ */
+export default function quickInsertionSort(arr: number[]): void;

package/dist/quick-insertion-sort.js

@@ -0,0 +1,132 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = quickInsertionSort;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/**
+ * Inplace quick insertion sorting algorithm for numeric values
+ * 1. using a stack to eliminate recursion
+ * 2. sorting inplace to reduce memory usage
+ * 3. using insertion sort for small partition sizes
+ * The original source code is from:
+ * https://www.measurethat.net/Benchmarks/Show/3549/0/javascript-sorting-algorithms
+ * https://quick.work/?page=view-blog&id=24
+ *
+ * @param arr
+ */
+function quickInsertionSort(arr) {
+  if (!arr || arr.length < 1) {
+    return;
+  }
+  var stack = [];
+  stack.push([0, arr.length, 2 * Math.floor(Math.log(arr.length) / Math.log(2))]);
+  while (stack.length > 0) {
+    var _stack = (0, _slicedToArray2["default"])(stack[stack.length - 1], 3),
+      start = _stack[0],
+      end = _stack[1],
+      depth = _stack[2];
+    stack.pop();
+    if (depth === 0) {
+      // for worst case of quick sort: too many partitions
+      shellSortBound(arr, start, end);
+    } else {
+      var pivot = Math.round((start + end) / 2);
+      var pivotNewIndex = inplaceQuicksortPartition(arr, start, end, pivot);
+      // more than 32 elements: faster to be sorted in QuickSort partition
+      // less than 32 elements: faster to be sorted in InsertionSort
+      if (end - pivotNewIndex > 16) {
+        stack.push([pivotNewIndex, end, depth - 1]);
+      }
+      if (pivotNewIndex - start > 16) {
+        stack.push([start, pivotNewIndex, depth - 1]);
+      }
+    }
+  }
+  insertionSort(arr);
+}
+
+/**
+ * shellsort is a generalization of insertion sort
+ * shellsort perform best on partially sorted array
+ * Don't use shellsort on array (>10k)
+ * @param arr
+ * @param start
+ * @param end
+ *
+ * Learn more about Shellsort at https://en.wikipedia.org/wiki/Shellsort
+ */
+function shellSortBound(arr, start, end) {
+  if (arr.length <= 1) return;
+  var inc = Math.round((start + end) / 2);
+  var i;
+  var j;
+  var t;
+  while (inc > start) {
+    for (i = inc; i < end; i++) {
+      t = arr[i];
+      j = i;
+      while (j >= inc && arr[j - inc] > t) {
+        arr[j] = arr[j - inc];
+        j -= inc;
+      }
+      arr[j] = t;
+    }
+    inc = Math.round((inc - start) / 2.2 + start);
+  }
+}
+
+/**
+ * Insertion sort
+ * @param arr
+ */
+function insertionSort(arr) {
+  for (var i = 1, l = arr.length; i < l; i++) {
+    var value = arr[i];
+    var j = void 0;
+    for (j = i - 1; j >= 0; j--) {
+      if (arr[j] <= value) break;
+      arr[j + 1] = arr[j];
+    }
+    arr[j + 1] = value;
+  }
+}
+
+/**
+ * In-place quick sort
+ * @param arr
+ * @param start
+ * @param end
+ * @param pivotIndex
+ * @returns number
+ */
+function inplaceQuicksortPartition(arr, start, end, pivotIndex) {
+  var i = start;
+  var j = end;
+  var pivot = arr[pivotIndex];
+  var partition = true;
+  while (partition) {
+    while (arr[i] < pivot) {
+      i++;
+    }
+    j--;
+    while (pivot < arr[j]) {
+      j--;
+    }
+    if (!(i < j)) {
+      return i;
+    }
+    // swap(arr, i, j);
+    var t = arr[i];
+    arr[i] = arr[j];
+    arr[j] = t;
+    i++;
+  }
+  return i;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["quickInsertionSort","arr","length","stack","push","Math","floor","log","_stack","_slicedToArray2","start","end","depth","pop","shellSortBound","pivot","round","pivotNewIndex","inplaceQuicksortPartition","insertionSort","inc","i","j","t","l","value","pivotIndex","partition"],"sources":["../src/quick-insertion-sort.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n/**\n * Inplace quick insertion sorting algorithm for numeric values\n * 1. using a stack to eliminate recursion\n * 2. sorting inplace to reduce memory usage\n * 3. using insertion sort for small partition sizes\n * The original source code is from:\n * https://www.measurethat.net/Benchmarks/Show/3549/0/javascript-sorting-algorithms\n * https://quick.work/?page=view-blog&id=24\n *\n * @param arr\n */\nexport default function quickInsertionSort(arr: number[]): void {\n  if (!arr || arr.length < 1) {\n    return;\n  }\n  const stack: number[][] = [];\n  stack.push([0, arr.length, 2 * Math.floor(Math.log(arr.length) / Math.log(2))]);\n\n  while (stack.length > 0) {\n    const [start, end, depth] = stack[stack.length - 1];\n    stack.pop();\n\n    if (depth === 0) {\n      // for worst case of quick sort: too many partitions\n      shellSortBound(arr, start, end);\n    } else {\n      const pivot = Math.round((start + end) / 2);\n      const pivotNewIndex = inplaceQuicksortPartition(arr, start, end, pivot);\n      // more than 32 elements: faster to be sorted in QuickSort partition\n      // less than 32 elements: faster to be sorted in InsertionSort\n      if (end - pivotNewIndex > 16) {\n        stack.push([pivotNewIndex, end, depth - 1]);\n      }\n      if (pivotNewIndex - start > 16) {\n        stack.push([start, pivotNewIndex, depth - 1]);\n      }\n    }\n  }\n  insertionSort(arr);\n}\n\n/**\n * shellsort is a generalization of insertion sort\n * shellsort perform best on partially sorted array\n * Don't use shellsort on array (>10k)\n * @param arr\n * @param start\n * @param end\n *\n * Learn more about Shellsort at https://en.wikipedia.org/wiki/Shellsort\n */\nfunction shellSortBound(arr: number[], start: number, end: number) {\n  if (arr.length <= 1) return;\n  let inc = Math.round((start + end) / 2);\n  let i;\n  let j;\n  let t;\n\n  while (inc > start) {\n    for (i = inc; i < end; i++) {\n      t = arr[i];\n      j = i;\n      while (j >= inc && arr[j - inc] > t) {\n        arr[j] = arr[j - inc];\n        j -= inc;\n      }\n      arr[j] = t;\n    }\n    inc = Math.round((inc - start) / 2.2 + start);\n  }\n}\n\n/**\n * Insertion sort\n * @param arr\n */\nfunction insertionSort(arr: number[]) {\n  for (let i = 1, l = arr.length; i < l; i++) {\n    const value = arr[i];\n    let j;\n    for (j = i - 1; j >= 0; j--) {\n      if (arr[j] <= value) break;\n      arr[j + 1] = arr[j];\n    }\n    arr[j + 1] = value;\n  }\n}\n\n/**\n * In-place quick sort\n * @param arr\n * @param start\n * @param end\n * @param pivotIndex\n * @returns number\n */\nfunction inplaceQuicksortPartition(\n  arr: number[],\n  start: number,\n  end: number,\n  pivotIndex: number\n): number {\n  let i = start;\n  let j = end;\n  const pivot = arr[pivotIndex];\n  const partition = true;\n  while (partition) {\n    while (arr[i] < pivot) {\n      i++;\n    }\n    j--;\n    while (pivot < arr[j]) {\n      j--;\n    }\n    if (!(i < j)) {\n      return i;\n    }\n    // swap(arr, i, j);\n    const t = arr[i];\n    arr[i] = arr[j];\n    arr[j] = t;\n    i++;\n  }\n  return i;\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,31 @@
+import { DataRow, SharedRowOptions } from './data-row';
+import { ProtoDatasetField } from '@kepler.gl/types';
+import { DataContainerInterface, RangeOptions } from './data-container-interface';
+declare type RowDataContainerInput = {
+    rows: any[][];
+    fields?: ProtoDatasetField[];
+};
+/**
+ * A data container where all data is stored internally as a 2D array.
+ */
+export declare class RowDataContainer implements DataContainerInterface {
+    _rows: any[][];
+    _numColumns: number;
+    constructor(data: RowDataContainerInput);
+    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>;
+    flattenData(): any[][];
+    getPlainIndex(): number[];
+    map<T>(func: (row: DataRow, index: number) => T, sharedRow?: SharedRowOptions, options?: RangeOptions): T[];
+    mapIndex<T>(func: ({ index: number }: {
+        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;
+}
+export {};

package/dist/row-data-container.js

@@ -0,0 +1,206 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RowDataContainer = void 0;
+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 _dataRow = require("./data-row");
+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 internally as a 2D array.
+ */
+var RowDataContainer = exports.RowDataContainer = /*#__PURE__*/function () {
+  function RowDataContainer(data) {
+    var _data$rows$;
+    (0, _classCallCheck2["default"])(this, RowDataContainer);
+    (0, _defineProperty2["default"])(this, "_rows", void 0);
+    (0, _defineProperty2["default"])(this, "_numColumns", void 0);
+    if (!data.rows) {
+      throw Error('RowDataContainer: no rows provided');
+    }
+    if (!Array.isArray(data.rows)) {
+      throw Error("RowDataContainer: rows object isn't an array");
+    }
+    this._rows = data.rows;
+    this._numColumns = ((_data$rows$ = data.rows[0]) === null || _data$rows$ === void 0 ? void 0 : _data$rows$.length) || 0;
+  }
+  return (0, _createClass2["default"])(RowDataContainer, [{
+    key: "numRows",
+    value: function numRows() {
+      return this._rows.length;
+    }
+  }, {
+    key: "numColumns",
+    value: function numColumns() {
+      return this._numColumns;
+    }
+  }, {
+    key: "valueAt",
+    value: function valueAt(rowIndex, columnIndex) {
+      if (this._rows[rowIndex] === null) {
+        return null;
+      }
+      return this._rows[rowIndex][columnIndex];
+    }
+  }, {
+    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._rows[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: "flattenData",
+    value: function flattenData() {
+      return this._rows;
+    }
+  }, {
+    key: "getPlainIndex",
+    value: function getPlainIndex() {
+      return this._rows.map(function (_, i) {
+        return i;
+      });
+    }
+  }, {
+    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._rows.length; ++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._rows.length; ++rowIndex) {
+        var row = this.row(rowIndex, tSharedRow);
+        initialValue = func(initialValue, row, rowIndex);
+      }
+      return initialValue;
+    }
+  }]);
+}();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_dataRow","require","_marked","_regenerator","mark","rowsIterator","_marked2","columnIterator","dataContainer","sharedRow","numRows","rowIndex","wrap","rowsIterator$","_context","prev","next","row","stop","columnIndex","columnIterator$","_context2","valueAt","RowDataContainer","exports","data","_data$rows$","_classCallCheck2","_defineProperty2","rows","Error","Array","isArray","_rows","_numColumns","length","_createClass2","key","value","numColumns","tSharedRow","DataRow","createSharedRow","setSource","rowAsArray","column","flattenData","getPlainIndex","map","_","i","func","options","arguments","undefined","_options$start","start","_options$end","end","endRow","Math","min","out","push","mapIndex","_options$start2","_options$end2","index","find","reduce","initialValue"],"sources":["../src/row-data-container.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {DataRow, SharedRowOptions} from './data-row';\nimport {ProtoDatasetField} from '@kepler.gl/types';\nimport {DataContainerInterface, RangeOptions} from './data-container-interface';\n\ntype RowDataContainerInput = {\n  rows: any[][];\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 internally as a 2D array.\n */\nexport class RowDataContainer implements DataContainerInterface {\n  _rows: any[][];\n  _numColumns: number;\n\n  constructor(data: RowDataContainerInput) {\n    if (!data.rows) {\n      throw Error('RowDataContainer: no rows provided');\n    }\n\n    if (!Array.isArray(data.rows)) {\n      throw Error(\"RowDataContainer: rows object isn't an array\");\n    }\n\n    this._rows = data.rows;\n    this._numColumns = data.rows[0]?.length || 0;\n  }\n\n  numRows(): number {\n    return this._rows.length;\n  }\n\n  numColumns(): number {\n    return this._numColumns;\n  }\n\n  valueAt(rowIndex: number, columnIndex: number): any {\n    if (this._rows[rowIndex] === null) {\n      return null;\n    }\n    return this._rows[rowIndex][columnIndex];\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._rows[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  flattenData(): any[][] {\n    return this._rows;\n  }\n\n  getPlainIndex(): number[] {\n    return this._rows.map((_, i) => i);\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>(\n    func: ({index: number}, dc: DataContainerInterface) => T,\n    options: RangeOptions = {}\n  ): 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._rows.length; ++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._rows.length; ++rowIndex) {\n      const row = this.row(rowIndex, tSharedRow);\n      initialValue = func(initialValue, row, rowIndex);\n    }\n    return initialValue;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAGA,IAAAA,QAAA,GAAAC,OAAA;AAAqD,IAAAC,OAAA,gBAAAC,YAAA,YAAAC,IAAA,CAa3CC,YAAY;EAAAC,QAAA,gBAAAH,YAAA,YAAAC,IAAA,CAWZG,cAAc,GA3BxB;AACA;AAWA;AACA;AACA;AACA;AACA,SAAUF,YAAYA,CAACG,aAAqC,EAAEC,SAA2B;EAAA,IAAAC,OAAA,EAAAC,QAAA;EAAA,OAAAR,YAAA,YAAAS,IAAA,UAAAC,cAAAC,QAAA;IAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;MAAA;QACjFN,OAAO,GAAGF,aAAa,CAACE,OAAO,CAAC,CAAC;QAC9BC,QAAQ,GAAG,CAAC;MAAA;QAAA,MAAEA,QAAQ,GAAGD,OAAO;UAAAI,QAAA,CAAAE,IAAA;UAAA;QAAA;QAAAF,QAAA,CAAAE,IAAA;QACvC,OAAMR,aAAa,CAACS,GAAG,CAACN,QAAQ,EAAEF,SAAS,CAAC;MAAA;QADH,EAAEE,QAAQ;QAAAG,QAAA,CAAAE,IAAA;QAAA;MAAA;MAAA;QAAA,OAAAF,QAAA,CAAAI,IAAA;IAAA;EAAA,GAAAhB,OAAA;AAAA;;AAKvD;AACA;AACA;AACA;AACA,SAAUK,cAAcA,CAACC,aAAqC,EAAEW,WAAmB;EAAA,IAAAT,OAAA,EAAAC,QAAA;EAAA,OAAAR,YAAA,YAAAS,IAAA,UAAAQ,gBAAAC,SAAA;IAAA,kBAAAA,SAAA,CAAAN,IAAA,GAAAM,SAAA,CAAAL,IAAA;MAAA;QAC3EN,OAAO,GAAGF,aAAa,CAACE,OAAO,CAAC,CAAC;QAC9BC,QAAQ,GAAG,CAAC;MAAA;QAAA,MAAEA,QAAQ,GAAGD,OAAO;UAAAW,SAAA,CAAAL,IAAA;UAAA;QAAA;QAAAK,SAAA,CAAAL,IAAA;QACvC,OAAMR,aAAa,CAACc,OAAO,CAACX,QAAQ,EAAEQ,WAAW,CAAC;MAAA;QADT,EAAER,QAAQ;QAAAU,SAAA,CAAAL,IAAA;QAAA;MAAA;MAAA;QAAA,OAAAK,SAAA,CAAAH,IAAA;IAAA;EAAA,GAAAZ,QAAA;AAAA;;AAKvD;AACA;AACA;AAFA,IAGaiB,gBAAgB,GAAAC,OAAA,CAAAD,gBAAA;EAI3B,SAAAA,iBAAYE,IAA2B,EAAE;IAAA,IAAAC,WAAA;IAAA,IAAAC,gBAAA,mBAAAJ,gBAAA;IAAA,IAAAK,gBAAA;IAAA,IAAAA,gBAAA;IACvC,IAAI,CAACH,IAAI,CAACI,IAAI,EAAE;MACd,MAAMC,KAAK,CAAC,oCAAoC,CAAC;IACnD;IAEA,IAAI,CAACC,KAAK,CAACC,OAAO,CAACP,IAAI,CAACI,IAAI,CAAC,EAAE;MAC7B,MAAMC,KAAK,CAAC,8CAA8C,CAAC;IAC7D;IAEA,IAAI,CAACG,KAAK,GAAGR,IAAI,CAACI,IAAI;IACtB,IAAI,CAACK,WAAW,GAAG,EAAAR,WAAA,GAAAD,IAAI,CAACI,IAAI,CAAC,CAAC,CAAC,cAAAH,WAAA,uBAAZA,WAAA,CAAcS,MAAM,KAAI,CAAC;EAC9C;EAAC,WAAAC,aAAA,aAAAb,gBAAA;IAAAc,GAAA;IAAAC,KAAA,EAED,SAAA5B,OAAOA,CAAA,EAAW;MAChB,OAAO,IAAI,CAACuB,KAAK,CAACE,MAAM;IAC1B;EAAC;IAAAE,GAAA;IAAAC,KAAA,EAED,SAAAC,UAAUA,CAAA,EAAW;MACnB,OAAO,IAAI,CAACL,WAAW;IACzB;EAAC;IAAAG,GAAA;IAAAC,KAAA,EAED,SAAAhB,OAAOA,CAACX,QAAgB,EAAEQ,WAAmB,EAAO;MAClD,IAAI,IAAI,CAACc,KAAK,CAACtB,QAAQ,CAAC,KAAK,IAAI,EAAE;QACjC,OAAO,IAAI;MACb;MACA,OAAO,IAAI,CAACsB,KAAK,CAACtB,QAAQ,CAAC,CAACQ,WAAW,CAAC;IAC1C;EAAC;IAAAkB,GAAA;IAAAC,KAAA,EAED,SAAArB,GAAGA,CAACN,QAAgB,EAAEF,SAA4B,EAAW;MAC3D,IAAM+B,UAAU,GAAGC,gBAAO,CAACC,eAAe,CAACjC,SAAS,CAAC;MACrD,IAAI+B,UAAU,EAAE;QACdA,UAAU,CAACG,SAAS,CAAC,IAAI,EAAEhC,QAAQ,CAAC;QACpC,OAAO6B,UAAU;MACnB;MAEA,OAAO,IAAIC,gBAAO,CAAC,IAAI,EAAE9B,QAAQ,CAAC;IACpC;EAAC;IAAA0B,GAAA;IAAAC,KAAA,EAED,SAAAM,UAAUA,CAACjC,QAAgB,EAAS;MAClC,OAAO,IAAI,CAACsB,KAAK,CAACtB,QAAQ,CAAC;IAC7B;EAAC;IAAA0B,GAAA;IAAAC,KAAA,EAED,SAAAT,IAAIA,CAACpB,SAA2B,EAAE;MAChC,IAAM+B,UAAU,GAAGC,gBAAO,CAACC,eAAe,CAACjC,SAAS,CAAC;MACrD,OAAOJ,YAAY,CAAC,IAAI,EAAEmC,UAAU,CAAC;IACvC;EAAC;IAAAH,GAAA;IAAAC,KAAA,EAED,SAAAO,MAAMA,CAAC1B,WAAmB,EAAE;MAC1B,OAAOZ,cAAc,CAAC,IAAI,EAAEY,WAAW,CAAC;IAC1C;EAAC;IAAAkB,GAAA;IAAAC,KAAA,EAED,SAAAQ,WAAWA,CAAA,EAAY;MACrB,OAAO,IAAI,CAACb,KAAK;IACnB;EAAC;IAAAI,GAAA;IAAAC,KAAA,EAED,SAAAS,aAAaA,CAAA,EAAa;MACxB,OAAO,IAAI,CAACd,KAAK,CAACe,GAAG,CAAC,UAACC,CAAC,EAAEC,CAAC;QAAA,OAAKA,CAAC;MAAA,EAAC;IACpC;EAAC;IAAAb,GAAA;IAAAC,KAAA,EAED,SAAAU,GAAGA,CACDG,IAAwC,EACxC1C,SAA4B,EAEvB;MAAA,IADL2C,OAAqB,GAAAC,SAAA,CAAAlB,MAAA,QAAAkB,SAAA,QAAAC,SAAA,GAAAD,SAAA,MAAG,CAAC,CAAC;MAE1B,IAAMb,UAAU,GAAGC,gBAAO,CAACC,eAAe,CAACjC,SAAS,CAAC;MAErD,IAAA8C,cAAA,GAA0CH,OAAO,CAA1CI,KAAK;QAALA,KAAK,GAAAD,cAAA,cAAG,CAAC,GAAAA,cAAA;QAAAE,YAAA,GAA0BL,OAAO,CAA/BM,GAAG;QAAHA,GAAG,GAAAD,YAAA,cAAG,IAAI,CAAC/C,OAAO,CAAC,CAAC,GAAA+C,YAAA;MACtC,IAAME,MAAM,GAAGC,IAAI,CAACC,GAAG,CAAC,IAAI,CAACnD,OAAO,CAAC,CAAC,EAAEgD,GAAG,CAAC;MAE5C,IAAMI,GAAQ,GAAG,EAAE;MACnB,KAAK,IAAInD,QAAQ,GAAG6C,KAAK,EAAE7C,QAAQ,GAAGgD,MAAM,EAAE,EAAEhD,QAAQ,EAAE;QACxD,IAAMM,GAAG,GAAG,IAAI,CAACA,GAAG,CAACN,QAAQ,EAAE6B,UAAU,CAAC;QAC1CsB,GAAG,CAACC,IAAI,CAACZ,IAAI,CAAClC,GAAG,EAAEN,QAAQ,CAAC,CAAC;MAC/B;MACA,OAAOmD,GAAG;IACZ;EAAC;IAAAzB,GAAA;IAAAC,KAAA,EAED,SAAA0B,QAAQA,CACNb,IAAwD,EAEnD;MAAA,IADLC,OAAqB,GAAAC,SAAA,CAAAlB,MAAA,QAAAkB,SAAA,QAAAC,SAAA,GAAAD,SAAA,MAAG,CAAC,CAAC;MAE1B,IAAAY,eAAA,GAA0Cb,OAAO,CAA1CI,KAAK;QAALA,KAAK,GAAAS,eAAA,cAAG,CAAC,GAAAA,eAAA;QAAAC,aAAA,GAA0Bd,OAAO,CAA/BM,GAAG;QAAHA,GAAG,GAAAQ,aAAA,cAAG,IAAI,CAACxD,OAAO,CAAC,CAAC,GAAAwD,aAAA;MACtC,IAAMP,MAAM,GAAGC,IAAI,CAACC,GAAG,CAAC,IAAI,CAACnD,OAAO,CAAC,CAAC,EAAEgD,GAAG,CAAC;MAE5C,IAAMI,GAAQ,GAAG,EAAE;MACnB,KAAK,IAAInD,QAAQ,GAAG6C,KAAK,EAAE7C,QAAQ,GAAGgD,MAAM,EAAE,EAAEhD,QAAQ,EAAE;QACxDmD,GAAG,CAACC,IAAI,CAACZ,IAAI,CAAC;UAACgB,KAAK,EAAExD;QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC;MACzC;MACA,OAAOmD,GAAG;IACZ;EAAC;IAAAzB,GAAA;IAAAC,KAAA,EAED,SAAA8B,IAAIA,CACFjB,IAA8C,EAC9C1C,SAA4B,EACP;MACrB,IAAM+B,UAAU,GAAGC,gBAAO,CAACC,eAAe,CAACjC,SAAS,CAAC;MAErD,KAAK,IAAIE,QAAQ,GAAG,CAAC,EAAEA,QAAQ,GAAG,IAAI,CAACsB,KAAK,CAACE,MAAM,EAAE,EAAExB,QAAQ,EAAE;QAC/D,IAAMM,GAAG,GAAG,IAAI,CAACA,GAAG,CAACN,QAAQ,EAAE6B,UAAU,CAAC;QAC1C,IAAIW,IAAI,CAAClC,GAAG,EAAEN,QAAQ,CAAC,EAAE;UACvB,OAAOM,GAAG;QACZ;MACF;MACA,OAAOqC,SAAS;IAClB;EAAC;IAAAjB,GAAA;IAAAC,KAAA,EAED,SAAA+B,MAAMA,CACJlB,IAAgD,EAChDmB,YAAe,EACf7D,SAA4B,EACzB;MACH,IAAM+B,UAAU,GAAGC,gBAAO,CAACC,eAAe,CAACjC,SAAS,CAAC;MAErD,KAAK,IAAIE,QAAQ,GAAG,CAAC,EAAEA,QAAQ,GAAG,IAAI,CAACsB,KAAK,CAACE,MAAM,EAAE,EAAExB,QAAQ,EAAE;QAC/D,IAAMM,GAAG,GAAG,IAAI,CAACA,GAAG,CAACN,QAAQ,EAAE6B,UAAU,CAAC;QAC1C8B,YAAY,GAAGnB,IAAI,CAACmB,YAAY,EAAErD,GAAG,EAAEN,QAAQ,CAAC;MAClD;MACA,OAAO2D,YAAY;IACrB;EAAC;AAAA","ignoreList":[]}

package/dist/searcher-utils.d.ts

@@ -0,0 +1 @@
+export declare function simpleSearcher(autofillValues: any, page: any, query: any, cb: any): any;

package/dist/searcher-utils.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.simpleSearcher = simpleSearcher;
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+
+/* eslint-disable callback-return */
+function simpleSearcher(autofillValues, page, query, cb) {
+  var regex = new RegExp(query, 'i');
+  var foundQuery = false;
+  var matches = (autofillValues || []).filter(function _filter(item) {
+    var tag = item.name;
+    foundQuery = foundQuery || tag === query;
+    return tag && regex.test(tag);
+  });
+  if (cb) {
+    cb(matches);
+  }
+  return matches;
+}
+/* eslint-enable callback-return */
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJzaW1wbGVTZWFyY2hlciIsImF1dG9maWxsVmFsdWVzIiwicGFnZSIsInF1ZXJ5IiwiY2IiLCJyZWdleCIsIlJlZ0V4cCIsImZvdW5kUXVlcnkiLCJtYXRjaGVzIiwiZmlsdGVyIiwiX2ZpbHRlciIsIml0ZW0iLCJ0YWciLCJuYW1lIiwidGVzdCJdLCJzb3VyY2VzIjpbIi4uL3NyYy9zZWFyY2hlci11dGlscy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogTUlUXG4vLyBDb3B5cmlnaHQgY29udHJpYnV0b3JzIHRvIHRoZSBrZXBsZXIuZ2wgcHJvamVjdFxuXG4vKiBlc2xpbnQtZGlzYWJsZSBjYWxsYmFjay1yZXR1cm4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzaW1wbGVTZWFyY2hlcihhdXRvZmlsbFZhbHVlcywgcGFnZSwgcXVlcnksIGNiKSB7XG4gIGNvbnN0IHJlZ2V4ID0gbmV3IFJlZ0V4cChxdWVyeSwgJ2knKTtcbiAgbGV0IGZvdW5kUXVlcnkgPSBmYWxzZTtcbiAgY29uc3QgbWF0Y2hlcyA9IChhdXRvZmlsbFZhbHVlcyB8fCBbXSkuZmlsdGVyKGZ1bmN0aW9uIF9maWx0ZXIoaXRlbSkge1xuICAgIGNvbnN0IHRhZyA9IGl0ZW0ubmFtZTtcbiAgICBmb3VuZFF1ZXJ5ID0gZm91bmRRdWVyeSB8fCB0YWcgPT09IHF1ZXJ5O1xuICAgIHJldHVybiB0YWcgJiYgcmVnZXgudGVzdCh0YWcpO1xuICB9KTtcblxuICBpZiAoY2IpIHtcbiAgICBjYihtYXRjaGVzKTtcbiAgfVxuXG4gIHJldHVybiBtYXRjaGVzO1xufVxuLyogZXNsaW50LWVuYWJsZSBjYWxsYmFjay1yZXR1cm4gKi9cbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUE7QUFDQTs7QUFFQTtBQUNPLFNBQVNBLGNBQWNBLENBQUNDLGNBQWMsRUFBRUMsSUFBSSxFQUFFQyxLQUFLLEVBQUVDLEVBQUUsRUFBRTtFQUM5RCxJQUFNQyxLQUFLLEdBQUcsSUFBSUMsTUFBTSxDQUFDSCxLQUFLLEVBQUUsR0FBRyxDQUFDO0VBQ3BDLElBQUlJLFVBQVUsR0FBRyxLQUFLO0VBQ3RCLElBQU1DLE9BQU8sR0FBRyxDQUFDUCxjQUFjLElBQUksRUFBRSxFQUFFUSxNQUFNLENBQUMsU0FBU0MsT0FBT0EsQ0FBQ0MsSUFBSSxFQUFFO0lBQ25FLElBQU1DLEdBQUcsR0FBR0QsSUFBSSxDQUFDRSxJQUFJO0lBQ3JCTixVQUFVLEdBQUdBLFVBQVUsSUFBSUssR0FBRyxLQUFLVCxLQUFLO0lBQ3hDLE9BQU9TLEdBQUcsSUFBSVAsS0FBSyxDQUFDUyxJQUFJLENBQUNGLEdBQUcsQ0FBQztFQUMvQixDQUFDLENBQUM7RUFFRixJQUFJUixFQUFFLEVBQUU7SUFDTkEsRUFBRSxDQUFDSSxPQUFPLENBQUM7RUFDYjtFQUVBLE9BQU9BLE9BQU87QUFDaEI7QUFDQSIsImlnbm9yZUxpc3QiOltdfQ==

package/dist/split-map-utils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Add new layers to both existing maps
+ * @param {Object} splitMaps
+ * @param {Object|Array<Object>} layers
+ * @returns {Array<Object>} new splitMaps
+ */
+export declare function addNewLayersToSplitMap(splitMaps: any, layers: any): any;
+/**
+ * Remove an existing layer from split map settings
+ * @param {Object} splitMaps
+ * @param {Object} layer
+ * @returns {Object} Maps of custom layer objects
+ */
+export declare function removeLayerFromSplitMaps(splitMaps: any, layer: any): any;
+/**
+ * This method will compute the default maps layer settings
+ * based on the current layers visibility
+ * @param {Array<Object>} layers
+ * @returns {Array<Object>} layer visibility for each panel
+ */
+export declare function getInitialMapLayersForSplitMap(layers: any): any;
+/**
+ * This method will get default splitMap settings based on existing layers
+ * @param {Array<Object>} layers
+ * @param {Object} options
+ * @returns {Array<Object>} split map settings
+ */
+export declare function computeSplitMapLayers(layers: any, options?: {
+    duplicate: boolean;
+}): {
+    layers: any;
+}[];