@deck.gl/aggregation-layers 8.8.23 → 8.8.25

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

@@ -0,0 +1,114 @@
+import { log, COORDINATE_SYSTEM } from '@deck.gl/core';
+const R_EARTH = 6378000;
+function toFinite(n) {
+    return Number.isFinite(n) ? n : 0;
+}
+// Parse input data to build positions, wights and bounding box.
+/* eslint-disable max-statements */
+export function getBoundingBox(attributes, vertexCount) {
+    // TODO - value might not exist (e.g. attribute transition)
+    const positions = attributes.positions.value;
+    let yMin = Infinity;
+    let yMax = -Infinity;
+    let xMin = Infinity;
+    let xMax = -Infinity;
+    let y;
+    let x;
+    for (let i = 0; i < vertexCount; i++) {
+        x = positions[i * 3];
+        y = positions[i * 3 + 1];
+        yMin = y < yMin ? y : yMin;
+        yMax = y > yMax ? y : yMax;
+        xMin = x < xMin ? x : xMin;
+        xMax = x > xMax ? x : xMax;
+    }
+    const boundingBox = {
+        xMin: toFinite(xMin),
+        xMax: toFinite(xMax),
+        yMin: toFinite(yMin),
+        yMax: toFinite(yMax)
+    };
+    return boundingBox;
+}
+/* eslint-enable max-statements */
+// Returns XY translation for positions to peform aggregation in +ve sapce
+function getTranslation(boundingBox, gridOffset, coordinateSystem, viewport) {
+    const { width, height } = viewport;
+    // Origin to define grid
+    // DEFAULT coordinate system is treated as LNGLAT
+    const worldOrigin = coordinateSystem === COORDINATE_SYSTEM.CARTESIAN ? [-width / 2, -height / 2] : [-180, -90];
+    // Other coordinate systems not supported/verified yet
+    log.assert(coordinateSystem === COORDINATE_SYSTEM.CARTESIAN ||
+        coordinateSystem === COORDINATE_SYSTEM.LNGLAT ||
+        coordinateSystem === COORDINATE_SYSTEM.DEFAULT);
+    const { xMin, yMin } = boundingBox;
+    return [
+        // Align origin to match grid cell boundaries in CPU and GPU aggregations
+        -1 * (alignToCell(xMin - worldOrigin[0], gridOffset.xOffset) + worldOrigin[0]),
+        -1 * (alignToCell(yMin - worldOrigin[1], gridOffset.yOffset) + worldOrigin[1])
+    ];
+}
+// Aligns `inValue` to given `cellSize`
+export function alignToCell(inValue, cellSize) {
+    const sign = inValue < 0 ? -1 : 1;
+    let value = sign < 0 ? Math.abs(inValue) + cellSize : Math.abs(inValue);
+    value = Math.floor(value / cellSize) * cellSize;
+    return value * sign;
+}
+/**
+ * Based on geometric center of sample points, calculate cellSize in lng/lat (degree) space
+ * @param {object} boundingBox - {xMin, yMin, xMax, yMax} contains bounding box of data
+ * @param {number} cellSize - grid cell size in meters
+ * @param {boolean, optional} converToDegrees - when true offsets are converted from meters to lng/lat (degree) space
+ * @returns {xOffset, yOffset} - cellSize size
+ */
+export function getGridOffset(boundingBox, cellSize, convertToMeters = true) {
+    if (!convertToMeters) {
+        return { xOffset: cellSize, yOffset: cellSize };
+    }
+    const { yMin, yMax } = boundingBox;
+    const centerLat = (yMin + yMax) / 2;
+    return calculateGridLatLonOffset(cellSize, centerLat);
+}
+export function getGridParams(boundingBox, cellSize, viewport, coordinateSystem) {
+    const gridOffset = getGridOffset(boundingBox, cellSize, coordinateSystem !== COORDINATE_SYSTEM.CARTESIAN);
+    const translation = getTranslation(boundingBox, gridOffset, coordinateSystem, viewport);
+    const { xMin, yMin, xMax, yMax } = boundingBox;
+    const width = xMax - xMin + gridOffset.xOffset;
+    const height = yMax - yMin + gridOffset.yOffset;
+    const numCol = Math.ceil(width / gridOffset.xOffset);
+    const numRow = Math.ceil(height / gridOffset.yOffset);
+    return { gridOffset, translation, width, height, numCol, numRow };
+}
+/**
+ * calculate grid layer cell size in lat lon based on world unit size
+ * and current latitude
+ * @param {number} cellSize
+ * @param {number} latitude
+ * @returns {object} - lat delta and lon delta
+ */
+function calculateGridLatLonOffset(cellSize, latitude) {
+    const yOffset = calculateLatOffset(cellSize);
+    const xOffset = calculateLonOffset(latitude, cellSize);
+    return { yOffset, xOffset };
+}
+/**
+ * with a given x-km change, calculate the increment of latitude
+ * based on stackoverflow http://stackoverflow.com/questions/7477003
+ * @param {number} dy - change in km
+ * @return {number} - increment in latitude
+ */
+function calculateLatOffset(dy) {
+    return (dy / R_EARTH) * (180 / Math.PI);
+}
+/**
+ * with a given x-km change, and current latitude
+ * calculate the increment of longitude
+ * based on stackoverflow http://stackoverflow.com/questions/7477003
+ * @param {number} lat - latitude of current location (based on city)
+ * @param {number} dx - change in km
+ * @return {number} - increment in longitude
+ */
+function calculateLonOffset(lat, dx) {
+    return ((dx / R_EARTH) * (180 / Math.PI)) / Math.cos((lat * Math.PI) / 180);
+}

package/typed/utils/prop-utils.js

@@ -0,0 +1,28 @@
+// 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 function filterProps(props, filterKeys) {
+    const filteredProps = {};
+    for (const key in props) {
+        if (!filterKeys.includes(key)) {
+            filteredProps[key] = props[key];
+        }
+    }
+    return filteredProps;
+}

package/typed/utils/resource-utils.js

@@ -0,0 +1,40 @@
+import GL from '@luma.gl/constants';
+import { Framebuffer, Texture2D, isWebGL2 } from '@luma.gl/core';
+const DEFAULT_PARAMETERS = {
+    [GL.TEXTURE_MAG_FILTER]: GL.NEAREST,
+    [GL.TEXTURE_MIN_FILTER]: GL.NEAREST
+};
+export function getFloatTexture(gl, opts = {}) {
+    const { width = 1, height = 1, data = null, unpackFlipY = true, parameters = DEFAULT_PARAMETERS } = opts;
+    const texture = new Texture2D(gl, {
+        data,
+        format: isWebGL2(gl) ? GL.RGBA32F : GL.RGBA,
+        type: GL.FLOAT,
+        border: 0,
+        mipmaps: false,
+        parameters,
+        dataFormat: GL.RGBA,
+        width,
+        height,
+        unpackFlipY
+    });
+    return texture;
+}
+export function getFramebuffer(gl, opts) {
+    const { id, width = 1, height = 1, texture } = opts;
+    const fb = new Framebuffer(gl, {
+        id,
+        width,
+        height,
+        attachments: {
+            [GL.COLOR_ATTACHMENT0]: texture
+        }
+    });
+    return fb;
+}
+export function getFloatArray(array, size, fillValue = 0) {
+    if (!array || array.length < size) {
+        return new Float32Array(size).fill(fillValue);
+    }
+    return array;
+}

package/typed/utils/scale-utils.js

@@ -0,0 +1,184 @@
+// 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';
+// a scale function wrapper just like d3-scales
+export function getScale(domain, range, scaleFunction) {
+    const scale = scaleFunction;
+    scale.domain = () => domain;
+    scale.range = () => range;
+    return scale;
+}
+// Quantize scale is similar to linear scales,
+// except it uses a discrete rather than continuous range
+// return a quantize scale function
+export function getQuantizeScale(domain, range) {
+    const scaleFunction = value => quantizeScale(domain, range, value);
+    return getScale(domain, range, scaleFunction);
+}
+// return a linear scale function
+export function getLinearScale(domain, range) {
+    const scaleFunction = value => linearScale(domain, range, value);
+    return getScale(domain, range, scaleFunction);
+}
+export function getQuantileScale(domain, range) {
+    // calculate threshold
+    const sortedDomain = domain.sort(ascending);
+    let i = 0;
+    const n = Math.max(1, range.length);
+    const thresholds = new Array(n - 1);
+    while (++i < n) {
+        thresholds[i - 1] = threshold(sortedDomain, i / n);
+    }
+    const scaleFunction = value => thresholdsScale(thresholds, range, value);
+    scaleFunction.thresholds = () => thresholds;
+    return getScale(domain, range, scaleFunction);
+}
+function ascending(a, b) {
+    return a - b;
+}
+function threshold(domain, fraction) {
+    const domainLength = domain.length;
+    if (fraction <= 0 || domainLength < 2) {
+        return domain[0];
+    }
+    if (fraction >= 1) {
+        return domain[domainLength - 1];
+    }
+    const domainFraction = (domainLength - 1) * fraction;
+    const lowIndex = Math.floor(domainFraction);
+    const low = domain[lowIndex];
+    const high = domain[lowIndex + 1];
+    return low + (high - low) * (domainFraction - lowIndex);
+}
+function bisectRight(a, x) {
+    let lo = 0;
+    let hi = a.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >>> 1;
+        if (ascending(a[mid], x) > 0) {
+            hi = mid;
+        }
+        else {
+            lo = mid + 1;
+        }
+    }
+    return lo;
+}
+// return a quantize scale function
+function thresholdsScale(thresholds, range, value) {
+    return range[bisectRight(thresholds, value)];
+}
+// ordinal Scale
+function ordinalScale(domain, domainMap, range, value) {
+    const key = `${value}`;
+    let d = domainMap.get(key);
+    if (d === undefined) {
+        // update the domain
+        d = domain.push(value);
+        domainMap.set(key, d);
+    }
+    return range[(d - 1) % range.length];
+}
+export function getOrdinalScale(domain, range) {
+    const domainMap = new Map();
+    const uniqueDomain = [];
+    for (const d of domain) {
+        const key = `${d}`;
+        if (!domainMap.has(key)) {
+            domainMap.set(key, uniqueDomain.push(d));
+        }
+    }
+    const scaleFunction = value => ordinalScale(uniqueDomain, domainMap, range, value);
+    return getScale(domain, range, scaleFunction);
+}
+// Quantize scale is similar to linear scales,
+// except it uses a discrete rather than continuous range
+export function quantizeScale(domain, range, value) {
+    const domainRange = domain[1] - domain[0];
+    if (domainRange <= 0) {
+        log.warn('quantizeScale: invalid domain, returning range[0]')();
+        return range[0];
+    }
+    const step = domainRange / range.length;
+    const idx = Math.floor((value - domain[0]) / step);
+    const clampIdx = Math.max(Math.min(idx, range.length - 1), 0);
+    return range[clampIdx];
+}
+// Linear scale maps continuous domain to continuous range
+export function linearScale(domain, range, value) {
+    return ((value - domain[0]) / (domain[1] - domain[0])) * (range[1] - range[0]) + range[0];
+}
+// get scale domains
+function notNullOrUndefined(d) {
+    return d !== undefined && d !== null;
+}
+export function unique(values) {
+    const results = [];
+    values.forEach(v => {
+        if (!results.includes(v) && notNullOrUndefined(v)) {
+            results.push(v);
+        }
+    });
+    return results;
+}
+function getTruthyValues(data, valueAccessor) {
+    const values = typeof valueAccessor === 'function' ? data.map(valueAccessor) : data;
+    return values.filter(notNullOrUndefined);
+}
+export function getLinearDomain(data, valueAccessor) {
+    const sorted = getTruthyValues(data, valueAccessor).sort();
+    return sorted.length ? [sorted[0], sorted[sorted.length - 1]] : [0, 0];
+}
+export function getQuantileDomain(data, valueAccessor) {
+    return getTruthyValues(data, valueAccessor);
+}
+export function getOrdinalDomain(data, valueAccessor) {
+    return unique(getTruthyValues(data, valueAccessor));
+}
+export function getScaleDomain(scaleType, data, valueAccessor) {
+    switch (scaleType) {
+        case 'quantize':
+        case 'linear':
+            return getLinearDomain(data, valueAccessor);
+        case 'quantile':
+            return getQuantileDomain(data, valueAccessor);
+        case 'ordinal':
+            return getOrdinalDomain(data, valueAccessor);
+        default:
+            return getLinearDomain(data, valueAccessor);
+    }
+}
+export function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+export function getScaleFunctionByScaleType(scaleType) {
+    switch (scaleType) {
+        case 'quantize':
+            return getQuantizeScale;
+        case 'linear':
+            return getLinearScale;
+        case 'quantile':
+            return getQuantileScale;
+        case 'ordinal':
+            return getOrdinalScale;
+        default:
+            return getQuantizeScale;
+    }
+}

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

@@ -1,116 +0,0 @@
-import { Buffer, Texture2D } from '@luma.gl/core';
-import { Accessor, AccessorFunction, AttributeManager, ChangeFlags, Color, Layer, LayerContext, LayersList, Position, UpdateParameters, DefaultProps } from '@deck.gl/core/typed';
-import AggregationLayer, { AggregationLayerProps } from '../aggregation-layer';
-export declare type HeatmapLayerProps<DataT = any> = _HeatmapLayerProps<DataT> & AggregationLayerProps<DataT>;
-declare type _HeatmapLayerProps<DataT> = {
-    /**
-     * 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: DefaultProps<HeatmapLayerProps<any>>;
-    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?: any): boolean;
-    _updateTextureRenderingBounds(): void;
-    _updateColorTexture(opts: any): void;
-    _updateWeightmap(): void;
-    _debouncedUpdateWeightmap(fromTimer?: boolean): void;
-    _worldToCommonBounds(worldBounds: any, opts?: {
-        useLayerCoordinateSystem?: boolean;
-    }): number[];
-    _commonToWorldBounds(commonBounds: any): number[];
-}
-export {};
-//# sourceMappingURL=heatmap-layer.orig.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"heatmap-layer.orig.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/heatmap-layer.orig.ts"],"names":[],"mappings":"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"}

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

@@ -1,116 +0,0 @@
-import { Buffer, Texture2D } from '@luma.gl/core';
-import { Accessor, AccessorFunction, AttributeManager, ChangeFlags, Color, Layer, LayerContext, LayersList, Position, UpdateParameters, DefaultProps } from '@deck.gl/core/typed';
-import AggregationLayer, { AggregationLayerProps } from '../aggregation-layer';
-export declare type HeatmapLayerProps<DataT = any> = _HeatmapLayerProps<DataT> & AggregationLayerProps<DataT>;
-declare type _HeatmapLayerProps<DataT> = {
-    /**
-     * 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: DefaultProps<HeatmapLayerProps<any>>;
-    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?: any): boolean;
-    _updateTextureRenderingBounds(): void;
-    _updateColorTexture(opts: any): void;
-    _updateWeightmap(): void;
-    _debouncedUpdateWeightmap(fromTimer?: boolean): void;
-    _worldToCommonBounds(worldBounds: any, opts?: {
-        useLayerCoordinateSystem?: boolean;
-    }): number[];
-    _commonToWorldBounds(commonBounds: any): number[];
-}
-export {};
-//# sourceMappingURL=heatmap-layer.patched.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"heatmap-layer.patched.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/heatmap-layer.patched.ts"],"names":[],"mappings":"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"}