@deck.gl/aggregation-layers 9.0.35 → 9.1.0-beta.1

package/dist/utils/color-utils.d.ts

@@ -1,3 +0,0 @@
-export declare const defaultColorRange: [number, number, number][];
-export declare function colorRangeToFlatArray(colorRange: any, normalize?: boolean, ArrayType?: Float32ArrayConstructor): any;
-//# sourceMappingURL=color-utils.d.ts.map

package/dist/utils/color-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"color-utils.d.ts","sourceRoot":"","sources":["../../src/utils/color-utils.ts"],"names":[],"mappings":"AAoBA,eAAO,MAAM,iBAAiB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAOvD,CAAC;AAGF,wBAAgB,qBAAqB,CAAC,UAAU,KAAA,EAAE,SAAS,UAAQ,EAAE,SAAS,0BAAe,OA0B5F"}

package/dist/utils/color-utils.js

@@ -1,53 +0,0 @@
-// 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.
-export const defaultColorRange = [
-    [255, 255, 178],
-    [254, 217, 118],
-    [254, 178, 76],
-    [253, 141, 60],
-    [240, 59, 32],
-    [189, 0, 38]
-];
-// Converts a colorRange array to a flat array with 4 components per color
-export function colorRangeToFlatArray(colorRange, normalize = false, ArrayType = Float32Array) {
-    let flatArray;
-    if (Number.isFinite(colorRange[0])) {
-        // its already a flat array.
-        flatArray = new ArrayType(colorRange);
-    }
-    else {
-        // flatten it
-        flatArray = new ArrayType(colorRange.length * 4);
-        let index = 0;
-        for (let i = 0; i < colorRange.length; i++) {
-            const color = colorRange[i];
-            flatArray[index++] = color[0];
-            flatArray[index++] = color[1];
-            flatArray[index++] = color[2];
-            flatArray[index++] = Number.isFinite(color[3]) ? color[3] : 255;
-        }
-    }
-    if (normalize) {
-        for (let i = 0; i < flatArray.length; i++) {
-            flatArray[i] /= 255;
-        }
-    }
-    return flatArray;
-}

package/dist/utils/cpu-aggregator.d.ts

@@ -1,169 +0,0 @@
-export default class CPUAggregator {
-    state: {
-        layerData: {
-            data?: any[];
-        };
-        dimensions: Record<string, any>;
-    };
-    changeFlags: Record<string, any>;
-    dimensionUpdaters: Record<string, any>;
-    _getCellSize: any;
-    _getAggregator: any;
-    constructor(opts: any);
-    static defaultDimensions(): ({
-        key: string;
-        accessor: string;
-        pickingInfo: string;
-        getBins: {
-            triggers: {
-                value: {
-                    prop: string;
-                    updateTrigger: string;
-                };
-                weight: {
-                    prop: string;
-                    updateTrigger: string;
-                };
-                aggregation: {
-                    prop: string;
-                };
-                filterData: {
-                    prop: string;
-                    updateTrigger: string;
-                };
-            };
-        };
-        getDomain: {
-            triggers: {
-                lowerPercentile: {
-                    prop: string;
-                };
-                upperPercentile: {
-                    prop: string;
-                };
-                scaleType: {
-                    prop: string;
-                };
-            };
-        };
-        getScaleFunc: {
-            triggers: {
-                domain: {
-                    prop: string;
-                };
-                range: {
-                    prop: string;
-                };
-            };
-            onSet: {
-                props: string;
-            };
-        };
-        nullValue: number[];
-    } | {
-        key: string;
-        accessor: string;
-        pickingInfo: string;
-        getBins: {
-            triggers: {
-                value: {
-                    prop: string;
-                    updateTrigger: string;
-                };
-                weight: {
-                    prop: string;
-                    updateTrigger: string;
-                };
-                aggregation: {
-                    prop: string;
-                };
-                filterData: {
-                    prop: string;
-                    updateTrigger: string;
-                };
-            };
-        };
-        getDomain: {
-            triggers: {
-                lowerPercentile: {
-                    prop: string;
-                };
-                upperPercentile: {
-                    prop: string;
-                };
-                scaleType: {
-                    prop: string;
-                };
-            };
-        };
-        getScaleFunc: {
-            triggers: {
-                domain: {
-                    prop: string;
-                };
-                range: {
-                    prop: string;
-                };
-            };
-            onSet: {
-                props: string;
-            };
-        };
-        nullValue: number;
-    })[];
-    updateState(opts: any, aggregationParams: any): {
-        layerData: {
-            data?: any[] | undefined;
-        };
-        dimensions: Record<string, any>;
-    };
-    setState(updateObject: any): void;
-    setDimensionState(key: any, updateObject: any): void;
-    normalizeResult(result?: {
-        hexagons?: any;
-        layerData?: any;
-    }): {
-        hexagons?: any;
-        layerData?: any;
-    } | {
-        hexagons?: any;
-        layerData?: any;
-        data: any;
-    };
-    getAggregatedData(props: any, aggregationParams: any): void;
-    updateGetValueFuncs(oldProps: any, props: any, changeFlags: any): void;
-    needsReProjectPoints(oldProps: any, props: any, changeFlags: any): any;
-    addDimension(dimensions: any): void;
-    _addDimension(dimensions?: never[]): void;
-    getDimensionUpdaters({ key, accessor, pickingInfo, getBins, getDomain, getScaleFunc, nullValue }: {
-        key: any;
-        accessor: any;
-        pickingInfo: any;
-        getBins: any;
-        getDomain: any;
-        getScaleFunc: any;
-        nullValue: any;
-    }): {
-        key: any;
-        accessor: any;
-        pickingInfo: any;
-        getBins: any;
-        getDomain: any;
-        getScaleFunc: any;
-        attributeAccessor: (cell: any) => any;
-    };
-    needUpdateDimensionStep(dimensionStep: any, oldProps: any, props: any, changeFlags: any): boolean;
-    getDimensionChanges(oldProps: any, props: any, changeFlags: any): Function[] | null;
-    getUpdateTriggers(props: any): {};
-    getSortedBins(props: any): void;
-    getDimensionSortedBins(props: any, dimensionUpdater: any): void;
-    getDimensionValueDomain(props: any, dimensionUpdater: any): void;
-    getDimensionScale(props: any, dimensionUpdater: any): void;
-    getSubLayerDimensionAttribute(key: any, nullValue: any): (cell: any) => any;
-    getSubLayerAccessors(props: any): {};
-    getPickingInfo({ info }: {
-        info: any;
-    }): any;
-    getAccessor(dimensionKey: any): any;
-}
-//# sourceMappingURL=cpu-aggregator.d.ts.map

package/dist/utils/cpu-aggregator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cpu-aggregator.d.ts","sourceRoot":"","sources":["../../src/utils/cpu-aggregator.ts"],"names":[],"mappings":"AA4HA,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC,KAAK,EAAE;QACL,SAAS,EAAE;YACT,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;SACd,CAAC;QACF,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KACjC,CAkBC;IACF,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAM;IACtC,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAM;IAE5C,YAAY,MAAC;IACb,cAAc,MAAC;gBAEH,IAAI,KAAA;IAMhB,MAAM,CAAC,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIxB,WAAW,CAAC,IAAI,KAAA,EAAE,iBAAiB,KAAA;;;;;;IAqBnC,QAAQ,CAAC,YAAY,KAAA;IAKrB,iBAAiB,CAAC,GAAG,KAAA,EAAE,YAAY,KAAA;IASnC,eAAe,CAAC,MAAM,GAAE;QAAC,QAAQ,CAAC,MAAC;QAAC,SAAS,CAAC,MAAA;KAAM;;;;;;;;IAWpD,iBAAiB,CAAC,KAAK,KAAA,EAAE,iBAAiB,KAAA;IAa1C,mBAAmB,CAAC,QAAQ,KAAA,EAAE,KAAK,KAAA,EAAE,WAAW,KAAA;IA0BhD,oBAAoB,CAAC,QAAQ,KAAA,EAAE,KAAK,KAAA,EAAE,WAAW,KAAA;IAUjD,YAAY,CAAC,UAAU,KAAA;IAIvB,aAAa,CAAC,UAAU,UAAK;IAa7B,oBAAoB,CAAC,EAAC,GAAG,EAAE,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAC;;;;;;;;KAAA;;;;;;;;;IAY9F,uBAAuB,CAAC,aAAa,KAAA,EAAE,QAAQ,KAAA,EAAE,KAAK,KAAA,EAAE,WAAW,KAAA;IAkCnE,mBAAmB,CAAC,QAAQ,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,GAAG,QAAQ,EAAE,GAAG,IAAI;IA8BnF,iBAAiB,CAAC,KAAK,KAAA;IAmCvB,aAAa,CAAC,KAAK,KAAA;IAMnB,sBAAsB,CAAC,KAAK,KAAA,EAAE,gBAAgB,KAAA;IAY9C,uBAAuB,CAAC,KAAK,KAAA,EAAE,gBAAgB,KAAA;IAc/C,iBAAiB,CAAC,KAAK,KAAA,EAAE,gBAAgB,KAAA;IAiBzC,6BAA6B,CAAC,GAAG,KAAA,EAAE,SAAS,KAAA;IAmB5C,oBAAoB,CAAC,KAAK,KAAA;IAU1B,cAAc,CAAC,EAAC,IAAI,EAAC;;KAAA;IA8BrB,WAAW,CAAC,YAAY,KAAA;CAMzB"}

package/dist/utils/cpu-aggregator.js

@@ -1,421 +0,0 @@
-// Copyright (c) 2015 - 2018 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 BinSorter from "./bin-sorter.js";
-import { getScaleFunctionByScaleType } from "./scale-utils.js";
-import { getValueFunc, wrapGetValueFunc } from "./aggregation-operation-utils.js";
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-function noop() { }
-const dimensionSteps = ['getBins', 'getDomain', 'getScaleFunc'];
-const defaultDimensions = [
-    {
-        key: 'fillColor',
-        accessor: 'getFillColor',
-        pickingInfo: 'colorValue',
-        getBins: {
-            triggers: {
-                value: {
-                    prop: 'getColorValue',
-                    updateTrigger: 'getColorValue'
-                },
-                weight: {
-                    prop: 'getColorWeight',
-                    updateTrigger: 'getColorWeight'
-                },
-                aggregation: {
-                    prop: 'colorAggregation'
-                },
-                filterData: {
-                    prop: '_filterData',
-                    updateTrigger: '_filterData'
-                }
-            }
-        },
-        getDomain: {
-            triggers: {
-                lowerPercentile: {
-                    prop: 'lowerPercentile'
-                },
-                upperPercentile: {
-                    prop: 'upperPercentile'
-                },
-                scaleType: {
-                    prop: 'colorScaleType'
-                }
-            }
-        },
-        getScaleFunc: {
-            triggers: {
-                domain: { prop: 'colorDomain' },
-                range: { prop: 'colorRange' }
-            },
-            onSet: {
-                props: 'onSetColorDomain'
-            }
-        },
-        nullValue: [0, 0, 0, 0]
-    },
-    {
-        key: 'elevation',
-        accessor: 'getElevation',
-        pickingInfo: 'elevationValue',
-        getBins: {
-            triggers: {
-                value: {
-                    prop: 'getElevationValue',
-                    updateTrigger: 'getElevationValue'
-                },
-                weight: {
-                    prop: 'getElevationWeight',
-                    updateTrigger: 'getElevationWeight'
-                },
-                aggregation: {
-                    prop: 'elevationAggregation'
-                },
-                filterData: {
-                    prop: '_filterData',
-                    updateTrigger: '_filterData'
-                }
-            }
-        },
-        getDomain: {
-            triggers: {
-                lowerPercentile: {
-                    prop: 'elevationLowerPercentile'
-                },
-                upperPercentile: {
-                    prop: 'elevationUpperPercentile'
-                },
-                scaleType: {
-                    prop: 'elevationScaleType'
-                }
-            }
-        },
-        getScaleFunc: {
-            triggers: {
-                domain: { prop: 'elevationDomain' },
-                range: { prop: 'elevationRange' }
-            },
-            onSet: {
-                props: 'onSetElevationDomain'
-            }
-        },
-        nullValue: -1
-    }
-];
-const defaultGetCellSize = props => props.cellSize;
-export default class CPUAggregator {
-    constructor(opts) {
-        this.state = {
-            layerData: {
-                data: undefined
-            },
-            dimensions: {
-            // color: {
-            //   getValue: null,
-            //   domain: null,
-            //   sortedBins: null,
-            //   scaleFunc: noop
-            // },
-            // elevation: {
-            //   getValue: null,
-            //   domain: null,
-            //   sortedBins: null,
-            //   scaleFunc: noop
-            // }
-            }
-        };
-        this.changeFlags = {};
-        this.dimensionUpdaters = {};
-        this._getCellSize = opts.getCellSize || defaultGetCellSize;
-        this._getAggregator = opts.getAggregator;
-        this._addDimension(opts.dimensions || defaultDimensions);
-    }
-    static defaultDimensions() {
-        return defaultDimensions;
-    }
-    updateState(opts, aggregationParams) {
-        const { oldProps, props, changeFlags } = opts;
-        this.updateGetValueFuncs(oldProps, props, changeFlags);
-        const reprojectNeeded = this.needsReProjectPoints(oldProps, props, changeFlags);
-        let aggregationDirty = false;
-        if (changeFlags.dataChanged || reprojectNeeded) {
-            // project data into bin and aggregate wegiths per bin
-            this.getAggregatedData(props, aggregationParams);
-            aggregationDirty = true;
-        }
-        else {
-            const dimensionChanges = this.getDimensionChanges(oldProps, props, changeFlags) || [];
-            // this here is layer
-            dimensionChanges.forEach(f => typeof f === 'function' && f());
-            aggregationDirty = true;
-        }
-        this.setState({ aggregationDirty });
-        return this.state;
-    }
-    // Update private state
-    setState(updateObject) {
-        this.state = { ...this.state, ...updateObject };
-    }
-    // Update private state.dimensions
-    setDimensionState(key, updateObject) {
-        this.setState({
-            dimensions: {
-                ...this.state.dimensions,
-                [key]: { ...this.state.dimensions[key], ...updateObject }
-            }
-        });
-    }
-    normalizeResult(result = {}) {
-        // support previous hexagonAggregator API
-        if (result.hexagons) {
-            return { data: result.hexagons, ...result };
-        }
-        else if (result.layerData) {
-            return { data: result.layerData, ...result };
-        }
-        return result;
-    }
-    getAggregatedData(props, aggregationParams) {
-        const aggregator = this._getAggregator(props);
-        const result = aggregator(props, aggregationParams);
-        this.setState({
-            layerData: this.normalizeResult(result)
-        });
-        this.changeFlags = {
-            layerData: true
-        };
-        this.getSortedBins(props);
-    }
-    updateGetValueFuncs(oldProps, props, changeFlags) {
-        for (const key in this.dimensionUpdaters) {
-            const { value, weight, aggregation } = this.dimensionUpdaters[key].getBins.triggers;
-            let getValue = props[value.prop];
-            const getValueChanged = this.needUpdateDimensionStep(this.dimensionUpdaters[key].getBins, oldProps, props, changeFlags);
-            if (getValueChanged) {
-                if (getValue) {
-                    getValue = wrapGetValueFunc(getValue, { data: props.data });
-                }
-                else {
-                    // If `getValue` is not provided from props, build it with aggregation and weight.
-                    getValue = getValueFunc(props[aggregation.prop], props[weight.prop], { data: props.data });
-                }
-            }
-            if (getValue) {
-                this.setDimensionState(key, { getValue });
-            }
-        }
-    }
-    needsReProjectPoints(oldProps, props, changeFlags) {
-        return (this._getCellSize(oldProps) !== this._getCellSize(props) ||
-            this._getAggregator(oldProps) !== this._getAggregator(props) ||
-            (changeFlags.updateTriggersChanged &&
-                (changeFlags.updateTriggersChanged.all || changeFlags.updateTriggersChanged.getPosition)));
-    }
-    // Adds dimensions
-    addDimension(dimensions) {
-        this._addDimension(dimensions);
-    }
-    _addDimension(dimensions = []) {
-        dimensions.forEach(dimension => {
-            const { key } = dimension;
-            this.dimensionUpdaters[key] = this.getDimensionUpdaters(dimension);
-            this.state.dimensions[key] = {
-                getValue: null,
-                domain: null,
-                sortedBins: null,
-                scaleFunc: noop
-            };
-        });
-    }
-    getDimensionUpdaters({ key, accessor, pickingInfo, getBins, getDomain, getScaleFunc, nullValue }) {
-        return {
-            key,
-            accessor,
-            pickingInfo,
-            getBins: { updater: this.getDimensionSortedBins.bind(this), ...getBins },
-            getDomain: { updater: this.getDimensionValueDomain.bind(this), ...getDomain },
-            getScaleFunc: { updater: this.getDimensionScale.bind(this), ...getScaleFunc },
-            attributeAccessor: this.getSubLayerDimensionAttribute(key, nullValue)
-        };
-    }
-    needUpdateDimensionStep(dimensionStep, oldProps, props, changeFlags) {
-        // whether need to update current dimension step
-        // dimension step is the value, domain, scaleFunction of each dimension
-        // each step is an object with properties links to layer prop and whether the prop is
-        // controlled by updateTriggers
-        // getBins: {
-        //   value: {
-        //     prop: 'getElevationValue',
-        //     updateTrigger: 'getElevationValue'
-        //   },
-        //   weight: {
-        //     prop: 'getElevationWeight',
-        //     updateTrigger: 'getElevationWeight'
-        //   },
-        //   aggregation: {
-        //     prop: 'elevationAggregation'
-        //   }
-        // }
-        return Object.values(dimensionStep.triggers).some((item) => {
-            if (item.updateTrigger) {
-                // check based on updateTriggers change first
-                // if data has changed, always update value
-                return (changeFlags.dataChanged ||
-                    (changeFlags.updateTriggersChanged &&
-                        (changeFlags.updateTriggersChanged.all ||
-                            changeFlags.updateTriggersChanged[item.updateTrigger])));
-            }
-            // fallback to direct comparison
-            return oldProps[item.prop] !== props[item.prop];
-        });
-    }
-    getDimensionChanges(oldProps, props, changeFlags) {
-        // const {dimensionUpdaters} = this.state;
-        const updaters = [];
-        // get dimension to be updated
-        for (const key in this.dimensionUpdaters) {
-            // return the first triggered updater for each dimension
-            const needUpdate = dimensionSteps.find(step => this.needUpdateDimensionStep(this.dimensionUpdaters[key][step], oldProps, props, changeFlags));
-            if (needUpdate) {
-                updaters.push(this.dimensionUpdaters[key][needUpdate].updater.bind(this, props, this.dimensionUpdaters[key]));
-            }
-        }
-        return updaters.length ? updaters : null;
-    }
-    getUpdateTriggers(props) {
-        const _updateTriggers = props.updateTriggers || {};
-        const updateTriggers = {};
-        for (const key in this.dimensionUpdaters) {
-            const { accessor } = this.dimensionUpdaters[key];
-            // fold dimension triggers into each accessor
-            updateTriggers[accessor] = {};
-            dimensionSteps.forEach(step => {
-                Object.values(this.dimensionUpdaters[key][step].triggers).forEach(({ prop, updateTrigger }) => {
-                    if (updateTrigger) {
-                        // if prop is based on updateTrigger e.g. getColorValue, getColorWeight
-                        // and updateTriggers is passed in from layer prop
-                        // fold the updateTriggers into accessor
-                        const fromProp = _updateTriggers[updateTrigger];
-                        if (typeof fromProp === 'object' && !Array.isArray(fromProp)) {
-                            // if updateTrigger is an object spread it
-                            Object.assign(updateTriggers[accessor], fromProp);
-                        }
-                        else if (fromProp !== undefined) {
-                            updateTriggers[accessor][prop] = fromProp;
-                        }
-                    }
-                    else {
-                        // if prop is not based on updateTrigger
-                        updateTriggers[accessor][prop] = props[prop];
-                    }
-                });
-            });
-        }
-        return updateTriggers;
-    }
-    getSortedBins(props) {
-        for (const key in this.dimensionUpdaters) {
-            this.getDimensionSortedBins(props, this.dimensionUpdaters[key]);
-        }
-    }
-    getDimensionSortedBins(props, dimensionUpdater) {
-        const { key } = dimensionUpdater;
-        const { getValue } = this.state.dimensions[key];
-        const sortedBins = new BinSorter(this.state.layerData.data || [], {
-            getValue,
-            filterData: props._filterData
-        });
-        this.setDimensionState(key, { sortedBins });
-        this.getDimensionValueDomain(props, dimensionUpdater);
-    }
-    getDimensionValueDomain(props, dimensionUpdater) {
-        const { getDomain, key } = dimensionUpdater;
-        const { triggers: { lowerPercentile, upperPercentile, scaleType } } = getDomain;
-        const valueDomain = this.state.dimensions[key].sortedBins.getValueDomainByScale(props[scaleType.prop], [props[lowerPercentile.prop], props[upperPercentile.prop]]);
-        this.setDimensionState(key, { valueDomain });
-        this.getDimensionScale(props, dimensionUpdater);
-    }
-    getDimensionScale(props, dimensionUpdater) {
-        const { key, getScaleFunc, getDomain } = dimensionUpdater;
-        const { domain, range } = getScaleFunc.triggers;
-        const { scaleType } = getDomain.triggers;
-        const { onSet } = getScaleFunc;
-        const dimensionRange = props[range.prop];
-        const dimensionDomain = props[domain.prop] || this.state.dimensions[key].valueDomain;
-        const getScaleFunction = getScaleFunctionByScaleType(scaleType && props[scaleType.prop]);
-        const scaleFunc = getScaleFunction(dimensionDomain, dimensionRange);
-        if (typeof onSet === 'object' && typeof props[onSet.props] === 'function') {
-            props[onSet.props](scaleFunc.domain());
-        }
-        this.setDimensionState(key, { scaleFunc });
-    }
-    getSubLayerDimensionAttribute(key, nullValue) {
-        return cell => {
-            const { sortedBins, scaleFunc } = this.state.dimensions[key];
-            const bin = sortedBins.binMap[cell.index];
-            if (bin && bin.counts === 0) {
-                // no points left in bin after filtering
-                return nullValue;
-            }
-            const cv = bin && bin.value;
-            const domain = scaleFunc.domain();
-            const isValueInDomain = cv >= domain[0] && cv <= domain[domain.length - 1];
-            // if cell value is outside domain, set alpha to 0
-            return isValueInDomain ? scaleFunc(cv) : nullValue;
-        };
-    }
-    getSubLayerAccessors(props) {
-        const accessors = {};
-        for (const key in this.dimensionUpdaters) {
-            const { accessor } = this.dimensionUpdaters[key];
-            accessors[accessor] = this.getSubLayerDimensionAttribute(props, key);
-        }
-        return accessors;
-    }
-    getPickingInfo({ info }) {
-        const isPicked = info.picked && info.index > -1;
-        let object = null;
-        if (isPicked) {
-            // const {sortedColorBins, sortedElevationBins} = this.state;
-            // @ts-expect-error
-            const cell = this.state.layerData.data[info.index];
-            const binInfo = {};
-            for (const key in this.dimensionUpdaters) {
-                const { pickingInfo } = this.dimensionUpdaters[key];
-                const { sortedBins } = this.state.dimensions[key];
-                const value = sortedBins.binMap[cell.index] && sortedBins.binMap[cell.index].value;
-                binInfo[pickingInfo] = value;
-            }
-            object = Object.assign(binInfo, cell, {
-                points: cell.filteredPoints || cell.points
-            });
-        }
-        // override object with picked cell
-        info.picked = Boolean(object);
-        info.object = object;
-        return info;
-    }
-    getAccessor(dimensionKey) {
-        if (!this.dimensionUpdaters.hasOwnProperty(dimensionKey)) {
-            return noop;
-        }
-        return this.dimensionUpdaters[dimensionKey].attributeAccessor;
-    }
-}

package/dist/utils/gpu-grid-aggregation/aggregate-all-fs.glsl.d.ts

@@ -1,3 +0,0 @@
-declare const _default: "#version 300 es\n#define SHADER_NAME gpu-aggregation-all-fs\n\nprecision highp float;\n\nin vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform bool combineMaxMin;\nout vec4 fragColor;\nvoid main(void) {\n  vec4 textureColor = texture(uSampler, vec2(vTextureCoord.s, vTextureCoord.t));\n  if (textureColor.a == 0.) {\n    discard;\n  }\n  fragColor.rgb = textureColor.rgb;\n  // if combineMinMax is true, use Alpha channel for first weights min value.\n  fragColor.a = combineMaxMin ? textureColor.r : textureColor.a;\n}\n";
-export default _default;
-//# sourceMappingURL=aggregate-all-fs.glsl.d.ts.map

package/dist/utils/gpu-grid-aggregation/aggregate-all-fs.glsl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"aggregate-all-fs.glsl.d.ts","sourceRoot":"","sources":["../../../src/utils/gpu-grid-aggregation/aggregate-all-fs.glsl.ts"],"names":[],"mappings":";AAoBA,wBAmBE"}