@carto/kepler.gl 0.0.80 → 0.1.0-alpha.0

package/src/utils/split-map-utils.ts

@@ -0,0 +1,104 @@
+// 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.
+
+import cloneDeep from 'lodash.clonedeep';
+
+/**
+ * Add new layers to both existing maps
+ * @param {Object} splitMaps
+ * @param {Object|Array<Object>} layers
+ * @returns {Array<Object>} new splitMaps
+ */
+export function addNewLayersToSplitMap(splitMaps, layers) {
+  const 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(settings => ({
+    ...settings,
+    layers: {
+      ...settings.layers,
+      ...newLayers.reduce(
+        (accu, newLayer) =>
+          // @ts-ignore
+          newLayer.id in settings.layers || !newLayer.config.isVisible
+            ? accu
+            : {
+                ...accu,
+                [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
+ */
+export function removeLayerFromSplitMaps(splitMaps, layer) {
+  if (!splitMaps.length) {
+    return splitMaps;
+  }
+  return splitMaps.map(settings => {
+    // eslint-disable-next-line no-unused-vars
+    const {[layer.id]: _, ...newLayers} = settings.layers;
+    return {
+      ...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
+ */
+export function getInitialMapLayersForSplitMap(layers) {
+  return layers
+    .filter(layer => layer.config.isVisible)
+    .reduce(
+      (newLayers, currentLayer) => ({
+        ...newLayers,
+        [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
+ */
+export function computeSplitMapLayers(layers) {
+  const mapLayers = getInitialMapLayersForSplitMap(layers);
+
+  return [{layers: mapLayers}, {layers: cloneDeep(mapLayers)}];
+}

package/src/utils/table-utils/data-container-interface.ts

@@ -0,0 +1,140 @@
+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/src/utils/table-utils/data-container-utils.ts

@@ -0,0 +1,90 @@
+// 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.
+
+import {RowDataContainer} from './row-data-container';
+import {IndexedDataContainer} from './indexed-data-container';
+
+import {DataContainerInterface} from './data-container-interface';
+import {Field} from './kepler-table';
+
+export type DataContainerOptions = {
+  inputDataFormat?: string; // one of DataForm
+  fields?: Field[];
+};
+
+export const DataForm = {
+  ROWS_ARRAY: 'ROWS_ARRAY'
+};
+
+const defaultOptions: DataContainerOptions = {
+  inputDataFormat: DataForm.ROWS_ARRAY
+};
+
+/**
+ * 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 function createDataContainer(
+  data: any[],
+  options: DataContainerOptions = defaultOptions
+): DataContainerInterface {
+  options = {...defaultOptions, ...options};
+
+  if (options.inputDataFormat === DataForm.ROWS_ARRAY) {
+    return new RowDataContainer({rows: data, fields: options.fields});
+  }
+
+  throw Error('Failed to create a data container: not implemented format');
+}
+
+/**
+ * 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 function createIndexedDataContainer(
+  dataContainer: DataContainerInterface,
+  indices: number[]
+): DataContainerInterface {
+  return new IndexedDataContainer(dataContainer, indices);
+}
+
+/**
+ * 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 function getSampleData(
+  dataContainer: DataContainerInterface,
+  sampleSize = 500
+): DataContainerInterface {
+  const numberOfRows = dataContainer.numRows();
+  const sampleStep = Math.max(Math.floor(numberOfRows / sampleSize), 1);
+
+  const indices: number[] = [];
+  for (let i = 0; i < numberOfRows; i += sampleStep) {
+    indices.push(i);
+  }
+
+  return createIndexedDataContainer(dataContainer, indices);
+}

package/src/utils/table-utils/data-row.ts

@@ -0,0 +1,110 @@
+// 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.
+
+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 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) {
+    this._dataContainer = dataContainer;
+    this._rowIndex = rowIndex;
+  }
+
+  /**
+   * 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 {
+    if (sharedRowDesc === true) {
+      return new DataRow(null, 0);
+    }
+    return sharedRowDesc;
+  }
+
+  /**
+   * 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 {
+    return this._dataContainer?.valueAt(this._rowIndex, columnIndex);
+  }
+
+  /**
+   * Returns the row represented as an array.
+   * @returns The row represented as an array.
+   */
+  values(): any[] {
+    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.
+   */
+  setSource(dataContainer: DataContainerInterface, rowIndex: number): void {
+    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.
+   */
+  map(handler: (elem: any, index: number) => any): any[] {
+    const numColumns = this._dataContainer?.numColumns() || 0;
+    const out: any[] = [];
+    for (let column = 0; column < numColumns; ++column) {
+      out[column] = handler(this.valueAt(column), column);
+    }
+    return out;
+  }
+}

package/src/utils/table-utils/indexed-data-container.ts

@@ -0,0 +1,184 @@
+// 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.
+
+import {DataContainerInterface, RangeOptions} from './data-container-interface';
+import {DataRow, SharedRowOptions} from './data-row';
+
+/**
+ * @param dataContainer
+ * @param indices
+ * @param sharedRow
+ * @returns
+ */
+function* rowsIterator(
+  dataContainer: DataContainerInterface,
+  indices: number[],
+  sharedRow: SharedRowOptions
+): Generator<DataRow> {
+  const numRows = indices.length;
+  for (let rowIndex = 0; rowIndex < numRows; ++rowIndex) {
+    const mappedRowIndex = indices[rowIndex];
+    yield dataContainer.row(mappedRowIndex, sharedRow);
+  }
+}
+
+/**
+ * @param dataContainer
+ * @param indices
+ * @param columnIndex
+ * @returns
+ */
+function* columnIterator(
+  dataContainer: DataContainerInterface,
+  indices: number[],
+  columnIndex: number
+): Generator<any> {
+  const numRows = indices.length;
+  for (let rowIndex = 0; rowIndex < numRows; ++rowIndex) {
+    const mappedRowIndex = indices[rowIndex];
+    yield dataContainer.valueAt(mappedRowIndex, columnIndex);
+  }
+}
+
+/**
+ * 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 class IndexedDataContainer implements DataContainerInterface {
+  _parentDataContainer: DataContainerInterface;
+  _indices: number[];
+
+  constructor(parentDataContainer: DataContainerInterface, indices: number[]) {
+    this._parentDataContainer = parentDataContainer;
+    this._indices = indices;
+  }
+
+  numRows(): number {
+    return this._indices.length;
+  }
+
+  numColumns(): number {
+    return this._parentDataContainer.numColumns();
+  }
+
+  /**
+   * Remaps a local index to an index in the parent dataset
+   * @param rowIndex
+   * @returns number
+   */
+  _mappedRowIndex(rowIndex: number): number {
+    return this._indices[rowIndex];
+  }
+
+  valueAt(rowIndex: number, columnIndex: number): any {
+    return this._parentDataContainer.valueAt(this._mappedRowIndex(rowIndex), columnIndex);
+  }
+
+  row(rowIndex: number, sharedRow?: SharedRowOptions): DataRow {
+    return this._parentDataContainer.row(this._mappedRowIndex(rowIndex), sharedRow);
+  }
+
+  rowAsArray(rowIndex: number): any[] {
+    return this._parentDataContainer.rowAsArray(this._mappedRowIndex(rowIndex));
+  }
+
+  rows(sharedRow?: SharedRowOptions) {
+    return rowsIterator(this._parentDataContainer, this._indices, sharedRow);
+  }
+
+  column(columnIndex: number) {
+    return columnIterator(this._parentDataContainer, this._indices, columnIndex);
+  }
+
+  getPlainIndex(): number[] {
+    return this._indices.map((_, i) => i);
+  }
+
+  flattenData(): any[][] {
+    const tSharedRow = DataRow.createSharedRow(true);
+
+    return this._indices.map((_, i) => {
+      return this.row(i, tSharedRow).values();
+    }, this);
+  }
+
+  map<T>(
+    func: (row: DataRow, index: number) => T,
+    sharedRow?: SharedRowOptions,
+    options: RangeOptions = {}
+  ): T[] {
+    const {start = 0, end = this.numRows()} = options;
+    const endRow = Math.min(this.numRows(), end);
+
+    const tSharedRow = DataRow.createSharedRow(sharedRow);
+
+    const out: T[] = [];
+    for (let rowIndex = start; rowIndex < endRow; ++rowIndex) {
+      const row = this.row(rowIndex, tSharedRow);
+      out.push(func(row, rowIndex));
+    }
+    return out;
+  }
+
+  mapIndex<T>(
+    func: ({index}: {index: number}, dc: DataContainerInterface) => T,
+    options: RangeOptions = {}
+  ): T[] {
+    const {start = 0, end = this.numRows()} = options;
+    const endRow = Math.min(this.numRows(), end);
+
+    const out: T[] = [];
+    for (let rowIndex = start; rowIndex < endRow; ++rowIndex) {
+      out.push(func({index: this._mappedRowIndex(rowIndex)}, this._parentDataContainer));
+    }
+    return out;
+  }
+
+  find(
+    func: (row: DataRow, index: number) => boolean,
+    sharedRow?: SharedRowOptions
+  ): DataRow | undefined {
+    const tSharedRow = DataRow.createSharedRow(sharedRow);
+
+    for (let rowIndex = 0; rowIndex < this.numRows(); ++rowIndex) {
+      const row = this.row(rowIndex, tSharedRow);
+      if (func(row, rowIndex)) {
+        return row;
+      }
+    }
+    return undefined;
+  }
+
+  reduce<T>(
+    func: (acc: T, row: DataRow, index: number) => T,
+    initialValue: T,
+    sharedRow?: SharedRowOptions
+  ): T {
+    const tSharedRow = DataRow.createSharedRow(sharedRow);
+
+    for (let rowIndex = 0; rowIndex < this._indices.length; ++rowIndex) {
+      const row = this.row(rowIndex, tSharedRow);
+      initialValue = func(initialValue, row, rowIndex);
+    }
+    return initialValue;
+  }
+}