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

package/dist/utils/projection-utils.js

@@ -0,0 +1,83 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateBounds = validateBounds;
+exports.getCenterAndZoomFromBounds = getCenterAndZoomFromBounds;
+
+var _geoViewport = _interopRequireDefault(require("@mapbox/geo-viewport"));
+
+var _console = _interopRequireDefault(require("global/console"));
+
+// 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.
+var 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
+  };
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/utils/searcher-utils.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.simpleSearcher = simpleSearcher;
+
+// 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.
+
+/* 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,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

package/dist/utils/split-map-utils.js

@@ -0,0 +1,108 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof = require("@babel/runtime/helpers/typeof");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addNewLayersToSplitMap = addNewLayersToSplitMap;
+exports.removeLayerFromSplitMaps = removeLayerFromSplitMaps;
+exports.getInitialMapLayersForSplitMap = getInitialMapLayersForSplitMap;
+exports.computeSplitMapLayers = computeSplitMapLayers;
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
+
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+
+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; }
+
+/**
+ * Add new layers to both existing maps
+ * @param {Object} splitMaps
+ * @param {Object|Array<Object>} layers
+ * @returns {Array<Object>} new splitMaps
+ */
+function addNewLayersToSplitMap(splitMaps, layers) {
+  var newLayers = Array.isArray(layers) ? layers : [layers];
+
+  if (!splitMaps.length || !newLayers.length) {
+    return splitMaps;
+  } // add new layer to both maps,
+  // don't override, if layer.id is already in splitMaps
+
+
+  return splitMaps.map(function (settings) {
+    return _objectSpread(_objectSpread({}, settings), {}, {
+      layers: _objectSpread(_objectSpread({}, settings.layers), newLayers.reduce(function (accu, newLayer) {
+        return (// @ts-ignore
+          newLayer.id in settings.layers || !newLayer.config.isVisible ? accu : _objectSpread(_objectSpread({}, accu), {}, (0, _defineProperty2["default"])({}, newLayer.id, newLayer.config.isVisible))
+        );
+      }, {}))
+    });
+  });
+}
+/**
+ * Remove an existing layer from split map settings
+ * @param {Object} splitMaps
+ * @param {Object} layer
+ * @returns {Object} Maps of custom layer objects
+ */
+
+
+function removeLayerFromSplitMaps(splitMaps, layer) {
+  if (!splitMaps.length) {
+    return splitMaps;
+  }
+
+  return splitMaps.map(function (settings) {
+    // eslint-disable-next-line no-unused-vars
+    var _settings$layers = settings.layers,
+        _layer$id = layer.id,
+        _ = _settings$layers[_layer$id],
+        newLayers = (0, _objectWithoutProperties2["default"])(_settings$layers, [_layer$id].map(_toPropertyKey));
+    return _objectSpread(_objectSpread({}, settings), {}, {
+      layers: newLayers
+    });
+  });
+}
+/**
+ * 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
+ */
+
+
+function getInitialMapLayersForSplitMap(layers) {
+  return layers.filter(function (layer) {
+    return layer.config.isVisible;
+  }).reduce(function (newLayers, currentLayer) {
+    return _objectSpread(_objectSpread({}, newLayers), {}, (0, _defineProperty2["default"])({}, currentLayer.id, currentLayer.config.isVisible));
+  }, {});
+}
+/**
+ * This method will get default splitMap settings based on existing layers
+ * @param {Array<Object>} layers
+ * @returns {Array<Object>} split map settings
+ */
+
+
+function computeSplitMapLayers(layers) {
+  var mapLayers = getInitialMapLayersForSplitMap(layers);
+  return [{
+    layers: mapLayers
+  }, {
+    layers: (0, _lodash["default"])(mapLayers)
+  }];
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -0,0 +1,69 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDataContainer = createDataContainer;
+exports.createIndexedDataContainer = createIndexedDataContainer;
+exports.getSampleData = getSampleData;
+exports.DataForm = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _rowDataContainer = require("./row-data-container");
+
+var _indexedDataContainer = require("./indexed-data-container");
+
+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; }
+
+/** @type {import('./data-container-utils').DataForm} */
+var DataForm = {
+  ROWS_ARRAY: 'ROWS_ARRAY'
+};
+/** @type {import('./data-container-utils').DataContainerOptions} */
+
+exports.DataForm = DataForm;
+var defaultOptions = {
+  inputDataFormat: DataForm.ROWS_ARRAY
+};
+/** @type {typeof import('./data-container-utils').createDataContainer} */
+
+function createDataContainer(data) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultOptions;
+  options = _objectSpread(_objectSpread({}, defaultOptions), options);
+
+  if (options.inputDataFormat === DataForm.ROWS_ARRAY) {
+    return new _rowDataContainer.RowDataContainer({
+      rows: data,
+      fields: options.fields
+    });
+  }
+
+  throw Error('Failed to create a data container: not implemented format');
+}
+/** @type {typeof import('./data-container-utils').createIndexedDataContainer} */
+
+
+function createIndexedDataContainer(dataContainer, indices) {
+  return new _indexedDataContainer.IndexedDataContainer(dataContainer, indices);
+}
+/** @type {typeof import('./data-container-utils').getSampleData} */
+
+
+function getSampleData(dataContainer) {
+  var sampleSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 500;
+  var numberOfRows = dataContainer.numRows();
+  var sampleStep = Math.max(Math.floor(numberOfRows / sampleSize), 1);
+  var indices = [];
+
+  for (var i = 0; i < numberOfRows; i += sampleStep) {
+    indices.push(i);
+  }
+
+  return createIndexedDataContainer(dataContainer, indices);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/utils/table-utils/data-row.js

@@ -0,0 +1,82 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DataRow = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+// 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.
+var DataRow = /*#__PURE__*/function () {
+  function DataRow(dataContainer, rowIndex) {
+    (0, _classCallCheck2["default"])(this, DataRow);
+    this.setSource(dataContainer, rowIndex);
+  }
+
+  (0, _createClass2["default"])(DataRow, [{
+    key: "valueAt",
+    value: function valueAt(columnIndex) {
+      return this._dataContainer.valueAt(this._rowIndex, columnIndex);
+    }
+  }, {
+    key: "values",
+    value: function values() {
+      return this._dataContainer.rowAsArray(this._rowIndex);
+    }
+  }, {
+    key: "setSource",
+    value: function setSource(dataContainer, rowIndex) {
+      this._dataContainer = dataContainer;
+      this._rowIndex = rowIndex;
+    }
+  }, {
+    key: "map",
+    value: function map(handler) {
+      var numColumns = this._dataContainer.numColumns();
+
+      var out = [];
+
+      for (var column = 0; column < numColumns; ++column) {
+        out[column] = handler(this.valueAt(column), column);
+      }
+
+      return out;
+    }
+  }], [{
+    key: "createSharedRow",
+    value: function createSharedRow(sharedRowDesc) {
+      if (sharedRowDesc === true) {
+        return new DataRow(null, 0);
+      }
+
+      return sharedRowDesc;
+    }
+  }]);
+  return DataRow;
+}();
+
+exports.DataRow = DataRow;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy90YWJsZS11dGlscy9kYXRhLXJvdy5qcyJdLCJuYW1lcyI6WyJEYXRhUm93IiwiZGF0YUNvbnRhaW5lciIsInJvd0luZGV4Iiwic2V0U291cmNlIiwiY29sdW1uSW5kZXgiLCJfZGF0YUNvbnRhaW5lciIsInZhbHVlQXQiLCJfcm93SW5kZXgiLCJyb3dBc0FycmF5IiwiaGFuZGxlciIsIm51bUNvbHVtbnMiLCJvdXQiLCJjb2x1bW4iLCJzaGFyZWRSb3dEZXNjIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7O0FBQUE7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7SUFFYUEsTztBQUNYLG1CQUFZQyxhQUFaLEVBQTJCQyxRQUEzQixFQUFxQztBQUFBO0FBQ25DLFNBQUtDLFNBQUwsQ0FBZUYsYUFBZixFQUE4QkMsUUFBOUI7QUFDRDs7OztXQVNELGlCQUFRRSxXQUFSLEVBQXFCO0FBQ25CLGFBQU8sS0FBS0MsY0FBTCxDQUFvQkMsT0FBcEIsQ0FBNEIsS0FBS0MsU0FBakMsRUFBNENILFdBQTVDLENBQVA7QUFDRDs7O1dBRUQsa0JBQVM7QUFDUCxhQUFPLEtBQUtDLGNBQUwsQ0FBb0JHLFVBQXBCLENBQStCLEtBQUtELFNBQXBDLENBQVA7QUFDRDs7O1dBRUQsbUJBQVVOLGFBQVYsRUFBeUJDLFFBQXpCLEVBQW1DO0FBQ2pDLFdBQUtHLGNBQUwsR0FBc0JKLGFBQXRCO0FBQ0EsV0FBS00sU0FBTCxHQUFpQkwsUUFBakI7QUFDRDs7O1dBRUQsYUFBSU8sT0FBSixFQUFhO0FBQ1gsVUFBTUMsVUFBVSxHQUFHLEtBQUtMLGNBQUwsQ0FBb0JLLFVBQXBCLEVBQW5COztBQUNBLFVBQU1DLEdBQUcsR0FBRyxFQUFaOztBQUNBLFdBQUssSUFBSUMsTUFBTSxHQUFHLENBQWxCLEVBQXFCQSxNQUFNLEdBQUdGLFVBQTlCLEVBQTBDLEVBQUVFLE1BQTVDLEVBQW9EO0FBQ2xERCxRQUFBQSxHQUFHLENBQUNDLE1BQUQsQ0FBSCxHQUFjSCxPQUFPLENBQUMsS0FBS0gsT0FBTCxDQUFhTSxNQUFiLENBQUQsRUFBdUJBLE1BQXZCLENBQXJCO0FBQ0Q7O0FBQ0QsYUFBT0QsR0FBUDtBQUNEOzs7V0EzQkQseUJBQXVCRSxhQUF2QixFQUFzQztBQUNwQyxVQUFJQSxhQUFhLEtBQUssSUFBdEIsRUFBNEI7QUFDMUIsZUFBTyxJQUFJYixPQUFKLENBQVksSUFBWixFQUFrQixDQUFsQixDQUFQO0FBQ0Q7O0FBQ0QsYUFBT2EsYUFBUDtBQUNEIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IChjKSAyMDIyIFViZXIgVGVjaG5vbG9naWVzLCBJbmMuXG4vL1xuLy8gUGVybWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24gb2J0YWluaW5nIGEgY29weVxuLy8gb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUgXCJTb2Z0d2FyZVwiKSwgdG8gZGVhbFxuLy8gaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0c1xuLy8gdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNlbnNlLCBhbmQvb3Igc2VsbFxuLy8gY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3YXJlIGlzXG4vLyBmdXJuaXNoZWQgdG8gZG8gc28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOlxuLy9cbi8vIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluXG4vLyBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS5cbi8vXG4vLyBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgXCJBUyBJU1wiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9SXG4vLyBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSxcbi8vIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5HRU1FTlQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRVxuLy8gQVVUSE9SUyBPUiBDT1BZUklHSFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBPVEhFUlxuLy8gTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUiBPVEhFUldJU0UsIEFSSVNJTkcgRlJPTSxcbi8vIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVBTElOR1MgSU5cbi8vIFRIRSBTT0ZUV0FSRS5cblxuZXhwb3J0IGNsYXNzIERhdGFSb3cge1xuICBjb25zdHJ1Y3RvcihkYXRhQ29udGFpbmVyLCByb3dJbmRleCkge1xuICAgIHRoaXMuc2V0U291cmNlKGRhdGFDb250YWluZXIsIHJvd0luZGV4KTtcbiAgfVxuXG4gIHN0YXRpYyBjcmVhdGVTaGFyZWRSb3coc2hhcmVkUm93RGVzYykge1xuICAgIGlmIChzaGFyZWRSb3dEZXNjID09PSB0cnVlKSB7XG4gICAgICByZXR1cm4gbmV3IERhdGFSb3cobnVsbCwgMCk7XG4gICAgfVxuICAgIHJldHVybiBzaGFyZWRSb3dEZXNjO1xuICB9XG5cbiAgdmFsdWVBdChjb2x1bW5JbmRleCkge1xuICAgIHJldHVybiB0aGlzLl9kYXRhQ29udGFpbmVyLnZhbHVlQXQodGhpcy5fcm93SW5kZXgsIGNvbHVtbkluZGV4KTtcbiAgfVxuXG4gIHZhbHVlcygpIHtcbiAgICByZXR1cm4gdGhpcy5fZGF0YUNvbnRhaW5lci5yb3dBc0FycmF5KHRoaXMuX3Jvd0luZGV4KTtcbiAgfVxuXG4gIHNldFNvdXJjZShkYXRhQ29udGFpbmVyLCByb3dJbmRleCkge1xuICAgIHRoaXMuX2RhdGFDb250YWluZXIgPSBkYXRhQ29udGFpbmVyO1xuICAgIHRoaXMuX3Jvd0luZGV4ID0gcm93SW5kZXg7XG4gIH1cblxuICBtYXAoaGFuZGxlcikge1xuICAgIGNvbnN0IG51bUNvbHVtbnMgPSB0aGlzLl9kYXRhQ29udGFpbmVyLm51bUNvbHVtbnMoKTtcbiAgICBjb25zdCBvdXQgPSBbXTtcbiAgICBmb3IgKGxldCBjb2x1bW4gPSAwOyBjb2x1bW4gPCBudW1Db2x1bW5zOyArK2NvbHVtbikge1xuICAgICAgb3V0W2NvbHVtbl0gPSBoYW5kbGVyKHRoaXMudmFsdWVBdChjb2x1bW4pLCBjb2x1bW4pO1xuICAgIH1cbiAgICByZXR1cm4gb3V0O1xuICB9XG59XG4iXX0=

package/dist/utils/table-utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createDataContainer", {
+  enumerable: true,
+  get: function get() {
+    return _dataContainerUtils.createDataContainer;
+  }
+});
+Object.defineProperty(exports, "createIndexedDataContainer", {
+  enumerable: true,
+  get: function get() {
+    return _dataContainerUtils.createIndexedDataContainer;
+  }
+});
+
+var _dataContainerUtils = require("./data-container-utils");
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy90YWJsZS11dGlscy9pbmRleC5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFvQkEiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgKGMpIDIwMjIgVWJlciBUZWNobm9sb2dpZXMsIEluYy5cbi8vXG4vLyBQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYSBjb3B5XG4vLyBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSBcIlNvZnR3YXJlXCIpLCB0byBkZWFsXG4vLyBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbiB0aGUgcmlnaHRzXG4vLyB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsIGFuZC9vciBzZWxsXG4vLyBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgU29mdHdhcmUgaXNcbi8vIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6XG4vL1xuLy8gVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW5cbi8vIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3YXJlLlxuLy9cbi8vIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCBcIkFTIElTXCIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1Jcbi8vIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLFxuLy8gRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFXG4vLyBBVVRIT1JTIE9SIENPUFlSSUdIVCBIT0xERVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSXG4vLyBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORyBGUk9NLFxuLy8gT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTlxuLy8gVEhFIFNPRlRXQVJFLlxuXG5leHBvcnQge2NyZWF0ZURhdGFDb250YWluZXIsIGNyZWF0ZUluZGV4ZWREYXRhQ29udGFpbmVyfSBmcm9tICcuL2RhdGEtY29udGFpbmVyLXV0aWxzJztcbiJdfQ==