@carto/kepler.gl 0.0.81 → 0.0.82

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

@@ -11,8 +11,8 @@ exports.getInitialMapLayersForSplitMap = getInitialMapLayersForSplitMap;
 exports.removeLayerFromSplitMaps = removeLayerFromSplitMaps;
 var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // Copyright (c) 2022 Uber Technologies, Inc.
@@ -106,7 +106,7 @@ function computeSplitMapLayers(layers) {
   return [{
     layers: mapLayers
   }, {
-    layers: (0, _cloneDeep["default"])(mapLayers)
+    layers: (0, _lodash["default"])(mapLayers)
   }];
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_cloneDeep","_interopRequireDefault","require","_toPropertyKey","t","i","_toPrimitive","_typeof","String","r","e","Symbol","toPrimitive","call","TypeError","Number","ownKeys","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","addNewLayersToSplitMap","splitMaps","layers","newLayers","Array","isArray","map","settings","reduce","accu","newLayer","id","config","isVisible","removeLayerFromSplitMaps","layer","_settings$layers","_layer$id","_","_objectWithoutProperties2","getInitialMapLayersForSplitMap","currentLayer","computeSplitMapLayers","mapLayers","cloneDeep"],"sources":["../../src/utils/split-map-utils.js"],"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 cloneDeep from 'lodash/cloneDeep';\n\n/**\n * Add new layers to both existing maps\n * @param {Object} splitMaps\n * @param {Object|Array<Object>} layers\n * @returns {Array<Object>} new splitMaps\n */\nexport function addNewLayersToSplitMap(splitMaps, layers) {\n  const newLayers = Array.isArray(layers) ? layers : [layers];\n\n  if (!splitMaps.length || !newLayers.length) {\n    return splitMaps;\n  }\n\n  // add new layer to both maps,\n  // don't override, if layer.id is already in splitMaps\n  return splitMaps.map(settings => ({\n    ...settings,\n    layers: {\n      ...settings.layers,\n      ...newLayers.reduce(\n        (accu, newLayer) =>\n          // @ts-ignore\n          newLayer.id in settings.layers || !newLayer.config.isVisible\n            ? accu\n            : {\n                ...accu,\n                [newLayer.id]: newLayer.config.isVisible\n              },\n        {}\n      )\n    }\n  }));\n}\n\n/**\n * Remove an existing layer from split map settings\n * @param {Object} splitMaps\n * @param {Object} layer\n * @returns {Object} Maps of custom layer objects\n */\nexport function removeLayerFromSplitMaps(splitMaps, layer) {\n  if (!splitMaps.length) {\n    return splitMaps;\n  }\n  return splitMaps.map(settings => {\n    // eslint-disable-next-line no-unused-vars\n    const {[layer.id]: _, ...newLayers} = settings.layers;\n    return {\n      ...settings,\n      layers: newLayers\n    };\n  });\n}\n\n/**\n * This method will compute the default maps layer settings\n * based on the current layers visibility\n * @param {Array<Object>} layers\n * @returns {Array<Object>} layer visibility for each panel\n */\nexport function getInitialMapLayersForSplitMap(layers) {\n  return layers\n    .filter(layer => layer.config.isVisible)\n    .reduce(\n      (newLayers, currentLayer) => ({\n        ...newLayers,\n        [currentLayer.id]: currentLayer.config.isVisible\n      }),\n      {}\n    );\n}\n\n/**\n * This method will get default splitMap settings based on existing layers\n * @param {Array<Object>} layers\n * @returns {Array<Object>} split map settings\n */\nexport function computeSplitMapLayers(layers) {\n  const mapLayers = getInitialMapLayersForSplitMap(layers);\n\n  return [{layers: mapLayers}, {layers: cloneDeep(mapLayers)}];\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_lodash","_interopRequireDefault","require","_toPropertyKey","t","i","_toPrimitive","_typeof","r","e","Symbol","toPrimitive","call","TypeError","String","Number","ownKeys","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","addNewLayersToSplitMap","splitMaps","layers","newLayers","Array","isArray","map","settings","reduce","accu","newLayer","id","config","isVisible","removeLayerFromSplitMaps","layer","_settings$layers","_layer$id","_","_objectWithoutProperties2","getInitialMapLayersForSplitMap","currentLayer","computeSplitMapLayers","mapLayers","cloneDeep"],"sources":["../../src/utils/split-map-utils.ts"],"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 cloneDeep from 'lodash.clonedeep';\n\n/**\n * Add new layers to both existing maps\n * @param {Object} splitMaps\n * @param {Object|Array<Object>} layers\n * @returns {Array<Object>} new splitMaps\n */\nexport function addNewLayersToSplitMap(splitMaps, layers) {\n  const newLayers = Array.isArray(layers) ? layers : [layers];\n\n  if (!splitMaps.length || !newLayers.length) {\n    return splitMaps;\n  }\n\n  // add new layer to both maps,\n  // don't override, if layer.id is already in splitMaps\n  return splitMaps.map(settings => ({\n    ...settings,\n    layers: {\n      ...settings.layers,\n      ...newLayers.reduce(\n        (accu, newLayer) =>\n          // @ts-ignore\n          newLayer.id in settings.layers || !newLayer.config.isVisible\n            ? accu\n            : {\n                ...accu,\n                [newLayer.id]: newLayer.config.isVisible\n              },\n        {}\n      )\n    }\n  }));\n}\n\n/**\n * Remove an existing layer from split map settings\n * @param {Object} splitMaps\n * @param {Object} layer\n * @returns {Object} Maps of custom layer objects\n */\nexport function removeLayerFromSplitMaps(splitMaps, layer) {\n  if (!splitMaps.length) {\n    return splitMaps;\n  }\n  return splitMaps.map(settings => {\n    // eslint-disable-next-line no-unused-vars\n    const {[layer.id]: _, ...newLayers} = settings.layers;\n    return {\n      ...settings,\n      layers: newLayers\n    };\n  });\n}\n\n/**\n * This method will compute the default maps layer settings\n * based on the current layers visibility\n * @param {Array<Object>} layers\n * @returns {Array<Object>} layer visibility for each panel\n */\nexport function getInitialMapLayersForSplitMap(layers) {\n  return layers\n    .filter(layer => layer.config.isVisible)\n    .reduce(\n      (newLayers, currentLayer) => ({\n        ...newLayers,\n        [currentLayer.id]: currentLayer.config.isVisible\n      }),\n      {}\n    );\n}\n\n/**\n * This method will get default splitMap settings based on existing layers\n * @param {Array<Object>} layers\n * @returns {Array<Object>} split map settings\n */\nexport function computeSplitMapLayers(layers) {\n  const mapLayers = getInitialMapLayersForSplitMap(layers);\n\n  return [{layers: mapLayers}, {layers: cloneDeep(mapLayers)}];\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/utils/table-utils/data-container-interface.d.ts

@@ -0,0 +1,115 @@
+import { DataRow, SharedRowOptions } from './data-row';
+/**
+ * Specifies a range of rows of a data container that should be processed.
+ */
+export type RangeOptions = {
+    start?: number;
+    end?: number;
+};
+export interface DataContainerInterface {
+    /**
+     * Returns the number of rows in the data container.
+     * @returns Number of rows in the data container.
+     */
+    numRows(): number;
+    /**
+     * Returns the number of columns in the data container.
+     * @returns Number of columns in the data container.
+     */
+    numColumns(): number;
+    /**
+     * Returns the value stored at the specified cell in the data container.
+     * @param rowIndex Row index.
+     * @param columnIndex Column index.
+     * @returns Value at the specified cell.
+     */
+    valueAt(rowIndex: number, columnIndex: number): any;
+    /**
+     * Returns the row at the specified index.
+     * @param rowIndex Row index.
+     * @param sharedRow Passed row is filled with contents from the specified index and returned without extra row allocations.
+     * @returns A row object.
+     */
+    row(rowIndex: number, sharedRow?: SharedRowOptions): DataRow;
+    /**
+     * Returns the specified row of the data container represented as an array.
+     * @param rowIndex Row index.
+     * @returns The specified row represented as an array.
+     */
+    rowAsArray(rowIndex: number): any[];
+    /**
+     * Returns an iterator to sequentially access all rows in the data container.
+     * @param sharedRow Indicates that a temporary row object should be used.
+     * If enabled, the returned row object is shared between calls
+     * and mustn't be stored without cloning.
+     * Passed row is filled with contents of the specified row and returned on each iteration.
+     * @returns An iterator to sequentially access all rows in the data container.
+     */
+    rows(sharedRow?: SharedRowOptions): Generator<DataRow, void, any>;
+    /**
+     * Returns an iterator to sequentially access all values in the specified column of the data container.
+     * @param columnIndex Column index.
+     * @returns An iterator to all values in the specified column of the data container.
+     */
+    column(columnIndex: number): Generator<any, void, any>;
+    /**
+     * Returns contents of the data container as a two-dimensional array.
+     * @returns Data.
+     */
+    flattenData(): any[][];
+    /**
+     * Generates an array of indices where each index represents a row in the data container.
+     * @returns An array of indices.
+     */
+    getPlainIndex(): number[];
+    /**
+     * Creates a new array populated with the results of calling the provided callback
+     * on every row in the data container.
+     * @param func Callback that is called for every row of the data container.
+     * The callback is called with the following arguments:
+     * - row: The current row being processed in the data container.
+     * - index: The index of the current row being processed in the data container.
+     * @param sharedRow Truthy value indicates that a shared row object should be used.
+     * Make sure the func callback doesn't store the row object in such case,
+     * and clone the row in case you need to store it.
+     * @param options Specify start and end row indices that should be mapped.
+     * @returns A new array with each element being the result of the func callback.
+     */
+    map(func: (row: DataRow, index: number) => any, sharedRow?: SharedRowOptions, options?: RangeOptions): any[];
+    /**
+     * Creates a new array populated with the results of calling the provided callback.
+     * The callback is called for every row in the dataset, but only {index} object is passed.
+     * @param func Callback that is called for every row of the data container.
+     * @param options Specify start and end row indices that should be mapped.
+     * @returns A new array with each element being the result of the func callback.
+     */
+    mapIndex(func: ({ index }: {
+        index: number;
+    }, dataContainer: DataContainerInterface) => any, options?: RangeOptions): any[];
+    /**
+     * Returns the value of the first row in the provided data container that satisfies the provided testing function.
+     * @param func Function to execute on each value in the array.
+     * The function is called with the following arguments:
+     * - row: The current row being processed in the data container.
+     * - index: The index of the current row being processed in the data container.
+     * @param sharedRow Truthy value indicates that a shared row object should be used.
+     * Make sure the func callback doesn't store the row object in such case,
+     * and clone the row in case you need to store it.
+     * @returns First matching row or undefined if no rows satisfy the testing function.
+     */
+    find(func: (row: DataRow, index: number) => any, sharedRow?: SharedRowOptions): DataRow | undefined;
+    /**
+     * Executes a reducer function on each element of the data container, resulting in single output value.
+     * @param func A function to execute on each row in the data container.
+     * The function is called with the following arguments:
+     * - acc: The accumulator accumulates func's return values.
+     * - row: The current row being processed in the data container.
+     * - index: The index of the current row being processed in the data container.
+     * @param initialValue A value to use as the first argument to the first call of the func.
+     * @param sharedRow Truthy value indicates that a shared row object should be used.
+     * Make sure the func callback doesn't store the row object in such case,
+     * and clone the row in case you need to store it.
+     * @returns The single value that results from the reduction.
+     */
+    reduce(func: (acc: any, row: DataRow, index: number) => any, initialValue: any, sharedRow?: SharedRowOptions): any;
+}

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

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":[],"sources":["../../../src/utils/table-utils/data-container-interface.ts"],"sourcesContent":["import {DataRow, SharedRowOptions} from './data-row';\n\n/**\n * Specifies a range of rows of a data container that should be processed.\n */\nexport type RangeOptions = {\n  start?: number;\n  end?: number;\n};\nexport interface DataContainerInterface {\n  /**\n   * Returns the number of rows in the data container.\n   * @returns Number of rows in the data container.\n   */\n  numRows(): number;\n\n  /**\n   * Returns the number of columns in the data container.\n   * @returns Number of columns in the data container.\n   */\n  numColumns(): number;\n\n  /**\n   * Returns the value stored at the specified cell in the data container.\n   * @param rowIndex Row index.\n   * @param columnIndex Column index.\n   * @returns Value at the specified cell.\n   */\n  valueAt(rowIndex: number, columnIndex: number): any;\n\n  /**\n   * Returns the row at the specified index.\n   * @param rowIndex Row index.\n   * @param sharedRow Passed row is filled with contents from the specified index and returned without extra row allocations.\n   * @returns A row object.\n   */\n  row(rowIndex: number, sharedRow?: SharedRowOptions): DataRow;\n\n  /**\n   * Returns the specified row of the data container represented as an array.\n   * @param rowIndex Row index.\n   * @returns The specified row represented as an array.\n   */\n  rowAsArray(rowIndex: number): any[];\n\n  /**\n   * Returns an iterator to sequentially access all rows in the data container.\n   * @param sharedRow Indicates that a temporary row object should be used.\n   * If enabled, the returned row object is shared between calls\n   * and mustn't be stored without cloning.\n   * Passed row is filled with contents of the specified row and returned on each iteration.\n   * @returns An iterator to sequentially access all rows in the data container.\n   */\n  rows(sharedRow?: SharedRowOptions): Generator<DataRow, void, any>;\n\n  /**\n   * Returns an iterator to sequentially access all values in the specified column of the data container.\n   * @param columnIndex Column index.\n   * @returns An iterator to all values in the specified column of the data container.\n   */\n  column(columnIndex: number): Generator<any, void, any>;\n\n  /**\n   * Returns contents of the data container as a two-dimensional array.\n   * @returns Data.\n   */\n  flattenData(): any[][];\n\n  /**\n   * Generates an array of indices where each index represents a row in the data container.\n   * @returns An array of indices.\n   */\n  getPlainIndex(): number[];\n\n  /**\n   * Creates a new array populated with the results of calling the provided callback\n   * on every row in the data container.\n   * @param func Callback that is called for every row of the data container.\n   * The callback is called with the following arguments:\n   * - row: The current row being processed in the data container.\n   * - index: The index of the current row being processed in the data container.\n   * @param sharedRow Truthy value indicates that a shared row object should be used.\n   * Make sure the func callback doesn't store the row object in such case,\n   * and clone the row in case you need to store it.\n   * @param options Specify start and end row indices that should be mapped.\n   * @returns A new array with each element being the result of the func callback.\n   */\n  map(\n    func: (row: DataRow, index: number) => any,\n    sharedRow?: SharedRowOptions,\n    options?: RangeOptions\n  ): any[];\n\n  /**\n   * Creates a new array populated with the results of calling the provided callback.\n   * The callback is called for every row in the dataset, but only {index} object is passed.\n   * @param func Callback that is called for every row of the data container.\n   * @param options Specify start and end row indices that should be mapped.\n   * @returns A new array with each element being the result of the func callback.\n   */\n  mapIndex(\n    func: ({index}: {index: number}, dataContainer: DataContainerInterface) => any,\n    options?: RangeOptions\n  ): any[];\n\n  /**\n   * Returns the value of the first row in the provided data container that satisfies the provided testing function.\n   * @param func Function to execute on each value in the array.\n   * The function is called with the following arguments:\n   * - row: The current row being processed in the data container.\n   * - index: The index of the current row being processed in the data container.\n   * @param sharedRow Truthy value indicates that a shared row object should be used.\n   * Make sure the func callback doesn't store the row object in such case,\n   * and clone the row in case you need to store it.\n   * @returns First matching row or undefined if no rows satisfy the testing function.\n   */\n  find(\n    func: (row: DataRow, index: number) => any,\n    sharedRow?: SharedRowOptions\n  ): DataRow | undefined;\n\n  /**\n   * Executes a reducer function on each element of the data container, resulting in single output value.\n   * @param func A function to execute on each row in the data container.\n   * The function is called with the following arguments:\n   * - acc: The accumulator accumulates func's return values.\n   * - row: The current row being processed in the data container.\n   * - index: The index of the current row being processed in the data container.\n   * @param initialValue A value to use as the first argument to the first call of the func.\n   * @param sharedRow Truthy value indicates that a shared row object should be used.\n   * Make sure the func callback doesn't store the row object in such case,\n   * and clone the row in case you need to store it.\n   * @returns The single value that results from the reduction.\n   */\n  reduce(\n    func: (acc: any, row: DataRow, index: number) => any,\n    initialValue: any,\n    sharedRow?: SharedRowOptions\n  ): any;\n}\n"],"mappings":"","ignoreList":[]}

package/dist/utils/table-utils/data-container-utils.d.ts

@@ -0,0 +1,29 @@
+import { DataContainerInterface } from './data-container-interface';
+import { Field } from './kepler-table';
+export type DataContainerOptions = {
+    inputDataFormat?: string;
+    fields?: Field[];
+};
+export declare const DataForm: {
+    ROWS_ARRAY: string;
+};
+/**
+ * Creates a data container wrapper for the data.
+ * @param data Data.
+ * @param options Options.
+ * @returns A data container object which is based on data and options.
+ */
+export declare function createDataContainer(data: any[], options?: DataContainerOptions): DataContainerInterface;
+/**
+ * Creates a data container wrapper around another data container.
+ * @param dataContainer Parent data container.
+ * @param indices An array of row indices in the parent data container.
+ */
+export declare function createIndexedDataContainer(dataContainer: DataContainerInterface, indices: number[]): DataContainerInterface;
+/**
+ * Get a sample of rows from a data container.
+ * @param dataContainer Data container to get samples from.
+ * @param sampleSize Max number of samples.
+ * @returns A data container which contains samples from the original data container.
+ */
+export declare function getSampleData(dataContainer: DataContainerInterface, sampleSize?: number): DataContainerInterface;

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

@@ -31,17 +31,19 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 // 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.
-/** @type {import('./data-container-utils').DataForm} */
 var DataForm = exports.DataForm = {
   ROWS_ARRAY: 'ROWS_ARRAY'
 };
-
-/** @type {import('./data-container-utils').DataContainerOptions} */
 var defaultOptions = {
   inputDataFormat: DataForm.ROWS_ARRAY
 };
 
-/** @type {typeof import('./data-container-utils').createDataContainer} */
+/**
+ * Creates a data container wrapper for the data.
+ * @param data Data.
+ * @param options Options.
+ * @returns A data container object which is based on data and options.
+ */
 function createDataContainer(data) {
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultOptions;
   options = _objectSpread(_objectSpread({}, defaultOptions), options);
@@ -54,12 +56,21 @@ function createDataContainer(data) {
   throw Error('Failed to create a data container: not implemented format');
 }
 
-/** @type {typeof import('./data-container-utils').createIndexedDataContainer} */
+/**
+ * Creates a data container wrapper around another data container.
+ * @param dataContainer Parent data container.
+ * @param indices An array of row indices in the parent data container.
+ */
 function createIndexedDataContainer(dataContainer, indices) {
   return new _indexedDataContainer.IndexedDataContainer(dataContainer, indices);
 }
 
-/** @type {typeof import('./data-container-utils').getSampleData} */
+/**
+ * Get a sample of rows from a data container.
+ * @param dataContainer Data container to get samples from.
+ * @param sampleSize Max number of samples.
+ * @returns A data container which contains samples from the original data container.
+ */
 function getSampleData(dataContainer) {
   var sampleSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 500;
   var numberOfRows = dataContainer.numRows();
@@ -70,4 +81,4 @@ function getSampleData(dataContainer) {
   }
   return createIndexedDataContainer(dataContainer, indices);
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_rowDataContainer","require","_indexedDataContainer","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","DataForm","exports","ROWS_ARRAY","defaultOptions","inputDataFormat","createDataContainer","data","options","undefined","RowDataContainer","rows","fields","Error","createIndexedDataContainer","dataContainer","indices","IndexedDataContainer","getSampleData","sampleSize","numberOfRows","numRows","sampleStep","Math","max","floor","i"],"sources":["../../../src/utils/table-utils/data-container-utils.ts"],"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 {RowDataContainer} from './row-data-container';\nimport {IndexedDataContainer} from './indexed-data-container';\n\nimport {DataContainerInterface} from './data-container-interface';\nimport {Field} from './kepler-table';\n\nexport type DataContainerOptions = {\n  inputDataFormat?: string; // one of DataForm\n  fields?: Field[];\n};\n\nexport const DataForm = {\n  ROWS_ARRAY: 'ROWS_ARRAY'\n};\n\nconst defaultOptions: DataContainerOptions = {\n  inputDataFormat: DataForm.ROWS_ARRAY\n};\n\n/**\n * Creates a data container wrapper for the data.\n * @param data Data.\n * @param options Options.\n * @returns A data container object which is based on data and options.\n */\nexport function createDataContainer(\n  data: any[],\n  options: DataContainerOptions = defaultOptions\n): DataContainerInterface {\n  options = {...defaultOptions, ...options};\n\n  if (options.inputDataFormat === DataForm.ROWS_ARRAY) {\n    return new RowDataContainer({rows: data, fields: options.fields});\n  }\n\n  throw Error('Failed to create a data container: not implemented format');\n}\n\n/**\n * Creates a data container wrapper around another data container.\n * @param dataContainer Parent data container.\n * @param indices An array of row indices in the parent data container.\n */\nexport function createIndexedDataContainer(\n  dataContainer: DataContainerInterface,\n  indices: number[]\n): DataContainerInterface {\n  return new IndexedDataContainer(dataContainer, indices);\n}\n\n/**\n * Get a sample of rows from a data container.\n * @param dataContainer Data container to get samples from.\n * @param sampleSize Max number of samples.\n * @returns A data container which contains samples from the original data container.\n */\nexport function getSampleData(\n  dataContainer: DataContainerInterface,\n  sampleSize = 500\n): DataContainerInterface {\n  const numberOfRows = dataContainer.numRows();\n  const sampleStep = Math.max(Math.floor(numberOfRows / sampleSize), 1);\n\n  const indices: number[] = [];\n  for (let i = 0; i < numberOfRows; i += sampleStep) {\n    indices.push(i);\n  }\n\n  return createIndexedDataContainer(dataContainer, indices);\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/utils/table-utils/data-row.d.ts

@@ -0,0 +1,59 @@
+import { DataContainerInterface } from './data-container-interface';
+/**
+ * Setting for shared row optimization.
+ * - False/undefined indicates that unique row objects should be used (default).
+ * - True indicates that a single temporary row object should be created and used without extra allocations.
+ * - A DataRow object indicates that the row should be used as a temporary shared row.
+ * When used, the content of the shared row isn't preserved between calls.
+ */
+export type SharedRowOptions = DataRow | boolean | undefined;
+/**
+ * Return type for createSharedRow:
+ * - DataRow object that should be used as shared row.
+ * - Falsy values indicate that shared row object shouldn't be used.
+ */
+export type SharedRowOptionsResult = DataRow | false | undefined;
+export declare class DataRow {
+    _dataContainer: DataContainerInterface | null;
+    _rowIndex: number;
+    /**
+     * Creates new DataRow.
+     * @param dataContainer Data container where data is stored. Can be initialized with null for shared rows.
+     * @param rowIndex Index of a row in the data container.
+     */
+    constructor(dataContainer: DataContainerInterface | null, rowIndex: number);
+    /**
+     * Conditionally creates a DataRow object.
+     * @param sharedRowDesc Accepts forllowing options:
+     * - true indicates that new DataRow should be created.
+     * - falsy value or a DataRow object is passed through without any change.
+     * @returns A new DataRow object or unchanged input argument.
+     */
+    static createSharedRow(sharedRowDesc: SharedRowOptions): SharedRowOptionsResult;
+    /**
+     * Returns the value stored at the specified index in the row.
+     * @param columnIndex Index of the requested field in the row.
+     * @returns Value at the index.
+     */
+    valueAt(columnIndex: number): any;
+    /**
+     * Returns the row represented as an array.
+     * @returns The row represented as an array.
+     */
+    values(): any[];
+    /**
+     * Setup a row object. The method is used by shared rows to prevent excessive allocations.
+     * @param dataContainer Data container.
+     * @param rowIndex Index of a row in the data container.
+     */
+    setSource(dataContainer: DataContainerInterface, rowIndex: number): void;
+    /**
+     * Creates a new array populated with the results of calling the provided function
+     * on every element of the row.
+     * @param handler The callback is called with the following arguments:
+     * - elem: The current element being processed in the row.
+     * - index: The index of the current element being processed in the row.
+     * @returns A new array with each element being the result of the func callback.
+     */
+    map(handler: (elem: any, index: number) => any): any[];
+}

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

@@ -26,31 +26,85 @@ var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/creat
 // 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.
+/**
+ * Setting for shared row optimization.
+ * - False/undefined indicates that unique row objects should be used (default).
+ * - True indicates that a single temporary row object should be created and used without extra allocations.
+ * - A DataRow object indicates that the row should be used as a temporary shared row.
+ * When used, the content of the shared row isn't preserved between calls.
+ */
+/**
+ * Return type for createSharedRow:
+ * - DataRow object that should be used as shared row.
+ * - Falsy values indicate that shared row object shouldn't be used.
+ */
 var DataRow = exports.DataRow = /*#__PURE__*/function () {
+  /**
+   * Creates new DataRow.
+   * @param dataContainer Data container where data is stored. Can be initialized with null for shared rows.
+   * @param rowIndex Index of a row in the data container.
+   */
   function DataRow(dataContainer, rowIndex) {
     (0, _classCallCheck2["default"])(this, DataRow);
-    this.setSource(dataContainer, rowIndex);
+    this._dataContainer = dataContainer;
+    this._rowIndex = rowIndex;
   }
-  (0, _createClass2["default"])(DataRow, [{
+
+  /**
+   * Conditionally creates a DataRow object.
+   * @param sharedRowDesc Accepts forllowing options:
+   * - true indicates that new DataRow should be created.
+   * - falsy value or a DataRow object is passed through without any change.
+   * @returns A new DataRow object or unchanged input argument.
+   */
+  return (0, _createClass2["default"])(DataRow, [{
     key: "valueAt",
-    value: function valueAt(columnIndex) {
-      return this._dataContainer.valueAt(this._rowIndex, columnIndex);
+    value:
+    /**
+     * Returns the value stored at the specified index in the row.
+     * @param columnIndex Index of the requested field in the row.
+     * @returns Value at the index.
+     */
+    function valueAt(columnIndex) {
+      var _this$_dataContainer;
+      return (_this$_dataContainer = this._dataContainer) === null || _this$_dataContainer === void 0 ? void 0 : _this$_dataContainer.valueAt(this._rowIndex, columnIndex);
     }
+
+    /**
+     * Returns the row represented as an array.
+     * @returns The row represented as an array.
+     */
   }, {
     key: "values",
     value: function values() {
-      return this._dataContainer.rowAsArray(this._rowIndex);
+      return this._dataContainer ? this._dataContainer.rowAsArray(this._rowIndex) : [];
     }
+
+    /**
+     * Setup a row object. The method is used by shared rows to prevent excessive allocations.
+     * @param dataContainer Data container.
+     * @param rowIndex Index of a row in the data container.
+     */
   }, {
     key: "setSource",
     value: function setSource(dataContainer, rowIndex) {
       this._dataContainer = dataContainer;
       this._rowIndex = rowIndex;
     }
+
+    /**
+     * Creates a new array populated with the results of calling the provided function
+     * on every element of the row.
+     * @param handler The callback is called with the following arguments:
+     * - elem: The current element being processed in the row.
+     * - index: The index of the current element being processed in the row.
+     * @returns A new array with each element being the result of the func callback.
+     */
   }, {
     key: "map",
     value: function map(handler) {
-      var numColumns = this._dataContainer.numColumns();
+      var _this$_dataContainer2;
+      var numColumns = ((_this$_dataContainer2 = this._dataContainer) === null || _this$_dataContainer2 === void 0 ? void 0 : _this$_dataContainer2.numColumns()) || 0;
       var out = [];
       for (var column = 0; column < numColumns; ++column) {
         out[column] = handler(this.valueAt(column), column);
@@ -66,6 +120,5 @@ var DataRow = exports.DataRow = /*#__PURE__*/function () {
       return sharedRowDesc;
     }
   }]);
-  return DataRow;
 }();
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DataRow","exports","dataContainer","rowIndex","_classCallCheck2","_dataContainer","_rowIndex","_createClass2","key","value","valueAt","columnIndex","_this$_dataContainer","values","rowAsArray","setSource","map","handler","_this$_dataContainer2","numColumns","out","column","createSharedRow","sharedRowDesc"],"sources":["../../../src/utils/table-utils/data-row.ts"],"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 {DataContainerInterface} from './data-container-interface';\n\n/**\n * Setting for shared row optimization.\n * - False/undefined indicates that unique row objects should be used (default).\n * - True indicates that a single temporary row object should be created and used without extra allocations.\n * - A DataRow object indicates that the row should be used as a temporary shared row.\n * When used, the content of the shared row isn't preserved between calls.\n */\nexport type SharedRowOptions = DataRow | boolean | undefined;\n/**\n * Return type for createSharedRow:\n * - DataRow object that should be used as shared row.\n * - Falsy values indicate that shared row object shouldn't be used.\n */\nexport type SharedRowOptionsResult = DataRow | false | undefined;\n\nexport class DataRow {\n  _dataContainer: DataContainerInterface | null;\n\n  _rowIndex: number;\n\n  /**\n   * Creates new DataRow.\n   * @param dataContainer Data container where data is stored. Can be initialized with null for shared rows.\n   * @param rowIndex Index of a row in the data container.\n   */\n  constructor(dataContainer: DataContainerInterface | null, rowIndex: number) {\n    this._dataContainer = dataContainer;\n    this._rowIndex = rowIndex;\n  }\n\n  /**\n   * Conditionally creates a DataRow object.\n   * @param sharedRowDesc Accepts forllowing options:\n   * - true indicates that new DataRow should be created.\n   * - falsy value or a DataRow object is passed through without any change.\n   * @returns A new DataRow object or unchanged input argument.\n   */\n  static createSharedRow(sharedRowDesc: SharedRowOptions): SharedRowOptionsResult {\n    if (sharedRowDesc === true) {\n      return new DataRow(null, 0);\n    }\n    return sharedRowDesc;\n  }\n\n  /**\n   * Returns the value stored at the specified index in the row.\n   * @param columnIndex Index of the requested field in the row.\n   * @returns Value at the index.\n   */\n  valueAt(columnIndex: number): any {\n    return this._dataContainer?.valueAt(this._rowIndex, columnIndex);\n  }\n\n  /**\n   * Returns the row represented as an array.\n   * @returns The row represented as an array.\n   */\n  values(): any[] {\n    return this._dataContainer ? this._dataContainer.rowAsArray(this._rowIndex) : [];\n  }\n\n  /**\n   * Setup a row object. The method is used by shared rows to prevent excessive allocations.\n   * @param dataContainer Data container.\n   * @param rowIndex Index of a row in the data container.\n   */\n  setSource(dataContainer: DataContainerInterface, rowIndex: number): void {\n    this._dataContainer = dataContainer;\n    this._rowIndex = rowIndex;\n  }\n\n  /**\n   * Creates a new array populated with the results of calling the provided function\n   * on every element of the row.\n   * @param handler The callback is called with the following arguments:\n   * - elem: The current element being processed in the row.\n   * - index: The index of the current element being processed in the row.\n   * @returns A new array with each element being the result of the func callback.\n   */\n  map(handler: (elem: any, index: number) => any): any[] {\n    const numColumns = this._dataContainer?.numColumns() || 0;\n    const out: any[] = [];\n    for (let column = 0; column < numColumns; ++column) {\n      out[column] = handler(this.valueAt(column), column);\n    }\n    return out;\n  }\n}\n"],"mappings":";;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAJA,IAOaA,OAAO,GAAAC,OAAA,CAAAD,OAAA;EAKlB;AACF;AACA;AACA;AACA;EACE,SAAAA,QAAYE,aAA4C,EAAEC,QAAgB,EAAE;IAAA,IAAAC,gBAAA,mBAAAJ,OAAA;IAC1E,IAAI,CAACK,cAAc,GAAGH,aAAa;IACnC,IAAI,CAACI,SAAS,GAAGH,QAAQ;EAC3B;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;EANE,WAAAI,aAAA,aAAAP,OAAA;IAAAQ,GAAA;IAAAC,KAAA;IAcA;AACF;AACA;AACA;AACA;IACE,SAAAC,OAAOA,CAACC,WAAmB,EAAO;MAAA,IAAAC,oBAAA;MAChC,QAAAA,oBAAA,GAAO,IAAI,CAACP,cAAc,cAAAO,oBAAA,uBAAnBA,oBAAA,CAAqBF,OAAO,CAAC,IAAI,CAACJ,SAAS,EAAEK,WAAW,CAAC;IAClE;;IAEA;AACF;AACA;AACA;EAHE;IAAAH,GAAA;IAAAC,KAAA,EAIA,SAAAI,MAAMA,CAAA,EAAU;MACd,OAAO,IAAI,CAACR,cAAc,GAAG,IAAI,CAACA,cAAc,CAACS,UAAU,CAAC,IAAI,CAACR,SAAS,CAAC,GAAG,EAAE;IAClF;;IAEA;AACF;AACA;AACA;AACA;EAJE;IAAAE,GAAA;IAAAC,KAAA,EAKA,SAAAM,SAASA,CAACb,aAAqC,EAAEC,QAAgB,EAAQ;MACvE,IAAI,CAACE,cAAc,GAAGH,aAAa;MACnC,IAAI,CAACI,SAAS,GAAGH,QAAQ;IAC3B;;IAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EAPE;IAAAK,GAAA;IAAAC,KAAA,EAQA,SAAAO,GAAGA,CAACC,OAA0C,EAAS;MAAA,IAAAC,qBAAA;MACrD,IAAMC,UAAU,GAAG,EAAAD,qBAAA,OAAI,CAACb,cAAc,cAAAa,qBAAA,uBAAnBA,qBAAA,CAAqBC,UAAU,CAAC,CAAC,KAAI,CAAC;MACzD,IAAMC,GAAU,GAAG,EAAE;MACrB,KAAK,IAAIC,MAAM,GAAG,CAAC,EAAEA,MAAM,GAAGF,UAAU,EAAE,EAAEE,MAAM,EAAE;QAClDD,GAAG,CAACC,MAAM,CAAC,GAAGJ,OAAO,CAAC,IAAI,CAACP,OAAO,CAACW,MAAM,CAAC,EAAEA,MAAM,CAAC;MACrD;MACA,OAAOD,GAAG;IACZ;EAAC;IAAAZ,GAAA;IAAAC,KAAA,EAjDD,SAAOa,eAAeA,CAACC,aAA+B,EAA0B;MAC9E,IAAIA,aAAa,KAAK,IAAI,EAAE;QAC1B,OAAO,IAAIvB,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;MAC7B;MACA,OAAOuB,aAAa;IACtB;EAAC;AAAA","ignoreList":[]}

package/dist/utils/table-utils/index.d.ts

@@ -0,0 +1 @@
+export { createDataContainer, createIndexedDataContainer } from './data-container-utils';

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

@@ -16,4 +16,4 @@ Object.defineProperty(exports, "createIndexedDataContainer", {
   }
 });
 var _dataContainerUtils = require("./data-container-utils");
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfZGF0YUNvbnRhaW5lclV0aWxzIiwicmVxdWlyZSJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy90YWJsZS11dGlscy9pbmRleC5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgKGMpIDIwMjIgVWJlciBUZWNobm9sb2dpZXMsIEluYy5cbi8vXG4vLyBQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYSBjb3B5XG4vLyBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSBcIlNvZnR3YXJlXCIpLCB0byBkZWFsXG4vLyBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbiB0aGUgcmlnaHRzXG4vLyB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsIGFuZC9vciBzZWxsXG4vLyBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgU29mdHdhcmUgaXNcbi8vIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6XG4vL1xuLy8gVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW5cbi8vIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3YXJlLlxuLy9cbi8vIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCBcIkFTIElTXCIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1Jcbi8vIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLFxuLy8gRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFXG4vLyBBVVRIT1JTIE9SIENPUFlSSUdIVCBIT0xERVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSXG4vLyBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORyBGUk9NLFxuLy8gT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTlxuLy8gVEhFIFNPRlRXQVJFLlxuXG5leHBvcnQge2NyZWF0ZURhdGFDb250YWluZXIsIGNyZWF0ZUluZGV4ZWREYXRhQ29udGFpbmVyfSBmcm9tICcuL2RhdGEtY29udGFpbmVyLXV0aWxzJztcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFvQkEsSUFBQUEsbUJBQUEsR0FBQUMsT0FBQSJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJfZGF0YUNvbnRhaW5lclV0aWxzIiwicmVxdWlyZSJdLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy91dGlscy90YWJsZS11dGlscy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgKGMpIDIwMjIgVWJlciBUZWNobm9sb2dpZXMsIEluYy5cbi8vXG4vLyBQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYSBjb3B5XG4vLyBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSBcIlNvZnR3YXJlXCIpLCB0byBkZWFsXG4vLyBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbiB0aGUgcmlnaHRzXG4vLyB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsIGFuZC9vciBzZWxsXG4vLyBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgU29mdHdhcmUgaXNcbi8vIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6XG4vL1xuLy8gVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW5cbi8vIGFsbCBjb3BpZXMgb3Igc3Vic3RhbnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3YXJlLlxuLy9cbi8vIFRIRSBTT0ZUV0FSRSBJUyBQUk9WSURFRCBcIkFTIElTXCIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1Jcbi8vIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLFxuLy8gRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFXG4vLyBBVVRIT1JTIE9SIENPUFlSSUdIVCBIT0xERVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSXG4vLyBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORyBGUk9NLFxuLy8gT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTlxuLy8gVEhFIFNPRlRXQVJFLlxuXG5leHBvcnQge2NyZWF0ZURhdGFDb250YWluZXIsIGNyZWF0ZUluZGV4ZWREYXRhQ29udGFpbmVyfSBmcm9tICcuL2RhdGEtY29udGFpbmVyLXV0aWxzJztcbiJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFvQkEsSUFBQUEsbUJBQUEsR0FBQUMsT0FBQSIsImlnbm9yZUxpc3QiOltdfQ==

package/dist/utils/table-utils/indexed-data-container.d.ts

@@ -0,0 +1,34 @@
+import { DataContainerInterface, RangeOptions } from './data-container-interface';
+import { DataRow, SharedRowOptions } from './data-row';
+/**
+ * A data container wrapper around another data container.
+ * You have to pass an array of indices to reference rows in the parent data container.
+ * For example indices [3, 4, 6, 8] means that IndexedDataContainer is going to have
+ * 4 rows and row(2) points to 6th row in the referenced data container.
+ */
+export declare class IndexedDataContainer implements DataContainerInterface {
+    _parentDataContainer: DataContainerInterface;
+    _indices: number[];
+    constructor(parentDataContainer: DataContainerInterface, indices: number[]);
+    numRows(): number;
+    numColumns(): number;
+    /**
+     * Remaps a local index to an index in the parent dataset
+     * @param rowIndex
+     * @returns number
+     */
+    _mappedRowIndex(rowIndex: number): number;
+    valueAt(rowIndex: number, columnIndex: number): any;
+    row(rowIndex: number, sharedRow?: SharedRowOptions): DataRow;
+    rowAsArray(rowIndex: number): any[];
+    rows(sharedRow?: SharedRowOptions): Generator<DataRow, any, unknown>;
+    column(columnIndex: number): Generator<any, any, unknown>;
+    getPlainIndex(): number[];
+    flattenData(): any[][];
+    map<T>(func: (row: DataRow, index: number) => T, sharedRow?: SharedRowOptions, options?: RangeOptions): T[];
+    mapIndex<T>(func: ({ index }: {
+        index: number;
+    }, 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;
+}