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

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-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-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/index.d.ts

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

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;
+}

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;

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

@@ -0,0 +1,31 @@
+import { DataRow, SharedRowOptions } from './data-row';
+import { Field } from './kepler-table';
+import { DataContainerInterface, RangeOptions } from './data-container-interface';
+type RowDataContainerInput = {
+    rows: any[][];
+    fields?: Field[];
+};
+/**
+ * A data container where all data is stored internally as a 2D array.
+ */
+export declare class RowDataContainer implements DataContainerInterface {
+    _rows: any[][];
+    _numColumns: number;
+    constructor(data: RowDataContainerInput);
+    numRows(): number;
+    numColumns(): number;
+    valueAt(rowIndex: number, columnIndex: number): any;
+    row(rowIndex: number, sharedRow?: SharedRowOptions): DataRow;
+    rowAsArray(rowIndex: number): any[];
+    rows(sharedRow: SharedRowOptions): any;
+    column(columnIndex: number): Generator<any, void, unknown>;
+    flattenData(): any[][];
+    getPlainIndex(): number[];
+    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;
+}
+export {};

package/dist/utils/utils.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Generate a hash string based on number of character
+ * @param {number} count
+ * @returns {string} hash string
+ */
+export declare function generateHashId(count?: number): string;
+/**
+ * Detect chrome
+ * @returns {boolean} - yes or no
+ */
+export declare function isChrome(): any;
+/**
+ * whether is an object
+ * @returns {boolean} - yes or no
+ */
+export declare function isPlainObject(obj: unknown): obj is Record<string, unknown>;
+/**
+ * whether object has property
+ * @param {string} prop
+ * @returns {boolean} - yes or no
+ */
+export declare function hasOwnProperty<X extends {}, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown>;
+/**
+ * Capitalize first letter of a string
+ * @param {string} str
+ * @returns {string}
+ */
+export declare function capitalizeFirstLetter(str: any): any;
+/**
+ * Convert camel style names to title
+ * strokeColor -> Stroke Color
+ * @param {string} str
+ * @returns {string}
+ */
+export declare function camelToTitle(str: any): any;
+/**
+ * Convert names to camel style
+ * Stroke Color -> strokeColor
+ * @param {string} str
+ * @returns {string}
+ */
+export declare const camelize: (str: any) => any;
+/**
+ * Returns the img url for a given map export option
+ * @param mode export option
+ * @return {string} url
+ */
+export declare function getHTMLMapModeTileUrl(mode: any): string;
+/**
+ * Converts non-arrays to arrays.  Leaves arrays alone.  Converts
+ * undefined values to empty arrays ([] instead of [undefined]).
+ * Otherwise, just returns [item] for non-array items.
+ *
+ * @param {*} item
+ * @returns {array} boom! much array. very indexed. so useful.
+ */
+export declare function toArray(item: any): any[];
+/**
+ * immutably insert value to an Array or Object
+ * @param {Array|Object} obj
+ * @param {Number|String} key
+ * @param {*} value
+ * @returns {Array|Object}
+ */
+export declare const insertValue: (obj: any, key: any, value: any) => any;
+/**
+ * check if value is a loose object including a plain object, array, function
+ * @param {*} value
+ */
+export declare function isObject(value: any): boolean;
+/**
+ * Immutable version of _.set
+ * @param {Array<String|Number>} path
+ * @param {*} value
+ * @param {Object} obj
+ * @returns {Object}
+ */
+export declare const set: (path: any, value: any, obj: any) => any;
+/**
+ * Get error information of unknown type
+ * Extracts as much human readable information as possible
+ * Ensure result is an Error object suitable for throw or promise rejection
+ *
+ * @private
+ * @param {*}  err - Unknown error
+ * @return {string} - human readable error msg
+ */
+export declare function getError(err: any): any;
+export declare function arrayInsert(arr: any, index: any, val: any): any;
+export declare function isTest(): boolean;
+/**
+ * Filters an object by an arbitrary predicate
+ * Returns a new object containing all elements that match the predicate
+ * @param {Object} obj Object to be filtered
+ * @param {Function} predicate Predicate by which the object will be filtered
+ * @returns {Object}
+ */
+export declare function filterObjectByPredicate(obj: any, predicate: any): {};