@carto/kepler.gl 0.0.81 → 0.0.82

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

@@ -30,10 +30,10 @@ var _marked = /*#__PURE__*/_regenerator["default"].mark(rowsIterator),
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 /**
- * @param {import('./data-container-interface').DataContainerInterface} dataContainer
- * @param {number[]} indices
- * @param {import('./data-row').SharedRowOptions} sharedRow
- * @returns {Generator<DataRow, void, unknown>}
+ * @param dataContainer
+ * @param indices
+ * @param sharedRow
+ * @returns
  */
 function rowsIterator(dataContainer, indices, sharedRow) {
   var numRows, rowIndex, mappedRowIndex;
@@ -62,10 +62,10 @@ function rowsIterator(dataContainer, indices, sharedRow) {
 }
 
 /**
- * @param {import('./data-container-interface').DataContainerInterface} dataContainer
- * @param {number[]} indices
- * @param {number} columnIndex
- * @returns {Generator<any, void, unknown>}
+ * @param dataContainer
+ * @param indices
+ * @param columnIndex
+ * @returns
  */
 function columnIterator(dataContainer, indices, columnIndex) {
   var numRows, rowIndex, mappedRowIndex;
@@ -92,13 +92,20 @@ function columnIterator(dataContainer, indices, columnIndex) {
     }
   }, _marked2);
 }
+
+/**
+ * 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.
+ */
 var IndexedDataContainer = exports.IndexedDataContainer = /*#__PURE__*/function () {
   function IndexedDataContainer(parentDataContainer, indices) {
     (0, _classCallCheck2["default"])(this, IndexedDataContainer);
     this._parentDataContainer = parentDataContainer;
     this._indices = indices;
   }
-  (0, _createClass2["default"])(IndexedDataContainer, [{
+  return (0, _createClass2["default"])(IndexedDataContainer, [{
     key: "numRows",
     value: function numRows() {
       return this._indices.length;
@@ -111,7 +118,7 @@ var IndexedDataContainer = exports.IndexedDataContainer = /*#__PURE__*/function
 
     /**
      * Remaps a local index to an index in the parent dataset
-     * @param {number} rowIndex
+     * @param rowIndex
      * @returns number
      */
   }, {
@@ -217,6 +224,5 @@ var IndexedDataContainer = exports.IndexedDataContainer = /*#__PURE__*/function
       return initialValue;
     }
   }]);
-  return IndexedDataContainer;
 }();
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_dataRow","require","_marked","_regenerator","mark","rowsIterator","_marked2","columnIterator","dataContainer","indices","sharedRow","numRows","rowIndex","mappedRowIndex","wrap","rowsIterator$","_context","prev","next","length","row","stop","columnIndex","columnIterator$","_context2","valueAt","IndexedDataContainer","exports","parentDataContainer","_classCallCheck2","_parentDataContainer","_indices","_createClass2","key","value","numColumns","_mappedRowIndex","rowAsArray","rows","column","getPlainIndex","map","_","i","flattenData","_this","tSharedRow","DataRow","createSharedRow","values","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/utils/table-utils/indexed-data-container.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 {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"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_dataRow","require","_marked","_regenerator","mark","rowsIterator","_marked2","columnIterator","dataContainer","indices","sharedRow","numRows","rowIndex","mappedRowIndex","wrap","rowsIterator$","_context","prev","next","length","row","stop","columnIndex","columnIterator$","_context2","valueAt","IndexedDataContainer","exports","parentDataContainer","_classCallCheck2","_parentDataContainer","_indices","_createClass2","key","value","numColumns","_mappedRowIndex","rowAsArray","rows","column","getPlainIndex","map","_","i","flattenData","_this","tSharedRow","DataRow","createSharedRow","values","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/utils/table-utils/indexed-data-container.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, RangeOptions} from './data-container-interface';\nimport {DataRow, SharedRowOptions} from './data-row';\n\n/**\n * @param dataContainer\n * @param indices\n * @param sharedRow\n * @returns\n */\nfunction* rowsIterator(\n  dataContainer: DataContainerInterface,\n  indices: number[],\n  sharedRow: SharedRowOptions\n): Generator<DataRow> {\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 dataContainer\n * @param indices\n * @param columnIndex\n * @returns\n */\nfunction* columnIterator(\n  dataContainer: DataContainerInterface,\n  indices: number[],\n  columnIndex: number\n): Generator<any> {\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\n/**\n * A data container wrapper around another data container.\n * You have to pass an array of indices to reference rows in the parent data container.\n * For example indices [3, 4, 6, 8] means that IndexedDataContainer is going to have\n * 4 rows and row(2) points to 6th row in the referenced data container.\n */\nexport class IndexedDataContainer implements DataContainerInterface {\n  _parentDataContainer: DataContainerInterface;\n  _indices: number[];\n\n  constructor(parentDataContainer: DataContainerInterface, indices: number[]) {\n    this._parentDataContainer = parentDataContainer;\n    this._indices = indices;\n  }\n\n  numRows(): number {\n    return this._indices.length;\n  }\n\n  numColumns(): number {\n    return this._parentDataContainer.numColumns();\n  }\n\n  /**\n   * Remaps a local index to an index in the parent dataset\n   * @param rowIndex\n   * @returns number\n   */\n  _mappedRowIndex(rowIndex: number): number {\n    return this._indices[rowIndex];\n  }\n\n  valueAt(rowIndex: number, columnIndex: number): any {\n    return this._parentDataContainer.valueAt(this._mappedRowIndex(rowIndex), columnIndex);\n  }\n\n  row(rowIndex: number, sharedRow?: SharedRowOptions): DataRow {\n    return this._parentDataContainer.row(this._mappedRowIndex(rowIndex), sharedRow);\n  }\n\n  rowAsArray(rowIndex: number): any[] {\n    return this._parentDataContainer.rowAsArray(this._mappedRowIndex(rowIndex));\n  }\n\n  rows(sharedRow?: SharedRowOptions) {\n    return rowsIterator(this._parentDataContainer, this._indices, sharedRow);\n  }\n\n  column(columnIndex: number) {\n    return columnIterator(this._parentDataContainer, this._indices, columnIndex);\n  }\n\n  getPlainIndex(): number[] {\n    return this._indices.map((_, i) => i);\n  }\n\n  flattenData(): any[][] {\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<T>(\n    func: (row: DataRow, index: number) => T,\n    sharedRow?: SharedRowOptions,\n    options: RangeOptions = {}\n  ): T[] {\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: 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}: {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: this._mappedRowIndex(rowIndex)}, this._parentDataContainer));\n    }\n    return out;\n  }\n\n  find(\n    func: (row: DataRow, index: number) => boolean,\n    sharedRow?: SharedRowOptions\n  ): DataRow | undefined {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    for (let rowIndex = 0; rowIndex < this.numRows(); ++rowIndex) {\n      const row = this.row(rowIndex, tSharedRow);\n      if (func(row, rowIndex)) {\n        return row;\n      }\n    }\n    return undefined;\n  }\n\n  reduce<T>(\n    func: (acc: T, row: DataRow, index: number) => T,\n    initialValue: T,\n    sharedRow?: SharedRowOptions\n  ): T {\n    const tSharedRow = DataRow.createSharedRow(sharedRow);\n\n    for (let rowIndex = 0; rowIndex < this._indices.length; ++rowIndex) {\n      const row = this.row(rowIndex, tSharedRow);\n      initialValue = func(initialValue, row, rowIndex);\n    }\n    return initialValue;\n  }\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,168 @@
+import { RGBColor } from 'reducers/types';
+import { Layer } from 'layers';
+import { FieldDomain, Filter } from 'reducers/vis-state-updaters';
+import { DataContainerInterface } from './data-container-interface';
+import { ProtoDataset } from 'actions';
+export type Field = {
+    analyzerType: string;
+    id?: string;
+    name: string;
+    displayName: string;
+    format: string;
+    type: string;
+    fieldIdx: number;
+    valueAccessor(v: {
+        index: number;
+    }): any;
+    filterProps?: any;
+    metadata?: any;
+};
+export type GpuFilter = {
+    filterRange: number[][];
+    filterValueUpdateTriggers: any;
+    filterValueAccessor: (dc: DataContainerInterface) => (getIndex?: (any: any) => number, getData?: (dc: DataContainerInterface, d: any, fieldIndex: number) => any) => (d: any) => number;
+};
+export type FieldPair = {
+    defaultName: string;
+    pair: {
+        [key: string]: {
+            fieldIdx: number;
+            value: string;
+        };
+    };
+    suffix: string[];
+};
+export type FilterRecord = {
+    dynamicDomain: Filter[];
+    fixedDomain: Filter[];
+    cpu: Filter[];
+    gpu: Filter[];
+};
+export type FilterDatasetOpt = {
+    cpuOnly?: boolean;
+    ignoreDomain?: boolean;
+};
+declare class KeplerTable {
+    readonly id: string;
+    type?: string;
+    label: string;
+    color: RGBColor;
+    fields: Field[];
+    dataContainer: DataContainerInterface;
+    allIndexes: number[];
+    filteredIndex: number[];
+    filteredIdxCPU?: number[];
+    filteredIndexForDomain: number[];
+    fieldPairs: FieldPair[];
+    gpuFilter: GpuFilter;
+    filterRecord?: FilterRecord;
+    filterRecordCPU?: FilterRecord;
+    changedFilters?: any;
+    sortColumn?: {
+        [key: string]: string;
+    };
+    sortOrder?: number[] | null;
+    pinnedColumns?: string[];
+    supportedFilterTypes: string[] | undefined;
+    metadata: object;
+    constructor({ info, data, color, metadata, supportedFilterTypes }: {
+        info?: ProtoDataset['info'];
+        data: ProtoDataset['data'];
+        color: RGBColor;
+        metadata?: ProtoDataset['metadata'];
+        supportedFilterTypes?: ProtoDataset['supportedFilterTypes'];
+    });
+    /**
+     * Get field
+     * @param columnName
+     */
+    getColumnField(columnName: string): Field | undefined;
+    /**
+     * Get fieldIdx
+     * @param columnName
+     */
+    getColumnFieldIdx(columnName: string): number;
+    /**
+     * Get the value of a cell
+     */
+    getValue(columnName: string, rowIdx: number): any;
+    /**
+     * Updates existing field with a new object
+     * @param fieldIdx
+     * @param newField
+     */
+    updateColumnField(fieldIdx: number, newField: Field): void;
+    /**
+     * Update dataset color by custom color
+     * @param newColor
+     */
+    updateTableColor(newColor: RGBColor): void;
+    /**
+     * Save filterProps to field and retrieve it
+     * @param columnName
+     */
+    getColumnFilterProps(columnName: string): Field['filterProps'] | null | undefined;
+    /**
+     * Apply filters to dataset, return the filtered dataset with updated `gpuFilter`, `filterRecord`, `filteredIndex`, `filteredIndexForDomain`
+     * @param filters
+     * @param layers
+     * @param opt
+     */
+    filterTable(filters: Filter[], layers: Layer[], opt?: FilterDatasetOpt): KeplerTable;
+    /**
+     * Apply filters to a dataset all on CPU, assign to `filteredIdxCPU`, `filterRecordCPU`
+     * @param filters
+     * @param layers
+     */
+    filterTableCPU(filters: Filter[], layers: Layer[]): KeplerTable;
+    /**
+     * Calculate field domain based on field type and data
+     * for Filter
+     */
+    getColumnFilterDomain(field: Field): FieldDomain;
+    /**
+     *  Get the domain of this column based on scale type
+     */
+    getColumnLayerDomain(field: Field, scaleType: string): number[] | string[] | [number, number] | null;
+    calculateLegend(leftField: any, rightField: any): {
+        label: any;
+        color: any;
+    }[];
+    /**
+     * Get a sample of rows to calculate layer boundaries
+     */
+    /**
+     * Parse cell value based on column type and return a string representation
+     * Value the field value, type the field type
+     */
+    /**
+     * Assert whether field exist
+     * @param fieldName
+     * @param condition
+     */
+    _assetField(fieldName: string, condition: any): void;
+}
+export declare function removeSuffixAndDelimiters(layerName: any, suffix: any): any;
+/**
+ * Find point fields pairs from fields
+ *
+ * @param fields
+ * @returns found point fields
+ */
+export declare function findPointFieldPairs(fields: Field[]): FieldPair[];
+/**
+ *
+ * @param dataset
+ * @param column
+ * @param mode
+ * @type
+ */
+export declare function sortDatasetByColumn(dataset: KeplerTable, column: string, mode?: string): KeplerTable;
+export declare function pinTableColumns(dataset: KeplerTable, column: string): KeplerTable;
+export declare function copyTable<T extends {}>(original: T): T;
+/**
+ * @type
+ * @returns
+ */
+export declare function copyTableAndUpdate<T extends {}>(original: T, options?: Partial<T>): T;
+export default KeplerTable;