@kepler.gl/utils 3.1.0-alpha.1 → 3.1.0-alpha.3

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

@@ -0,0 +1,138 @@
+import { ProtoDatasetField } from '@kepler.gl/types';
+import { DataRow, SharedRowOptions } from './data-row';
+/**
+ * Specifies a range of rows of a data container that should be processed.
+ */
+export declare type RangeOptions = {
+    start?: number;
+    end?: number;
+};
+export interface DataContainerInterface {
+    /**
+     * Updates the data container with new data.
+     * @param updateData updated data, e.g. for arrow data container, it's an array of arrow columns; for row data container, it's an array of rows.
+     */
+    update?(updateData: any[]): void;
+    /**
+     * 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 the column object at the specified index.
+     * @param columnIndex Column index.
+     * @returns The column object at the specified index.
+     */
+    getColumn?(columnIndex: number): unknown;
+    /**
+     * Returns the field object at the specified index.
+     * @param columnIndex Column index.
+     * @returns The field object at the specified index.
+     */
+    getField?(columnIndex: number): ProtoDatasetField;
+    /**
+     * Returns the underlying data object.
+     * @returns Returns the underlying data object.
+     */
+    getTable?(): unknown;
+    /**
+     * 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: number }: {
+        index: any;
+    }, 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/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/data-container-interface.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {ProtoDatasetField} from '@kepler.gl/types';\nimport {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   * Updates the data container with new data.\n   * @param updateData updated data, e.g. for arrow data container, it's an array of arrow columns; for row data container, it's an array of rows.\n   */\n  update?(updateData: any[]): void;\n\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 the column object at the specified index.\n   * @param columnIndex Column index.\n   * @returns The column object at the specified index.\n   */\n  getColumn?(columnIndex: number): unknown;\n\n  /**\n   * Returns the field object at the specified index.\n   * @param columnIndex Column index.\n   * @returns The field object at the specified index.\n   */\n  getField?(columnIndex: number): ProtoDatasetField;\n\n  /**\n   * Returns the underlying data object.\n   * @returns Returns the underlying data object.\n   */\n  getTable?(): unknown;\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: 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/data-container-utils.d.ts

@@ -0,0 +1,30 @@
+import { DataContainerInterface } from './data-container-interface';
+import { ProtoDatasetField } from '@kepler.gl/types';
+export declare type DataContainerOptions = {
+    inputDataFormat?: string;
+    fields?: ProtoDatasetField[];
+};
+export declare const DataForm: {
+    ROWS_ARRAY: string;
+    COLS_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/data-container-utils.js

@@ -0,0 +1,74 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DataForm = void 0;
+exports.createDataContainer = createDataContainer;
+exports.createIndexedDataContainer = createIndexedDataContainer;
+exports.getSampleData = getSampleData;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _arrowDataContainer = require("./arrow-data-container");
+var _rowDataContainer = require("./row-data-container");
+var _indexedDataContainer = require("./indexed-data-container");
+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; } // SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+var DataForm = exports.DataForm = {
+  ROWS_ARRAY: 'ROWS_ARRAY',
+  COLS_ARRAY: 'COLS_ARRAY'
+};
+var defaultOptions = {
+  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.
+ */
+function createDataContainer(data) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultOptions;
+  options = _objectSpread(_objectSpread({}, defaultOptions), options);
+  if (options.inputDataFormat === DataForm.ROWS_ARRAY) {
+    return new _rowDataContainer.RowDataContainer({
+      rows: data,
+      fields: options.fields
+    });
+  } else if (options.inputDataFormat === DataForm.COLS_ARRAY) {
+    return new _arrowDataContainer.ArrowDataContainer({
+      cols: 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.
+ */
+function createIndexedDataContainer(dataContainer, indices) {
+  return new _indexedDataContainer.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.
+ */
+function getSampleData(dataContainer) {
+  var sampleSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 500;
+  var numberOfRows = dataContainer.numRows();
+  var sampleStep = Math.max(Math.floor(numberOfRows / sampleSize), 1);
+  var indices = [];
+  for (var i = 0; i < numberOfRows; i += sampleStep) {
+    indices.push(i);
+  }
+  return createIndexedDataContainer(dataContainer, indices);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/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 declare 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 declare 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/data-row.js

@@ -0,0 +1,110 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DataRow = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+// SPDX-License-Identifier: MIT
+// Copyright contributors to the kepler.gl project
+/**
+ * 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);
+    (0, _defineProperty2["default"])(this, "_dataContainer", void 0);
+    (0, _defineProperty2["default"])(this, "_rowIndex", void 0);
+    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.
+   */
+  return (0, _createClass2["default"])(DataRow, [{
+    key: "valueAt",
+    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 ? 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 _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);
+      }
+      return out;
+    }
+  }], [{
+    key: "createSharedRow",
+    value: function createSharedRow(sharedRowDesc) {
+      if (sharedRowDesc === true) {
+        return new DataRow(null, 0);
+      }
+      return sharedRowDesc;
+    }
+  }]);
+}();
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/data-scale-utils.d.ts

@@ -0,0 +1,119 @@
+import { ColorMap, ColorRange, HexColor, MapState } from '@kepler.gl/types';
+import { DataContainerInterface } from './data-container-interface';
+export declare type ColorBreak = {
+    data: HexColor;
+    label: string;
+    range: number[];
+    inputs: number[];
+};
+export declare type ColorBreakOrdinal = {
+    data: HexColor;
+    label: string;
+};
+export declare type D3ScaleFunction = Record<string, any> & ((x: any) => any);
+declare type Layer = any;
+declare type VisualChannel = any;
+declare type VisualChannelDomain = any;
+export declare type LabelFormat = (n: number) => string;
+declare type dataValueAccessor = <T>(param: T) => T;
+declare type dataContainerValueAccessor = (d: {
+    index: number;
+}, dc: DataContainerInterface) => any;
+declare type sort = (a: any, b: any) => any;
+/**
+ * return quantile domain for an array of data
+ */
+export declare function getQuantileDomain(data: any[], valueAccessor?: dataValueAccessor, sortFunc?: sort): number[];
+/**
+ * return ordinal domain for a data container
+ */
+export declare function getOrdinalDomain(dataContainer: DataContainerInterface, valueAccessor: dataContainerValueAccessor): string[];
+/**
+ * return linear domain for an array of data
+ */
+export declare function getLinearDomain(data: number[], valueAccessor?: dataValueAccessor): [number, number];
+/**
+ * return linear domain for an array of data. A log scale domain cannot contain 0
+ */
+export declare function getLogDomain(data: any[], valueAccessor: dataValueAccessor): [number, number];
+export declare type DomainStops = {
+    stops: number[];
+    z: number[];
+};
+/**
+ * whether field domain is stops
+ */
+export declare function isDomainStops(domain: unknown): domain is DomainStops;
+export declare type DomainQuantiles = {
+    quantiles: number[];
+    z: number[];
+};
+/**
+ * whether field domain is quantiles
+ */
+export declare function isDomainQuantile(domain: any): domain is DomainQuantiles;
+/**
+ * get the domain at zoom
+ */
+export declare function getThresholdsFromQuantiles(quantiles: number[], buckets: number): (number | undefined)[];
+/**
+ * get the domain at zoom
+ */
+export declare function getDomainStepsbyZoom(domain: any[], steps: number[], z: number): any;
+/**
+ * Get d3 scale function
+ */
+export declare function getScaleFunction(scale: string, range: any[] | IterableIterator<any>, domain: (number | undefined)[] | string[] | IterableIterator<any>, fixed?: boolean): D3ScaleFunction;
+/**
+ * Get linear / quant scale color breaks
+ */
+export declare function getQuantLegends(scale: D3ScaleFunction, labelFormat: LabelFormat): ColorBreak[];
+/**
+ * Get ordinal color scale legends
+ */
+export declare function getOrdinalLegends(scale: D3ScaleFunction): ColorBreakOrdinal[];
+export declare function getQuantLabelFormat(domain: any, fieldType: any): (d: any) => any;
+/**
+ * Get legends for scale
+ */
+export declare function getLegendOfScale({ scale, scaleType, labelFormat, fieldType }: {
+    scale?: D3ScaleFunction | null;
+    scaleType: string;
+    labelFormat?: LabelFormat;
+    fieldType: string | null | undefined;
+}): ColorBreak[] | ColorBreakOrdinal[];
+/**
+ * Get color scale function
+ */
+export declare function getLayerColorScale({ range, domain, scaleType, layer }: {
+    range: ColorRange | null | undefined;
+    domain: VisualChannelDomain;
+    scaleType: string;
+    layer: Layer;
+    isFixed?: boolean;
+}): D3ScaleFunction | null;
+/**
+ * Convert colorRange.colorMap into color breaks UI input
+ */
+export declare function initializeLayerColorMap(layer: Layer, visualChannel: VisualChannel): ColorMap;
+/**
+ * Get visual chanel scale function if it's based on zoom
+ */
+export declare function getVisualChannelScaleByZoom({ scale, layer, mapState }: {
+    scale: D3ScaleFunction | null;
+    layer: Layer;
+    mapState?: MapState;
+}): D3ScaleFunction | null;
+/**
+ * Convert color breaks UI input into colorRange.colorMap
+ */
+export declare function colorBreaksToColorMap(colorBreaks: ColorBreak[] | ColorBreakOrdinal[]): ColorMap;
+/**
+ * Convert colorRange.colorMap into color breaks UI input
+ */
+export declare function colorMapToColorBreaks(colorMap?: ColorMap): ColorBreak[] | null;
+/**
+ * Whether color breaks is for numeric field
+ */
+export declare function isNumericColorBreaks(colorBreaks: unknown): colorBreaks is ColorBreak[];
+export {};