@deck.gl/aggregation-layers 8.8.0-alpha.6 → 8.8.0-beta.1

package/typed/screen-grid-layer/screen-grid-layer.d.ts

@@ -1,34 +1,117 @@
-declare class ScreenGridLayer extends GridAggregationLayer {
+import { Accessor, Color, GetPickingInfoParams, Layer, LayerContext, LayersList, PickingInfo, Position, UpdateParameters } from '@deck.gl/core/typed';
+import type { Texture2D } from '@luma.gl/core';
+import GridAggregationLayer, { GridAggregationLayerProps } from '../grid-aggregation-layer';
+/** All properties supported by ScreenGridLayer. */
+export declare type ScreenGridLayerProps<DataT> = _ScreenGridLayerProps<DataT> & GridAggregationLayerProps<DataT>;
+/** Properties added by ScreenGridLayer. */
+export declare type _ScreenGridLayerProps<DataT = any> = {
+    /**
+     * Unit width/height of the bins.
+     * @default 100
+     */
+    cellSizePixels?: number;
+    /**
+     * Cell margin size in pixels.
+     * @default 2
+     */
+    cellMarginPixels?: number;
+    /**
+     * Expressed as an rgba array, minimal color that could be rendered by a tile.
+     * @default [0, 0, 0, 255]
+     * @deprecated Deprecated in version 5.2.0, use `colorRange` and `colorDomain` instead.
+     */
+    minColor?: Color | null;
+    /**
+     * Expressed as an rgba array, maximal color that could be rendered by a tile.
+     * @default [0, 255, 0, 255]
+     * @deprecated Deprecated in version 5.2.0, use `colorRange` and `colorDomain` instead.
+     */
+    maxColor?: Color | null;
+    /**
+     * Color scale input domain. The color scale maps continues numeric domain into discrete color range.
+     * @default [1, max(weight)]
+     */
+    colorDomain?: [number, number] | null;
+    /**
+     * Specified as an array of colors [color1, color2, ...].
+     *
+     * @default `6-class YlOrRd` - [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6)
+     */
+    colorRange?: Color[];
+    /**
+     * Method called to retrieve the position of each object.
+     *
+     * @default d => d.position
+     */
+    getPosition?: Accessor<DataT, Position>;
+    /**
+     * The weight of each object.
+     *
+     * @default 1
+     */
+    getWeight?: Accessor<DataT, number>;
+    /**
+     * Perform aggregation is performed on GPU.
+     *
+     * NOTE: GPU Aggregation requires WebGL2 support by the browser.
+     * When `gpuAggregation` is set to true and browser doesn't support WebGL2, aggregation falls back to CPU.
+     *
+     * @default true
+     */
+    gpuAggregation?: boolean;
+    /**
+     * Defines the type of aggregation operation
+     *
+     * V valid values are 'SUM', 'MEAN', 'MIN' and 'MAX'.
+     *
+     * @default 'SUM'
+     */
+    aggregation?: 'SUM' | 'MEAN' | 'MIN' | 'MAX';
+};
+export default class ScreenGridLayer<DataT = any, ExtraProps = {}> extends GridAggregationLayer<ExtraProps & Required<_ScreenGridLayerProps<DataT>>> {
+    static layerName: string;
+    static defaultProps: {
+        getPosition: {
+            type: string;
+            value: (d: any) => any;
+        };
+        getWeight: {
+            type: string;
+            value: number;
+        };
+        gpuAggregation: boolean;
+        aggregation: string;
+        cellSizePixels: {
+            value: number;
+            min: number;
+        };
+        cellMarginPixels: {
+            value: number;
+            min: number;
+            max: number;
+        };
+        colorDomain: null;
+        colorRange: number[][];
+    };
+    state: GridAggregationLayer['state'] & {
+        supported: boolean;
+        gpuGridAggregator?: any;
+        gpuAggregation?: any;
+        weights?: any;
+        maxTexture?: Texture2D;
+    };
+    initializeState(): void;
+    shouldUpdateState({ changeFlags }: UpdateParameters<this>): boolean;
+    updateState(opts: UpdateParameters<this>): void;
+    renderLayers(): LayersList | Layer;
+    finalizeState(context: LayerContext): void;
+    getPickingInfo({ info }: GetPickingInfoParams): PickingInfo;
+    updateResults({ aggregationData, maxData }: {
+        aggregationData: any;
+        maxData: any;
+    }): void;
+    updateAggregationState(opts: any): void;
     _updateAccessors(opts: any): void;
     _resetResults(): void;
 }
-declare namespace ScreenGridLayer {
-    export const layerName: string;
-    export { defaultProps };
-}
-export default ScreenGridLayer;
-import GridAggregationLayer from "../grid-aggregation-layer";
-declare const defaultProps: {
-    getPosition: {
-        type: string;
-        value: (d: any) => any;
-    };
-    getWeight: {
-        type: string;
-        value: number;
-    };
-    gpuAggregation: boolean;
-    aggregation: string;
-    cellSizePixels: {
-        value: number;
-        min: number;
-    };
-    cellMarginPixels: {
-        value: number;
-        min: number;
-        max: number;
-    };
-    colorDomain: null;
-    colorRange: number[][];
-};
 //# sourceMappingURL=screen-grid-layer.d.ts.map

package/typed/screen-grid-layer/screen-grid-layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"screen-grid-layer.d.ts","sourceRoot":"","sources":["../../src/screen-grid-layer/screen-grid-layer.js"],"names":[],"mappings":"AAgDA;IAqLE,kCAQC;IAED,sBAKC;CACF;;;;;;;AAzND;;;;;;;;;;;;;;;;;;;;;;EAOE"}
+{"version":3,"file":"screen-grid-layer.d.ts","sourceRoot":"","sources":["../../src/screen-grid-layer/screen-grid-layer.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,QAAQ,EACR,KAAK,EACL,oBAAoB,EACpB,KAAK,EACL,YAAY,EACZ,UAAU,EAEV,WAAW,EACX,QAAQ,EACR,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,eAAe,CAAC;AAI7C,OAAO,oBAAoB,EAAE,EAAC,yBAAyB,EAAC,MAAM,2BAA2B,CAAC;AAuB1F,mDAAmD;AACnD,oBAAY,oBAAoB,CAAC,KAAK,IAAI,qBAAqB,CAAC,KAAK,CAAC,GACpE,yBAAyB,CAAC,KAAK,CAAC,CAAC;AAEnC,2CAA2C;AAC3C,oBAAY,qBAAqB,CAAC,KAAK,GAAG,GAAG,IAAI;IAC/C;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IAExB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IAExB;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAEtC;;;;OAIG;IACH,UAAU,CAAC,EAAE,KAAK,EAAE,CAAC;IAErB;;;;OAIG;IACH,WAAW,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAExC;;;;OAIG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAEpC;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;CAC9C,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,eAAe,CAAC,KAAK,GAAG,GAAG,EAAE,UAAU,GAAG,EAAE,CAAE,SAAQ,oBAAoB,CAC7F,UAAU,GAAG,QAAQ,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC,CACpD;IACC,MAAM,CAAC,SAAS,SAAqB;IACrC,MAAM,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;MAAgB;IAEnC,KAAK,EAAG,oBAAoB,CAAC,OAAO,CAAC,GAAG;QACtC,SAAS,EAAE,OAAO,CAAC;QACnB,iBAAiB,CAAC,EAAE,GAAG,CAAC;QACxB,cAAc,CAAC,EAAE,GAAG,CAAC;QACrB,OAAO,CAAC,EAAE,GAAG,CAAC;QACd,UAAU,CAAC,EAAE,SAAS,CAAC;KACxB,CAAC;IAEF,eAAe;IA4Cf,iBAAiB,CAAC,EAAC,WAAW,EAAC,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAIvD,WAAW,CAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAIxC,YAAY,IAAI,UAAU,GAAG,KAAK;IAuBlC,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAU1C,cAAc,CAAC,EAAC,IAAI,EAAC,EAAE,oBAAoB,GAAG,WAAW;IAsBzD,aAAa,CAAC,EAAC,eAAe,EAAE,OAAO,EAAC;;;KAAA;IASxC,sBAAsB,CAAC,IAAI,KAAA;IAiE3B,gBAAgB,CAAC,IAAI,KAAA;IAUrB,aAAa;CAMd"}

package/typed/screen-grid-layer/screen-grid-layer.js

@@ -0,0 +1,216 @@
+// Copyright (c) 2015 - 2017 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 { log } from '@deck.gl/core';
+import GL from '@luma.gl/constants';
+import GPUGridAggregator from '../utils/gpu-grid-aggregation/gpu-grid-aggregator';
+import { AGGREGATION_OPERATION, getValueFunc } from '../utils/aggregation-operation-utils';
+import ScreenGridCellLayer from './screen-grid-cell-layer';
+import GridAggregationLayer from '../grid-aggregation-layer';
+import { getFloatTexture } from '../utils/resource-utils.js';
+const defaultProps = {
+    ...ScreenGridCellLayer.defaultProps,
+    getPosition: { type: 'accessor', value: d => d.position },
+    getWeight: { type: 'accessor', value: 1 },
+    gpuAggregation: true,
+    aggregation: 'SUM'
+};
+const POSITION_ATTRIBUTE_NAME = 'positions';
+const DIMENSIONS = {
+    data: {
+        props: ['cellSizePixels']
+    },
+    weights: {
+        props: ['aggregation'],
+        accessors: ['getWeight']
+    }
+};
+export default class ScreenGridLayer extends GridAggregationLayer {
+    initializeState() {
+        const { gl } = this.context;
+        if (!ScreenGridCellLayer.isSupported(gl)) {
+            // max aggregated value is sampled from a float texture
+            this.setState({ supported: false });
+            log.error(`ScreenGridLayer: ${this.id} is not supported on this browser`)();
+            return;
+        }
+        super.initializeAggregationLayer({
+            dimensions: DIMENSIONS,
+            // @ts-expect-error
+            getCellSize: props => props.cellSizePixels // TODO
+        });
+        const weights = {
+            count: {
+                size: 1,
+                operation: AGGREGATION_OPERATION.SUM,
+                needMax: true,
+                maxTexture: getFloatTexture(gl, { id: `${this.id}-max-texture` })
+            }
+        };
+        this.setState({
+            supported: true,
+            projectPoints: true,
+            weights,
+            subLayerData: { attributes: {} },
+            maxTexture: weights.count.maxTexture,
+            positionAttributeName: 'positions',
+            posOffset: [0, 0],
+            translation: [1, -1]
+        });
+        const attributeManager = this.getAttributeManager();
+        attributeManager.add({
+            [POSITION_ATTRIBUTE_NAME]: {
+                size: 3,
+                accessor: 'getPosition',
+                type: GL.DOUBLE,
+                fp64: this.use64bitPositions()
+            },
+            // this attribute is used in gpu aggregation path only
+            count: { size: 3, accessor: 'getWeight' }
+        });
+    }
+    shouldUpdateState({ changeFlags }) {
+        return this.state.supported && changeFlags.somethingChanged;
+    }
+    updateState(opts) {
+        super.updateState(opts);
+    }
+    renderLayers() {
+        if (!this.state.supported) {
+            return [];
+        }
+        const { maxTexture, numRow, numCol, weights } = this.state;
+        const { updateTriggers } = this.props;
+        const { aggregationBuffer } = weights.count;
+        const CellLayerClass = this.getSubLayerClass('cells', ScreenGridCellLayer);
+        return new CellLayerClass(this.props, this.getSubLayerProps({
+            id: 'cell-layer',
+            updateTriggers
+        }), {
+            data: { attributes: { instanceCounts: aggregationBuffer } },
+            maxTexture,
+            numInstances: numRow * numCol
+        });
+    }
+    finalizeState(context) {
+        super.finalizeState(context);
+        const { aggregationBuffer, maxBuffer, maxTexture } = this.state;
+        aggregationBuffer?.delete();
+        maxBuffer?.delete();
+        maxTexture?.delete();
+    }
+    getPickingInfo({ info }) {
+        const { index } = info;
+        if (index >= 0) {
+            const { gpuGridAggregator, gpuAggregation, weights } = this.state;
+            // Get count aggregation results
+            const aggregationResults = gpuAggregation
+                ? gpuGridAggregator.getData('count')
+                : weights.count;
+            // Each instance (one cell) is aggregated into single pixel,
+            // Get current instance's aggregation details.
+            info.object = GPUGridAggregator.getAggregationData({
+                pixelIndex: index,
+                ...aggregationResults
+            });
+        }
+        return info;
+    }
+    // Aggregation Overrides
+    updateResults({ aggregationData, maxData }) {
+        const { count } = this.state.weights;
+        count.aggregationData = aggregationData;
+        count.aggregationBuffer.setData({ data: aggregationData });
+        count.maxData = maxData;
+        count.maxTexture.setImageData({ data: maxData });
+    }
+    /* eslint-disable complexity, max-statements */
+    updateAggregationState(opts) {
+        const cellSize = opts.props.cellSizePixels;
+        const cellSizeChanged = opts.oldProps.cellSizePixels !== cellSize;
+        const { viewportChanged } = opts.changeFlags;
+        let gpuAggregation = opts.props.gpuAggregation;
+        if (this.state.gpuAggregation !== opts.props.gpuAggregation) {
+            if (gpuAggregation && !GPUGridAggregator.isSupported(this.context.gl)) {
+                log.warn('GPU Grid Aggregation not supported, falling back to CPU')();
+                gpuAggregation = false;
+            }
+        }
+        const gpuAggregationChanged = gpuAggregation !== this.state.gpuAggregation;
+        this.setState({
+            gpuAggregation
+        });
+        const positionsChanged = this.isAttributeChanged(POSITION_ATTRIBUTE_NAME);
+        const { dimensions } = this.state;
+        const { data, weights } = dimensions;
+        const aggregationDataDirty = positionsChanged ||
+            gpuAggregationChanged ||
+            viewportChanged ||
+            this.isAggregationDirty(opts, {
+                compareAll: gpuAggregation,
+                dimension: data
+            });
+        const aggregationWeightsDirty = this.isAggregationDirty(opts, { dimension: weights });
+        this.setState({
+            aggregationDataDirty,
+            aggregationWeightsDirty
+        });
+        const { viewport } = this.context;
+        if (viewportChanged || cellSizeChanged) {
+            const { width, height } = viewport;
+            const numCol = Math.ceil(width / cellSize);
+            const numRow = Math.ceil(height / cellSize);
+            this.allocateResources(numRow, numCol);
+            this.setState({
+                // transformation from clipspace to screen(pixel) space
+                scaling: [width / 2, -height / 2, 1],
+                gridOffset: { xOffset: cellSize, yOffset: cellSize },
+                width,
+                height,
+                numCol,
+                numRow
+            });
+        }
+        if (aggregationWeightsDirty) {
+            this._updateAccessors(opts);
+        }
+        if (aggregationDataDirty || aggregationWeightsDirty) {
+            this._resetResults();
+        }
+    }
+    /* eslint-enable complexity, max-statements */
+    // Private
+    _updateAccessors(opts) {
+        const { getWeight, aggregation, data } = opts.props;
+        const { count } = this.state.weights;
+        if (count) {
+            count.getWeight = getWeight;
+            count.operation = AGGREGATION_OPERATION[aggregation];
+        }
+        this.setState({ getValue: getValueFunc(aggregation, getWeight, { data }) });
+    }
+    _resetResults() {
+        const { count } = this.state.weights;
+        if (count) {
+            count.aggregationData = null;
+        }
+    }
+}
+ScreenGridLayer.layerName = 'ScreenGridLayer';
+ScreenGridLayer.defaultProps = defaultProps;

package/typed/types.d.ts

@@ -0,0 +1,11 @@
+export declare type AggregateAccessor<DataT = any> = {
+    /** a list of objects whose positions fall inside this cell. */
+    objects: DataT[];
+    objectInfo: {
+        /** the indices of `objects` in the original data. */
+        indices: number[];
+        /** the value of the `data` prop */
+        data: any;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/typed/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,oBAAY,iBAAiB,CAAC,KAAK,GAAG,GAAG,IAAI;IAC3C,+DAA+D;IAC/D,OAAO,EAAE,KAAK,EAAE,CAAC;IACjB,UAAU,EAAE;QACV,qDAAqD;QACrD,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,mCAAmC;QACnC,IAAI,EAAE,GAAG,CAAC;KACX,CAAC;CACH,CAAC"}

package/typed/types.js

@@ -0,0 +1 @@
+export {};

package/typed/utils/aggregation-operation-utils.js

@@ -0,0 +1,94 @@
+// Copyright (c) 2015 - 2019 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.
+export const AGGREGATION_OPERATION = {
+    SUM: 1,
+    MEAN: 2,
+    MIN: 3,
+    MAX: 4
+};
+function sumReducer(accu, cur) {
+    return accu + cur;
+}
+function maxReducer(accu, cur) {
+    return cur > accu ? cur : accu;
+}
+function minReducer(accu, cur) {
+    return cur < accu ? cur : accu;
+}
+export function getMean(pts, accessor) {
+    if (Number.isFinite(accessor)) {
+        return pts.length ? accessor : null;
+    }
+    const filtered = pts.map(accessor).filter(Number.isFinite);
+    return filtered.length ? filtered.reduce(sumReducer, 0) / filtered.length : null;
+}
+export function getSum(pts, accessor) {
+    if (Number.isFinite(accessor)) {
+        return pts.length ? pts.length * accessor : null;
+    }
+    const filtered = pts.map(accessor).filter(Number.isFinite);
+    return filtered.length ? filtered.reduce(sumReducer, 0) : null;
+}
+export function getMax(pts, accessor) {
+    if (Number.isFinite(accessor)) {
+        return pts.length ? accessor : null;
+    }
+    const filtered = pts.map(accessor).filter(Number.isFinite);
+    return filtered.length ? filtered.reduce(maxReducer, -Infinity) : null;
+}
+export function getMin(pts, accessor) {
+    if (Number.isFinite(accessor)) {
+        return pts.length ? accessor : null;
+    }
+    const filtered = pts.map(accessor).filter(Number.isFinite);
+    return filtered.length ? filtered.reduce(minReducer, Infinity) : null;
+}
+// Function to convert from aggregation/accessor props (like colorAggregation and getColorWeight) to getValue prop (like getColorValue)
+export function getValueFunc(aggregation, accessor, context) {
+    const op = AGGREGATION_OPERATION[aggregation] || AGGREGATION_OPERATION.SUM;
+    accessor = wrapAccessor(accessor, context);
+    switch (op) {
+        case AGGREGATION_OPERATION.MIN:
+            return pts => getMin(pts, accessor);
+        case AGGREGATION_OPERATION.SUM:
+            return pts => getSum(pts, accessor);
+        case AGGREGATION_OPERATION.MEAN:
+            return pts => getMean(pts, accessor);
+        case AGGREGATION_OPERATION.MAX:
+            return pts => getMax(pts, accessor);
+        default:
+            return null;
+    }
+}
+function wrapAccessor(accessor, context = {}) {
+    if (Number.isFinite(accessor)) {
+        return accessor;
+    }
+    return pt => {
+        context.index = pt.index;
+        return accessor(pt.source, context);
+    };
+}
+export function wrapGetValueFunc(getValue, context = {}) {
+    return pts => {
+        context.indices = pts.map(pt => pt.index);
+        return getValue(pts.map(pt => pt.source), context);
+    };
+}

package/typed/utils/bin-sorter.d.ts

@@ -1,12 +1,23 @@
+declare const defaultProps: {
+    getValue: (points: any) => any;
+    getPoints: (bin: any) => any;
+    getIndex: (bin: any) => any;
+    filterData: null;
+};
+export declare type AggregatedBin = {
+    i: number;
+    value: any;
+    counts: number;
+};
 export default class BinSorter {
-    constructor(bins?: any[], props?: {
-        getValue: (points: any) => any;
-        getPoints: (bin: any) => any;
-        getIndex: (bin: any) => any;
-        filterData: null;
-    });
-    aggregatedBins: any[];
-    binMap: any;
+    maxCount: number;
+    maxValue: number;
+    minValue: number;
+    totalCount: number;
+    aggregatedBins: AggregatedBin[];
+    sortedBins: AggregatedBin[];
+    binMap: Record<number, AggregatedBin>;
+    constructor(bins?: never[], props?: Partial<typeof defaultProps>);
     /**
      * Get an array of object with aggregated values and index of bins
      * Array object will be sorted by value optionally.
@@ -14,23 +25,18 @@ export default class BinSorter {
      * @param {Function} getValue
      * @return {Array} array of values and index lookup
      */
-    getAggregatedBins(bins: any[], props: any): any[];
-    _percentileToIndex(percentileRange: any): number[];
+    getAggregatedBins(bins: any, props: any): AggregatedBin[];
+    _percentileToIndex(percentileRange: any): [number, number];
     /**
      * Get a mapping from cell/hexagon index to sorted bin
      * This is used to retrieve bin value for color calculation
      * @return {Object} bin index to aggregatedBins
      */
-    getBinMap(): any;
+    getBinMap(): Record<number, AggregatedBin>;
     /**
      * Get ths max count of all bins
-     * @return {Number | Boolean} max count
      */
-    _updateMinMaxValues(): number | boolean;
-    maxCount: number | undefined;
-    maxValue: number | undefined;
-    minValue: number | undefined;
-    totalCount: number | undefined;
+    _updateMinMaxValues(): void;
     /**
      * Get range of values of all bins
      * @param {Number[]} range
@@ -38,9 +44,9 @@ export default class BinSorter {
      * @param {Number} range[1] - upper bound
      * @return {Array} array of new value range
      */
-    getValueRange(percentileRange: any): any[];
-    sortedBins: any[] | undefined;
-    getValueDomainByScale(scale: any, [lower, upper]?: [(number | undefined)?, (number | undefined)?]): any;
-    _getScaleDomain(scaleType: any, [lowerIdx, upperIdx]: [any, any]): any;
+    getValueRange(percentileRange: [number, number]): [number, number];
+    getValueDomainByScale(scale: string, [lower, upper]?: [(number | undefined)?, (number | undefined)?]): [number, number] | never[];
+    _getScaleDomain(scaleType: string, [lowerIdx, upperIdx]: [number, number]): [number, number];
 }
+export {};
 //# sourceMappingURL=bin-sorter.d.ts.map

package/typed/utils/bin-sorter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bin-sorter.d.ts","sourceRoot":"","sources":["../../src/utils/bin-sorter.js"],"names":[],"mappings":"AA6CA;IACE;;;;;OAIC;IAHC,sBAAyD;IAEzD,YAA8B;IAGhC;;;;;;OAMG;IACH,kDAmCC;IAED,mDAYC;IAED;;;;OAIG;IACH,iBAMC;IAID;;;OAGG;IACH,uBAFY,gBAAgB,CAiB3B;IAJC,6BAAwB;IACxB,6BAAwB;IACxB,6BAAwB;IACxB,+BAA4B;IAG9B;;;;;;OAMG;IACH,2CAiBC;IAfG,8BAAiF;IAiBrF,wGAUC;IAED,uEAiBC;CACF"}
+{"version":3,"file":"bin-sorter.d.ts","sourceRoot":"","sources":["../../src/utils/bin-sorter.ts"],"names":[],"mappings":"AAsCA,QAAA,MAAM,YAAY;;;;;CAKjB,CAAC;AAEF,oBAAY,aAAa,GAAG;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,GAAG,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,SAAS;IAC5B,QAAQ,EAAG,MAAM,CAAC;IAClB,QAAQ,EAAG,MAAM,CAAC;IAClB,QAAQ,EAAG,MAAM,CAAC;IAClB,UAAU,EAAG,MAAM,CAAC;IAEpB,cAAc,EAAE,aAAa,EAAE,CAAC;IAChC,UAAU,EAAG,aAAa,EAAE,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;gBAE1B,IAAI,UAAK,EAAE,KAAK,GAAE,OAAO,CAAC,OAAO,YAAY,CAAgB;IAMzE;;;;;;OAMG;IACH,iBAAiB,CAAC,IAAI,KAAA,EAAE,KAAK,KAAA,GAAG,aAAa,EAAE;IAqC/C,kBAAkB,CAAC,eAAe,KAAA,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAcrD;;;;OAIG;IACH,SAAS,IAAI,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAU1C;;OAEG;IACH,mBAAmB,IAAI,IAAI;IAiB3B;;;;;;OAMG;IACH,aAAa,CAAC,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAoBlE,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,KAAS,EAAE,KAAW,CAAC,iDAAK;IAYlE,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;CAkB7F"}