@carto/kepler.gl 0.0.76 → 0.0.78-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-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: 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;
+  }
+}