@carto/kepler.gl 0.0.1-alpha.map-libre

package/dist/utils/table-utils/indexed-data-container.js

@@ -0,0 +1,241 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IndexedDataContainer = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+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);
+
+/**
+ * @param {import('./data-container-interface').DataContainerInterface} dataContainer
+ * @param {number[]} indices
+ * @param {import('./data-row').SharedRowOptions} sharedRow
+ * @returns {Generator<DataRow, void, unknown>}
+ */
+function rowsIterator(dataContainer, indices, sharedRow) {
+  var numRows, rowIndex, mappedRowIndex;
+  return _regenerator["default"].wrap(function rowsIterator$(_context) {
+    while (1) {
+      switch (_context.prev = _context.next) {
+        case 0:
+          numRows = indices.length;
+          rowIndex = 0;
+
+        case 2:
+          if (!(rowIndex < numRows)) {
+            _context.next = 9;
+            break;
+          }
+
+          mappedRowIndex = indices[rowIndex];
+          _context.next = 6;
+          return dataContainer.row(mappedRowIndex, sharedRow);
+
+        case 6:
+          ++rowIndex;
+          _context.next = 2;
+          break;
+
+        case 9:
+        case "end":
+          return _context.stop();
+      }
+    }
+  }, _marked);
+}
+/**
+ * @param {import('./data-container-interface').DataContainerInterface} dataContainer
+ * @param {number[]} indices
+ * @param {number} columnIndex
+ * @returns {Generator<any, void, unknown>}
+ */
+
+
+function columnIterator(dataContainer, indices, columnIndex) {
+  var numRows, rowIndex, mappedRowIndex;
+  return _regenerator["default"].wrap(function columnIterator$(_context2) {
+    while (1) {
+      switch (_context2.prev = _context2.next) {
+        case 0:
+          numRows = indices.length;
+          rowIndex = 0;
+
+        case 2:
+          if (!(rowIndex < numRows)) {
+            _context2.next = 9;
+            break;
+          }
+
+          mappedRowIndex = indices[rowIndex];
+          _context2.next = 6;
+          return dataContainer.valueAt(mappedRowIndex, columnIndex);
+
+        case 6:
+          ++rowIndex;
+          _context2.next = 2;
+          break;
+
+        case 9:
+        case "end":
+          return _context2.stop();
+      }
+    }
+  }, _marked2);
+}
+
+var IndexedDataContainer = /*#__PURE__*/function () {
+  function IndexedDataContainer(parentDataContainer, indices) {
+    (0, _classCallCheck2["default"])(this, IndexedDataContainer);
+    this._parentDataContainer = parentDataContainer;
+    this._indices = indices;
+  }
+
+  (0, _createClass2["default"])(IndexedDataContainer, [{
+    key: "numRows",
+    value: function numRows() {
+      return this._indices.length;
+    }
+  }, {
+    key: "numColumns",
+    value: function numColumns() {
+      return this._parentDataContainer.numColumns();
+    }
+    /**
+     * Remaps a local index to an index in the parent dataset
+     * @param {number} rowIndex
+     * @returns number
+     */
+
+  }, {
+    key: "_mappedRowIndex",
+    value: function _mappedRowIndex(rowIndex) {
+      return this._indices[rowIndex];
+    }
+  }, {
+    key: "valueAt",
+    value: function valueAt(rowIndex, columnIndex) {
+      return this._parentDataContainer.valueAt(this._mappedRowIndex(rowIndex), columnIndex);
+    }
+  }, {
+    key: "row",
+    value: function row(rowIndex, sharedRow) {
+      return this._parentDataContainer.row(this._mappedRowIndex(rowIndex), sharedRow);
+    }
+  }, {
+    key: "rowAsArray",
+    value: function rowAsArray(rowIndex) {
+      return this._parentDataContainer.rowAsArray(this._mappedRowIndex(rowIndex));
+    }
+  }, {
+    key: "rows",
+    value: function rows(sharedRow) {
+      return rowsIterator(this._parentDataContainer, this._indices, sharedRow);
+    }
+  }, {
+    key: "column",
+    value: function column(columnIndex) {
+      return columnIterator(this._parentDataContainer, this._indices, columnIndex);
+    }
+  }, {
+    key: "getPlainIndex",
+    value: function getPlainIndex() {
+      return this._indices.map(function (_, i) {
+        return i;
+      });
+    }
+  }, {
+    key: "flattenData",
+    value: function flattenData() {
+      var _this = this;
+
+      var tSharedRow = _dataRow.DataRow.createSharedRow(true);
+
+      return this._indices.map(function (_, i) {
+        return _this.row(i, tSharedRow).values();
+      }, this);
+    }
+  }, {
+    key: "map",
+    value: function map(func, sharedRow) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      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 tSharedRow = _dataRow.DataRow.createSharedRow(sharedRow);
+
+      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: this._mappedRowIndex(rowIndex)
+        }, this._parentDataContainer));
+      }
+
+      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._indices.length; ++rowIndex) {
+        var row = this.row(rowIndex, tSharedRow);
+        initialValue = func(initialValue, row, rowIndex);
+      }
+
+      return initialValue;
+    }
+  }]);
+  return IndexedDataContainer;
+}();
+
+exports.IndexedDataContainer = IndexedDataContainer;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/utils/table-utils/indexed-data-container.js"],"names":["rowsIterator","columnIterator","dataContainer","indices","sharedRow","numRows","length","rowIndex","mappedRowIndex","row","columnIndex","valueAt","IndexedDataContainer","parentDataContainer","_parentDataContainer","_indices","numColumns","_mappedRowIndex","rowAsArray","map","_","i","tSharedRow","DataRow","createSharedRow","values","func","options","start","end","endRow","Math","min","out","push","index","undefined","initialValue"],"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 {DataRow} from './data-row';\n\n/**\n * @param {import('./data-container-interface').DataContainerInterface} dataContainer\n * @param {number[]} indices\n * @param {import('./data-row').SharedRowOptions} sharedRow\n * @returns {Generator<DataRow, void, unknown>}\n */\nfunction* rowsIterator(dataContainer, indices, sharedRow) {\n  const numRows = indices.length;\n  for (let rowIndex = 0; rowIndex < numRows; ++rowIndex) {\n    const mappedRowIndex = indices[rowIndex];\n    yield dataContainer.row(mappedRowIndex, sharedRow);\n  }\n}\n\n/**\n * @param {import('./data-container-interface').DataContainerInterface} dataContainer\n * @param {number[]} indices\n * @param {number} columnIndex\n * @returns {Generator<any, void, unknown>}\n */\nfunction* columnIterator(dataContainer, indices, columnIndex) {\n  const numRows = indices.length;\n  for (let rowIndex = 0; rowIndex < numRows; ++rowIndex) {\n    const mappedRowIndex = indices[rowIndex];\n    yield dataContainer.valueAt(mappedRowIndex, columnIndex);\n  }\n}\n\nexport class IndexedDataContainer {\n  constructor(parentDataContainer, indices) {\n    this._parentDataContainer = parentDataContainer;\n    this._indices = indices;\n  }\n\n  numRows() {\n    return this._indices.length;\n  }\n\n  numColumns() {\n    return this._parentDataContainer.numColumns();\n  }\n\n  /**\n   * Remaps a local index to an index in the parent dataset\n   * @param {number} rowIndex\n   * @returns number\n   */\n  _mappedRowIndex(rowIndex) {\n    return this._indices[rowIndex];\n  }\n\n  valueAt(rowIndex, columnIndex) {\n    return this._parentDataContainer.valueAt(this._mappedRowIndex(rowIndex), columnIndex);\n  }\n\n  row(rowIndex, sharedRow) {\n    return this._parentDataContainer.row(this._mappedRowIndex(rowIndex), sharedRow);\n  }\n\n  rowAsArray(rowIndex) {\n    return this._parentDataContainer.rowAsArray(this._mappedRowIndex(rowIndex));\n  }\n\n  rows(sharedRow) {\n    return rowsIterator(this._parentDataContainer, this._indices, sharedRow);\n  }\n\n  column(columnIndex) {\n    return columnIterator(this._parentDataContainer, this._indices, columnIndex);\n  }\n\n  getPlainIndex() {\n    return this._indices.map((_, i) => i);\n  }\n\n  flattenData() {\n    const tSharedRow = DataRow.createSharedRow(true);\n\n    return this._indices.map((_, i) => {\n      return this.row(i, tSharedRow).values();\n    }, this);\n  }\n\n  map(func, sharedRow, options = {}) {\n    const {start = 0, end = this.numRows()} = options;\n    const endRow = Math.min(this.numRows(), end);\n\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    const out = [];\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(func, options = {}) {\n    const {start = 0, end = this.numRows()} = options;\n    const endRow = Math.min(this.numRows(), end);\n\n    const out = [];\n    for (let rowIndex = start; rowIndex < endRow; ++rowIndex) {\n      out.push(func({index: this._mappedRowIndex(rowIndex)}, this._parentDataContainer));\n    }\n    return out;\n  }\n\n  find(func, sharedRow) {\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(func, initialValue, sharedRow) {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    for (let rowIndex = 0; rowIndex < this._indices.length; ++rowIndex) {\n      const row = this.row(rowIndex, tSharedRow);\n      initialValue = func(initialValue, row, rowIndex);\n    }\n    return initialValue;\n  }\n}\n"]}