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

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

@@ -1,93 +1,112 @@
-declare class GridLayer extends CompositeLayer<any> {
-    constructor(...propObjects: Partial<any>[]);
-    canUseGPUAggregation(props: any): boolean;
-}
-declare namespace GridLayer {
-    export const layerName: string;
-    export { defaultProps };
-}
-export default GridLayer;
-import { CompositeLayer } from '@deck.gl/core/typed';
-declare const defaultProps: {
-    gpuAggregation: boolean;
-    colorDomain: null;
-    colorRange: number[][];
-    getColorValue: {
-        type: string;
-        value: null;
-    };
-    getColorWeight: {
-        type: string;
-        value: number;
-    };
-    colorAggregation: string;
-    lowerPercentile: {
-        type: string;
-        min: number;
-        max: number;
-        value: number;
-    };
-    upperPercentile: {
-        type: string;
-        min: number;
-        max: number;
-        value: number;
-    };
-    colorScaleType: string;
-    onSetColorDomain: () => void;
-    elevationDomain: null;
-    elevationRange: number[];
-    getElevationValue: {
-        type: string;
-        value: null;
-    };
-    getElevationWeight: {
-        type: string;
-        value: number;
-    };
-    elevationAggregation: string;
-    elevationLowerPercentile: {
-        type: string;
-        min: number;
-        max: number;
-        value: number;
-    };
-    elevationUpperPercentile: {
-        type: string;
-        min: number;
-        max: number;
-        value: number;
-    };
-    elevationScale: {
-        type: string;
-        min: number;
-        value: number;
-    };
-    elevationScaleType: string;
-    onSetElevationDomain: () => void;
-    gridAggregator: typeof import("../cpu-grid-layer/grid-aggregator").pointToDensityGridDataCPU;
-    cellSize: {
-        type: string;
-        min: number;
-        max: number;
-        value: number;
-    };
-    coverage: {
-        type: string;
-        min: number;
-        max: number;
-        value: number;
-    };
-    getPosition: {
-        type: string;
-        value: (x: any) => any;
+import { CompositeLayer, CompositeLayerProps, Layer, UpdateParameters } from '@deck.gl/core/typed';
+import { _GPUGridLayerProps } from '../gpu-grid-layer/gpu-grid-layer';
+import { _CPUGridLayerProps } from '../cpu-grid-layer/cpu-grid-layer';
+/** All properties supported by GridLayer. */
+export declare type GridLayerProps<DataT = any> = _GridLayerProps<DataT> & CompositeLayerProps<DataT>;
+/** Properties added by GridLayer. */
+declare type _GridLayerProps<DataT = any> = _CPUGridLayerProps<DataT> & _GPUGridLayerProps<DataT> & {
+    /**
+     * Whether the aggregation should be performed in high-precision 64-bit mode.
+     * @default false
+     */
+    fp64?: boolean;
+    /**
+     * When set to true, aggregation is performed on GPU, provided other conditions are met.
+     * @default false
+     */
+    gpuAggregation?: boolean;
+};
+export default class GridLayer<DataT = any, ExtraPropsT = {}> extends CompositeLayer<ExtraPropsT & Required<_GridLayerProps<DataT>>> {
+    static layerName: string;
+    static defaultProps: {
+        gpuAggregation: boolean;
+        colorDomain: null;
+        colorRange: number[][];
+        getColorValue: {
+            type: string;
+            value: null;
+        };
+        getColorWeight: {
+            type: string;
+            value: number;
+        };
+        colorAggregation: string;
+        lowerPercentile: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        upperPercentile: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        colorScaleType: string;
+        onSetColorDomain: () => void;
+        elevationDomain: null;
+        elevationRange: number[];
+        getElevationValue: {
+            type: string;
+            value: null;
+        };
+        getElevationWeight: {
+            type: string;
+            value: number;
+        };
+        elevationAggregation: string;
+        elevationLowerPercentile: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        elevationUpperPercentile: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        elevationScale: {
+            type: string;
+            min: number;
+            value: number;
+        };
+        elevationScaleType: string;
+        onSetElevationDomain: () => void;
+        gridAggregator: typeof import("../cpu-grid-layer/grid-aggregator").pointToDensityGridDataCPU;
+        cellSize: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        coverage: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        getPosition: {
+            type: string;
+            value: (x: any) => any;
+        };
+        extruded: boolean;
+        material: boolean;
+        _filterData: {
+            type: string;
+            value: null;
+            optional: boolean;
+        };
     };
-    extruded: boolean;
-    material: boolean;
-    _filterData: {
-        type: string;
-        value: null;
-        optional: boolean;
+    state: CompositeLayer['state'] & {
+        useGPUAggregation: boolean;
     };
-};
+    initializeState(): void;
+    updateState({ props }: UpdateParameters<this>): void;
+    renderLayers(): Layer;
+    canUseGPUAggregation(props: GridLayer['props']): boolean;
+}
+export {};
 //# sourceMappingURL=grid-layer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"grid-layer.d.ts","sourceRoot":"","sources":["../../src/grid-layer/grid-layer.js"],"names":[],"mappings":"AAWA;IAS6B,4CACf;IAuBZ,0CA6BC;CACF;;;;;;;AArED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIE"}
+{"version":3,"file":"grid-layer.d.ts","sourceRoot":"","sources":["../../src/grid-layer/grid-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAE,mBAAmB,EAAE,KAAK,EAAE,gBAAgB,EAAC,MAAM,eAAe,CAAC;AAE3F,OAAqB,EAAC,kBAAkB,EAAC,MAAM,kCAAkC,CAAC;AAClF,OAAqB,EAAC,kBAAkB,EAAC,MAAM,kCAAkC,CAAC;AAQlF,6CAA6C;AAC7C,oBAAY,cAAc,CAAC,KAAK,GAAG,GAAG,IAAI,eAAe,CAAC,KAAK,CAAC,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;AAE9F,qCAAqC;AACrC,aAAK,eAAe,CAAC,KAAK,GAAG,GAAG,IAAI,kBAAkB,CAAC,KAAK,CAAC,GAC3D,kBAAkB,CAAC,KAAK,CAAC,GAAG;IAC1B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEJ,MAAM,CAAC,OAAO,OAAO,SAAS,CAAC,KAAK,GAAG,GAAG,EAAE,WAAW,GAAG,EAAE,CAAE,SAAQ,cAAc,CAClF,WAAW,GAAG,QAAQ,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAC/C;IACC,MAAM,CAAC,SAAS,SAAe;IAC/B,MAAM,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAgB;IAEnC,KAAK,EAAG,cAAc,CAAC,OAAO,CAAC,GAAG;QAChC,iBAAiB,EAAE,OAAO,CAAC;KAC5B,CAAC;IAEF,eAAe;IAMf,WAAW,CAAC,EAAC,KAAK,EAAC,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAM3C,YAAY,IAAI,KAAK;IAoBrB,oBAAoB,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC;CA8B/C"}

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

@@ -0,0 +1,60 @@
+import { CompositeLayer } from '@deck.gl/core';
+import GPUGridAggregator from '../utils/gpu-grid-aggregation/gpu-grid-aggregator';
+import GPUGridLayer from '../gpu-grid-layer/gpu-grid-layer';
+import CPUGridLayer from '../cpu-grid-layer/cpu-grid-layer';
+const defaultProps = {
+    ...GPUGridLayer.defaultProps,
+    ...CPUGridLayer.defaultProps,
+    gpuAggregation: false
+};
+export default class GridLayer extends CompositeLayer {
+    initializeState() {
+        this.state = {
+            useGPUAggregation: true
+        };
+    }
+    updateState({ props }) {
+        this.setState({
+            useGPUAggregation: this.canUseGPUAggregation(props)
+        });
+    }
+    renderLayers() {
+        const { data, updateTriggers } = this.props;
+        const id = this.state.useGPUAggregation ? 'GPU' : 'CPU';
+        const LayerType = this.state.useGPUAggregation
+            ? this.getSubLayerClass('GPU', GPUGridLayer)
+            : this.getSubLayerClass('CPU', CPUGridLayer);
+        return new LayerType(this.props, this.getSubLayerProps({
+            id,
+            updateTriggers
+        }), {
+            data
+        });
+    }
+    // Private methods
+    canUseGPUAggregation(props) {
+        const { gpuAggregation, lowerPercentile, upperPercentile, getColorValue, getElevationValue, colorScaleType } = props;
+        if (!gpuAggregation) {
+            // cpu aggregation is requested
+            return false;
+        }
+        if (!GPUGridAggregator.isSupported(this.context.gl)) {
+            return false;
+        }
+        if (lowerPercentile !== 0 || upperPercentile !== 100) {
+            // percentile calculations requires sorting not supported on GPU
+            return false;
+        }
+        if (getColorValue !== null || getElevationValue !== null) {
+            // accessor for custom color or elevation calculation is specified
+            return false;
+        }
+        if (colorScaleType === 'quantile' || colorScaleType === 'ordinal') {
+            // quantile and ordinal scales are not supported on GPU
+            return false;
+        }
+        return true;
+    }
+}
+GridLayer.layerName = 'GridLayer';
+GridLayer.defaultProps = defaultProps;

package/typed/heatmap-layer/heatmap-layer-utils.d.ts

@@ -1,9 +1,9 @@
-export function getBounds(points: any): number[];
-export function boundsContain(currentBounds: any, targetBounds: any): boolean;
-export function packVertices(points: any, dimensions?: number): Float32Array;
-export function scaleToAspectRatio(boundingBox: any, width: any, height: any): number[];
-export function getTextureCoordinates(point: any, bounds: any): number[];
-export function getTextureParams({ gl, floatTargetSupport }: {
+export declare function getBounds(points: number[][]): number[];
+export declare function boundsContain(currentBounds: number[], targetBounds: number[]): boolean;
+export declare function packVertices(points: number[][], dimensions?: number): Float32Array;
+export declare function scaleToAspectRatio(boundingBox: number[], width: number, height: number): number[];
+export declare function getTextureCoordinates(point: number[], bounds: number[]): number[];
+export declare function getTextureParams({ gl, floatTargetSupport }: {
     gl: any;
     floatTargetSupport: any;
 }): {

package/typed/heatmap-layer/heatmap-layer-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heatmap-layer-utils.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/heatmap-layer-utils.js"],"names":[],"mappings":"AAGA,iDAWC;AAGD,8EAUC;AAKD,6EAQC;AAGD,wFA6BC;AAGD,yEAGC;AAGD;;;;;;EAWC"}
+{"version":3,"file":"heatmap-layer-utils.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/heatmap-layer-utils.ts"],"names":[],"mappings":"AAGA,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,CAWtD;AAGD,wBAAgB,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAUtF;AAKD,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,GAAE,MAAU,GAAG,YAAY,CAQrF;AAGD,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CA6BjG;AAGD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,YAGtE;AAGD,wBAAgB,gBAAgB,CAAC,EAAC,EAAE,EAAE,kBAAkB,EAAC;;;CAAA;;;EAWxD"}

package/typed/heatmap-layer/heatmap-layer-utils.js

@@ -0,0 +1,78 @@
+import GL from '@luma.gl/constants';
+import { isWebGL2 } from '@luma.gl/core';
+export function getBounds(points) {
+    // Now build bounding box in world space (aligned to world coordiante system)
+    const x = points.map(p => p[0]);
+    const y = points.map(p => p[1]);
+    const xMin = Math.min.apply(null, x);
+    const xMax = Math.max.apply(null, x);
+    const yMin = Math.min.apply(null, y);
+    const yMax = Math.max.apply(null, y);
+    return [xMin, yMin, xMax, yMax];
+}
+// true if currentBounds contains targetBounds, false otherwise
+export function boundsContain(currentBounds, targetBounds) {
+    if (targetBounds[0] >= currentBounds[0] &&
+        targetBounds[2] <= currentBounds[2] &&
+        targetBounds[1] >= currentBounds[1] &&
+        targetBounds[3] <= currentBounds[3]) {
+        return true;
+    }
+    return false;
+}
+const scratchArray = new Float32Array(12);
+// For given rectangle bounds generates two triangles vertices that coverit completely
+export function packVertices(points, dimensions = 2) {
+    let index = 0;
+    for (const point of points) {
+        for (let i = 0; i < dimensions; i++) {
+            scratchArray[index++] = point[i] || 0;
+        }
+    }
+    return scratchArray;
+}
+// Expands boundingBox:[xMin, yMin, xMax, yMax] to match aspect ratio of given width and height
+export function scaleToAspectRatio(boundingBox, width, height) {
+    const [xMin, yMin, xMax, yMax] = boundingBox;
+    const currentWidth = xMax - xMin;
+    const currentHeight = yMax - yMin;
+    let newWidth = currentWidth;
+    let newHeight = currentHeight;
+    if (currentWidth / currentHeight < width / height) {
+        // expand bounding box width
+        newWidth = (width / height) * currentHeight;
+    }
+    else {
+        newHeight = (height / width) * currentWidth;
+    }
+    if (newWidth < width) {
+        newWidth = width;
+        newHeight = height;
+    }
+    const xCenter = (xMax + xMin) / 2;
+    const yCenter = (yMax + yMin) / 2;
+    return [
+        xCenter - newWidth / 2,
+        yCenter - newHeight / 2,
+        xCenter + newWidth / 2,
+        yCenter + newHeight / 2
+    ];
+}
+// Get texture coordiante of point inside a bounding box
+export function getTextureCoordinates(point, bounds) {
+    const [xMin, yMin, xMax, yMax] = bounds;
+    return [(point[0] - xMin) / (xMax - xMin), (point[1] - yMin) / (yMax - yMin)];
+}
+// Returns format and type for creating texture objects
+export function getTextureParams({ gl, floatTargetSupport }) {
+    return floatTargetSupport
+        ? {
+            // format:  should be RGBA32F on WebGL2 (float textures), RGBA in WebGL1 for float or non float textures
+            format: isWebGL2(gl) ? GL.RGBA32F : GL.RGBA,
+            type: GL.FLOAT
+        }
+        : {
+            format: GL.RGBA,
+            type: GL.UNSIGNED_BYTE
+        };
+}

package/typed/heatmap-layer/heatmap-layer.d.ts

@@ -1,96 +1,161 @@
-declare class HeatmapLayer extends AggregationLayer {
-    _updateHeatmapState(opts: any): void;
-    _getChangeFlags(opts: any): {
-        dataChanged: boolean;
-        viewportChanged: any;
-        viewportZoomChanged: boolean;
+import { Buffer, Texture2D } from '@luma.gl/core';
+import { Accessor, AccessorFunction, AttributeManager, ChangeFlags, Color, Layer, LayerContext, LayersList, Position, UpdateParameters } from '@deck.gl/core/typed';
+import AggregationLayer, { AggregationLayerProps } from '../aggregation-layer';
+export declare type HeatmapLayerProps<DataT> = _HeatmapLayerProps<DataT> & AggregationLayerProps<DataT>;
+declare type _HeatmapLayerProps<DataT = any> = {
+    /**
+     * Radius of the circle in pixels, to which the weight of an object is distributed.
+     *
+     * @default 30
+     */
+    radiusPixels?: number;
+    /**
+     * Specified as an array of colors [color1, color2, ...].
+     *
+     * @default `6-class YlOrRd` - [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6)
+     */
+    colorRange?: Color[];
+    /**
+     * Value that is multiplied with the total weight at a pixel to obtain the final weight.
+     *
+     * @default 1
+     */
+    intensity?: number;
+    /**
+     * Ratio of the fading weight to the max weight, between `0` and `1`.
+     *
+     * For example, `0.1` affects all pixels with weight under 10% of the max.
+     *
+     * Ignored when `colorDomain` is specified.
+     * @default 0.05
+     */
+    threshold?: number;
+    /**
+     * Controls how weight values are mapped to the `colorRange`, as an array of two numbers [`minValue`, `maxValue`].
+     *
+     * @default null
+     */
+    colorDomain?: [number, number] | null;
+    /**
+     * Defines the type of aggregation operation
+     *
+     * V valid values are 'SUM', 'MEAN'.
+     *
+     * @default 'SUM'
+     */
+    aggregation?: 'SUM' | 'MEAN';
+    /**
+     * Specifies the size of weight texture.
+     * @default 2048
+     */
+    weightsTextureSize?: number;
+    /**
+     * Interval in milliseconds during which changes to the viewport don't trigger aggregation.
+     *
+     * @default 500
+     */
+    debounceTimeout?: number;
+    /**
+     * Method called to retrieve the position of each object.
+     *
+     * @default d => d.position
+     */
+    getPosition?: AccessorFunction<DataT, Position>;
+    /**
+     * The weight of each object.
+     *
+     * @default 1
+     */
+    getWeight?: Accessor<DataT, number>;
+};
+export default class HeatmapLayer<DataT = any, ExtraPropsT = {}> extends AggregationLayer<ExtraPropsT & Required<_HeatmapLayerProps<DataT>>> {
+    static layerName: string;
+    static defaultProps: {
+        getPosition: {
+            type: string;
+            value: (x: any) => any;
+        };
+        getWeight: {
+            type: string;
+            value: number;
+        };
+        intensity: {
+            type: string;
+            min: number;
+            value: number;
+        };
+        radiusPixels: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        colorRange: number[][];
+        threshold: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        colorDomain: {
+            type: string;
+            value: null;
+            optional: boolean;
+        };
+        aggregation: string;
+        weightsTextureSize: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        debounceTimeout: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+    };
+    state: AggregationLayer['state'] & {
+        supported: boolean;
+        colorDomain?: number[];
+        isWeightMapDirty?: boolean;
+        weightsTexture?: Texture2D;
+        zoom?: number;
+        worldBounds?: number[];
+        normalizedCommonBounds?: number[];
+        updateTimer?: any;
+        triPositionBuffer?: Buffer;
+        triTexCoordBuffer?: Buffer;
+    };
+    initializeState(): void;
+    shouldUpdateState({ changeFlags }: UpdateParameters<this>): boolean;
+    updateState(opts: UpdateParameters<this>): void;
+    _updateHeatmapState(opts: UpdateParameters<this>): void;
+    renderLayers(): LayersList | Layer;
+    finalizeState(context: LayerContext): void;
+    _getAttributeManager(): AttributeManager;
+    _getChangeFlags(opts: UpdateParameters<this>): Partial<ChangeFlags> & {
+        boundsChanged?: boolean | undefined;
+        viewportZoomChanged?: boolean | undefined;
     };
     _createTextures(): void;
     _setupAttributes(): void;
     _setupTextureParams(): void;
+    getShaders(type: any): any;
     _createWeightsTransform(shaders?: {}): void;
     _setupResources(): void;
+    updateShaders(shaderOptions: any): void;
     _updateMaxWeightValue(): void;
-    _updateBounds(forceUpdate?: boolean): boolean;
+    _updateBounds(forceUpdate?: any): boolean;
     _updateTextureRenderingBounds(): void;
     _updateColorTexture(opts: any): void;
     _updateWeightmap(): void;
     _debouncedUpdateWeightmap(fromTimer?: boolean): void;
-    _worldToCommonBounds(worldBounds: any, opts?: {}): number[];
+    _worldToCommonBounds(worldBounds: any, opts?: {
+        useLayerCoordinateSystem?: boolean;
+    }): number[];
     _commonToWorldBounds(commonBounds: any): number[];
 }
-declare namespace HeatmapLayer {
-    export const layerName: string;
-    export { defaultProps };
-}
-export default HeatmapLayer;
-import AggregationLayer from "../aggregation-layer";
-declare namespace defaultProps {
-    export namespace getPosition {
-        const type: string;
-        function value(x: any): any;
-    }
-    export namespace getWeight {
-        const type_1: string;
-        export { type_1 as type };
-        const value_1: number;
-        export { value_1 as value };
-    }
-    export namespace intensity {
-        const type_2: string;
-        export { type_2 as type };
-        export const min: number;
-        const value_2: number;
-        export { value_2 as value };
-    }
-    export namespace radiusPixels {
-        const type_3: string;
-        export { type_3 as type };
-        const min_1: number;
-        export { min_1 as min };
-        export const max: number;
-        const value_3: number;
-        export { value_3 as value };
-    }
-    export { defaultColorRange as colorRange };
-    export namespace threshold {
-        const type_4: string;
-        export { type_4 as type };
-        const min_2: number;
-        export { min_2 as min };
-        const max_1: number;
-        export { max_1 as max };
-        const value_4: number;
-        export { value_4 as value };
-    }
-    export namespace colorDomain {
-        const type_5: string;
-        export { type_5 as type };
-        const value_5: null;
-        export { value_5 as value };
-        export const optional: boolean;
-    }
-    export const aggregation: string;
-    export namespace weightsTextureSize {
-        const type_6: string;
-        export { type_6 as type };
-        const min_3: number;
-        export { min_3 as min };
-        const max_2: number;
-        export { max_2 as max };
-        const value_6: number;
-        export { value_6 as value };
-    }
-    export namespace debounceTimeout {
-        const type_7: string;
-        export { type_7 as type };
-        const min_4: number;
-        export { min_4 as min };
-        const max_3: number;
-        export { max_3 as max };
-        const value_7: number;
-        export { value_7 as value };
-    }
-}
-import { defaultColorRange } from "../utils/color-utils";
+export {};
 //# sourceMappingURL=heatmap-layer.d.ts.map

package/typed/heatmap-layer/heatmap-layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heatmap-layer.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/heatmap-layer.js"],"names":[],"mappings":"AAuFA;IA6BE,qCA4BC;IA+ED;;;;MAiBC;IAED,wBAcC;IAED,yBAOC;IAED,4BAcC;IAgBD,4CAcC;IAED,wBAkCC;IAQD,8BAUC;IAGD,8CAgDC;IAED,sCAaC;IAED,qCAmBC;IAED,yBAmDC;IAED,qDAiBC;IAKD,4DAsCC;IAID,kDAOC;CACF;;;;;;;;;;QAzgBwC,4BAAe"}
+{"version":3,"file":"heatmap-layer.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/heatmap-layer.ts"],"names":[],"mappings":"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"}