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

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

@@ -1,10 +1,27 @@
-declare class TriangleLayer extends Layer<any> {
-    constructor(...propObjects: Partial<any>[]);
-    _getModel(gl: any): any;
+import { Model, Texture2D } from '@luma.gl/core';
+import { Layer, LayerContext } from '@deck.gl/core/typed';
+declare type _TriangleLayerProps = {
+    colorDomain: number[];
+    aggregationMode: string;
+    threshold: number;
+    intensity: number;
+    vertexCount: number;
+    colorTexture: Texture2D;
+    maxTexture: Texture2D;
+    texture: Texture2D;
+};
+export default class TriangleLayer extends Layer<_TriangleLayerProps> {
+    static layerName: string;
+    getShaders(): {
+        vs: string;
+        fs: string;
+        modules: import("@deck.gl/core")._ShaderModule<any>[];
+    };
+    initializeState({ gl }: LayerContext): void;
+    _getModel(gl: WebGLRenderingContext): Model;
+    draw({ uniforms }: {
+        uniforms: any;
+    }): void;
 }
-declare namespace TriangleLayer {
-    const layerName: string;
-}
-export default TriangleLayer;
-import { Layer } from '@deck.gl/core/typed';
+export {};
 //# sourceMappingURL=triangle-layer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"triangle-layer.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/triangle-layer.js"],"names":[],"mappings":"AA0BA;IAhBoB,4CAEN;IA+BZ,wBAWC;CAqBF"}
+{"version":3,"file":"triangle-layer.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/triangle-layer.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAC,KAAK,EAAY,SAAS,EAAC,MAAM,eAAe,CAAC;AACzD,OAAO,EAAC,KAAK,EAAE,YAAY,EAAY,MAAM,eAAe,CAAC;AAI7D,aAAK,mBAAmB,GAAG;IACzB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,SAAS,CAAC;IACxB,UAAU,EAAE,SAAS,CAAC;IACtB,OAAO,EAAE,SAAS,CAAC;CACpB,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,KAAK,CAAC,mBAAmB,CAAC;IACnE,MAAM,CAAC,SAAS,SAAmB;IAEnC,UAAU;;;;;IAIV,eAAe,CAAC,EAAC,EAAE,EAAC,EAAE,YAAY,GAAG,IAAI;IAWzC,SAAS,CAAC,EAAE,EAAE,qBAAqB,GAAG,KAAK;IAa3C,IAAI,CAAC,EAAC,QAAQ,EAAC;;KAAA,GAAG,IAAI;CAmBvB"}

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

@@ -0,0 +1,67 @@
+// 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.
+import GL from '@luma.gl/constants';
+import { Model, Geometry } from '@luma.gl/core';
+import { Layer, project32 } from '@deck.gl/core';
+import vs from './triangle-layer-vertex.glsl';
+import fs from './triangle-layer-fragment.glsl';
+export default class TriangleLayer extends Layer {
+    getShaders() {
+        return { vs, fs, modules: [project32] };
+    }
+    initializeState({ gl }) {
+        const attributeManager = this.getAttributeManager();
+        attributeManager.add({
+            positions: { size: 3, noAlloc: true },
+            texCoords: { size: 2, noAlloc: true }
+        });
+        this.setState({
+            model: this._getModel(gl)
+        });
+    }
+    _getModel(gl) {
+        const { vertexCount } = this.props;
+        return new Model(gl, {
+            ...this.getShaders(),
+            id: this.props.id,
+            geometry: new Geometry({
+                drawMode: GL.TRIANGLE_FAN,
+                vertexCount
+            })
+        });
+    }
+    draw({ uniforms }) {
+        const { model } = this.state;
+        const { texture, maxTexture, colorTexture, intensity, threshold, aggregationMode, colorDomain } = this.props;
+        model
+            .setUniforms({
+            ...uniforms,
+            texture,
+            maxTexture,
+            colorTexture,
+            intensity,
+            threshold,
+            aggregationMode,
+            colorDomain
+        })
+            .draw();
+    }
+}
+TriangleLayer.layerName = 'TriangleLayer';

package/typed/heatmap-layer/weights-fs.glsl.d.ts

@@ -1,3 +1,3 @@
-declare var _default: "varying vec4 weightsTexture;\n// Epanechnikov function, keeping for reference\n// float epanechnikovKDE(float u) {\n//   return 0.75 * (1.0 - u * u);\n// }\nfloat gaussianKDE(float u){\n  return pow(2.71828, -u*u/0.05555)/(1.77245385*0.166666);\n}\nvoid main()\n{\n  float dist = length(gl_PointCoord - vec2(0.5, 0.5));\n  if (dist > 0.5) {\n    discard;\n  }\n  gl_FragColor = weightsTexture * gaussianKDE(2. * dist);\n  DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n";
+declare const _default: "varying vec4 weightsTexture;\n// Epanechnikov function, keeping for reference\n// float epanechnikovKDE(float u) {\n//   return 0.75 * (1.0 - u * u);\n// }\nfloat gaussianKDE(float u){\n  return pow(2.71828, -u*u/0.05555)/(1.77245385*0.166666);\n}\nvoid main()\n{\n  float dist = length(gl_PointCoord - vec2(0.5, 0.5));\n  if (dist > 0.5) {\n    discard;\n  }\n  gl_FragColor = weightsTexture * gaussianKDE(2. * dist);\n  DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n";
 export default _default;
 //# sourceMappingURL=weights-fs.glsl.d.ts.map

package/typed/heatmap-layer/weights-fs.glsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"weights-fs.glsl.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/weights-fs.glsl.js"],"names":[],"mappings":""}
+{"version":3,"file":"weights-fs.glsl.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/weights-fs.glsl.ts"],"names":[],"mappings":";AAAA,wBAkBE"}

package/typed/heatmap-layer/weights-fs.glsl.js

@@ -0,0 +1,19 @@
+export default `\
+varying vec4 weightsTexture;
+// Epanechnikov function, keeping for reference
+// float epanechnikovKDE(float u) {
+//   return 0.75 * (1.0 - u * u);
+// }
+float gaussianKDE(float u){
+  return pow(2.71828, -u*u/0.05555)/(1.77245385*0.166666);
+}
+void main()
+{
+  float dist = length(gl_PointCoord - vec2(0.5, 0.5));
+  if (dist > 0.5) {
+    discard;
+  }
+  gl_FragColor = weightsTexture * gaussianKDE(2. * dist);
+  DECKGL_FILTER_COLOR(gl_FragColor, geometry);
+}
+`;

package/typed/heatmap-layer/weights-vs.glsl.d.ts

@@ -1,3 +1,3 @@
-declare var _default: "attribute vec3 positions;\nattribute vec3 positions64Low;\nattribute float weights;\nvarying vec4 weightsTexture;\nuniform float radiusPixels;\nuniform float textureWidth;\nuniform vec4 commonBounds;\nuniform float weightsScale;\nvoid main()\n{\n  weightsTexture = vec4(weights * weightsScale, 0., 0., 1.);\n\n  float radiusTexels  = project_pixel_size(radiusPixels) * textureWidth / (commonBounds.z - commonBounds.x);\n  gl_PointSize = radiusTexels * 2.;\n\n  vec3 commonPosition = project_position(positions, positions64Low);\n\n  // map xy from commonBounds to [-1, 1]\n  gl_Position.xy = (commonPosition.xy - commonBounds.xy) / (commonBounds.zw - commonBounds.xy) ;\n  gl_Position.xy = (gl_Position.xy * 2.) - (1.);\n}\n";
+declare const _default: "attribute vec3 positions;\nattribute vec3 positions64Low;\nattribute float weights;\nvarying vec4 weightsTexture;\nuniform float radiusPixels;\nuniform float textureWidth;\nuniform vec4 commonBounds;\nuniform float weightsScale;\nvoid main()\n{\n  weightsTexture = vec4(weights * weightsScale, 0., 0., 1.);\n\n  float radiusTexels  = project_pixel_size(radiusPixels) * textureWidth / (commonBounds.z - commonBounds.x);\n  gl_PointSize = radiusTexels * 2.;\n\n  vec3 commonPosition = project_position(positions, positions64Low);\n\n  // map xy from commonBounds to [-1, 1]\n  gl_Position.xy = (commonPosition.xy - commonBounds.xy) / (commonBounds.zw - commonBounds.xy) ;\n  gl_Position.xy = (gl_Position.xy * 2.) - (1.);\n}\n";
 export default _default;
 //# sourceMappingURL=weights-vs.glsl.d.ts.map

package/typed/heatmap-layer/weights-vs.glsl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"weights-vs.glsl.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/weights-vs.glsl.js"],"names":[],"mappings":""}
+{"version":3,"file":"weights-vs.glsl.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/weights-vs.glsl.ts"],"names":[],"mappings":";AAAA,wBAsBE"}

package/typed/heatmap-layer/weights-vs.glsl.js

@@ -0,0 +1,23 @@
+export default `\
+attribute vec3 positions;
+attribute vec3 positions64Low;
+attribute float weights;
+varying vec4 weightsTexture;
+uniform float radiusPixels;
+uniform float textureWidth;
+uniform vec4 commonBounds;
+uniform float weightsScale;
+void main()
+{
+  weightsTexture = vec4(weights * weightsScale, 0., 0., 1.);
+
+  float radiusTexels  = project_pixel_size(radiusPixels) * textureWidth / (commonBounds.z - commonBounds.x);
+  gl_PointSize = radiusTexels * 2.;
+
+  vec3 commonPosition = project_position(positions, positions64Low);
+
+  // map xy from commonBounds to [-1, 1]
+  gl_Position.xy = (commonPosition.xy - commonBounds.xy) / (commonBounds.zw - commonBounds.xy) ;
+  gl_Position.xy = (gl_Position.xy * 2.) - (1.);
+}
+`;

package/typed/hexagon-layer/hexagon-aggregator.js

@@ -0,0 +1,112 @@
+// 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 { hexbin } from 'd3-hexbin';
+import { createIterable, log } from '@deck.gl/core';
+/**
+ * Use d3-hexbin to performs hexagonal binning from geo points to hexagons
+ * @param {Iterable} data - array of points
+ * @param {Number} radius - hexagon radius in meter
+ * @param {function} getPosition - get points lon lat
+ * @param {Object} viewport - current viewport object
+
+ * @return {Object} - hexagons and countRange
+ */
+export function pointToHexbin(props, aggregationParams) {
+    const { data, radius } = props;
+    const { viewport, attributes } = aggregationParams;
+    // get hexagon radius in mercator world unit
+    const centerLngLat = data.length ? getPointsCenter(data, aggregationParams) : null;
+    const radiusCommon = getRadiusInCommon(radius, viewport, centerLngLat);
+    // add world space coordinates to points
+    const screenPoints = [];
+    const { iterable, objectInfo } = createIterable(data);
+    const positions = attributes.positions.value;
+    const { size } = attributes.positions.getAccessor();
+    for (const object of iterable) {
+        objectInfo.index++;
+        const posIndex = objectInfo.index * size;
+        const position = [positions[posIndex], positions[posIndex + 1]];
+        const arrayIsFinite = Number.isFinite(position[0]) && Number.isFinite(position[1]);
+        if (arrayIsFinite) {
+            screenPoints.push({
+                screenCoord: viewport.projectFlat(position),
+                source: object,
+                index: objectInfo.index
+            });
+        }
+        else {
+            log.warn('HexagonLayer: invalid position')();
+        }
+    }
+    const newHexbin = hexbin()
+        .radius(radiusCommon)
+        .x(d => d.screenCoord[0])
+        .y(d => d.screenCoord[1]);
+    const hexagonBins = newHexbin(screenPoints);
+    return {
+        hexagons: hexagonBins.map((hex, index) => ({
+            position: viewport.unprojectFlat([hex.x, hex.y]),
+            points: hex,
+            index
+        })),
+        radiusCommon
+    };
+}
+/**
+ * Get the bounding box of all data points
+ */
+export function getPointsCenter(data, aggregationParams) {
+    const { attributes } = aggregationParams;
+    const positions = attributes.positions.value;
+    const { size } = attributes.positions.getAccessor();
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let i;
+    for (i = 0; i < size * data.length; i += size) {
+        const x = positions[i];
+        const y = positions[i + 1];
+        const arrayIsFinite = Number.isFinite(x) && Number.isFinite(y);
+        if (arrayIsFinite) {
+            minX = Math.min(x, minX);
+            maxX = Math.max(x, maxX);
+            minY = Math.min(y, minY);
+            maxY = Math.max(y, maxY);
+        }
+    }
+    // return center
+    return [minX, minY, maxX, maxY].every(Number.isFinite)
+        ? [(minX + maxX) / 2, (minY + maxY) / 2]
+        : null;
+}
+/**
+ * Get radius in mercator world space coordinates from meter
+ * @param {Number} radius - in meter
+ * @param {Object} viewport - current viewport object
+ * @param {Array<Number>} center - data center
+
+ * @return {Number} radius in mercator world spcae coordinates
+ */
+export function getRadiusInCommon(radius, viewport, center) {
+    const { unitsPerMeter } = viewport.getDistanceScales(center);
+    // x, y distance should be the same
+    return radius * unitsPerMeter[0];
+}

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

@@ -1,130 +1,237 @@
-declare class HexagonLayer extends AggregationLayer {
+import { Accessor, AccessorFunction, Color, Position, UpdateParameters } from '@deck.gl/core/typed';
+import { ColumnLayer, _MaterialProps as MaterialProps } from '@deck.gl/layers/typed';
+import { pointToHexbin } from './hexagon-aggregator';
+import CPUAggregator from '../utils/cpu-aggregator';
+import AggregationLayer, { AggregationLayerProps } from '../aggregation-layer';
+import { AggregateAccessor } from '../types';
+declare function nop(): void;
+/** All properties supported by by HexagonLayer. */
+export declare type HexagonLayerProps<DataT = any> = _HexagonLayerProps<DataT> & AggregationLayerProps<DataT>;
+/** Properties added by HexagonLayer. */
+declare type _HexagonLayerProps<DataT = any> = {
+    /**
+     * Radius of hexagon bin in meters. The hexagons are pointy-topped (rather than flat-topped).
+     * @default 1000
+     */
+    radius?: number;
+    /**
+     * Function to aggregate data into hexagonal bins.
+     * @default d3-hexbin
+     */
+    hexagonAggregator?: () => any;
+    /**
+     * Color scale input domain.
+     * @default [min(colorWeight), max(colorWeight)]
+     */
+    colorDomain?: 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[];
+    /**
+     * Hexagon radius multiplier, clamped between 0 - 1.
+     * @default 1
+     */
+    coverage?: number;
+    /**
+     * Elevation scale input domain. The elevation scale is a linear scale that maps number of counts to elevation.
+     * @default [0, max(elevationWeight)]
+     */
+    elevationDomain?: number[];
+    /**
+     * Elevation scale output range.
+     * @default [0, 1000]
+     */
+    elevationRange?: number[];
+    /**
+     * Hexagon elevation multiplier.
+     * @default 1
+     */
+    elevationScale?: number;
+    /**
+     * Whether to enable cell elevation. If set to false, all cell will be flat.
+     * @default false
+     */
+    extruded?: boolean;
+    /**
+     * Filter bins and re-calculate color by `upperPercentile`.
+     * Hexagons with color value larger than the `upperPercentile` will be hidden.
+     * @default 100
+     */
+    upperPercentile?: number;
+    /**
+     * Filter bins and re-calculate color by `lowerPercentile`.
+     * Hexagons with color value smaller than the `lowerPercentile` will be hidden.
+     * @default 0
+     */
+    lowerPercentile?: number;
+    /**
+     * Filter bins and re-calculate elevation by `elevationUpperPercentile`.
+     * Hexagons with elevation value larger than the `elevationUpperPercentile` will be hidden.
+     * @default 100
+     */
+    elevationUpperPercentile?: number;
+    /**
+     * Filter bins and re-calculate elevation by `elevationLowerPercentile`.
+     * Hexagons with elevation value larger than the `elevationLowerPercentile` will be hidden.
+     * @default 0
+     */
+    elevationLowerPercentile?: number;
+    /**
+     * Scaling function used to determine the color of the grid cell, default value is 'quantize'.
+     * Supported Values are 'quantize', 'quantile' and 'ordinal'.
+     * @default 'quantize'
+     */
+    colorScaleType?: 'quantize' | 'quantile' | 'ordinal';
+    /**
+     * This is an object that contains material props
+     * for [lighting effect](/docs/api-reference/core/lighting-effect.md) applied on extruded polygons.
+     * @default true
+     */
+    material?: MaterialProps | boolean;
+    /**
+     * Defines the operation used to aggregate all data object weights to calculate a cell's color value.
+     * @default 'SUM'
+     */
+    colorAggregation?: 'SUM' | 'MEAN' | 'MIN' | 'MAX';
+    /**
+     * Defines the operation used to aggregate all data object weights to calculate a cell's elevation value.
+     * @default 'SUM'
+     */
+    elevationAggregation?: 'SUM' | 'MEAN' | 'MIN' | 'MAX';
+    /**
+     * Method called to retrieve the position of each object.
+     * @default object => object.position
+     */
+    getPosition?: AccessorFunction<DataT, Position>;
+    /**
+     * The weight of a data object used to calculate the color value for a bin.
+     * @default 1
+     */
+    getColorWeight?: Accessor<DataT, number>;
+    /**
+     * After data objects are aggregated into bins, this accessor is called on each cell to get the value that its color is based on.
+     * @default null
+     */
+    getColorValue?: AggregateAccessor<DataT> | null;
+    /**
+     * The weight of a data object used to calculate the elevation value for a bin.
+     * @default 1
+     */
+    getElevationWeight?: Accessor<DataT, number>;
+    /**
+     * After data objects are aggregated into bins, this accessor is called on each cell to get the value that its elevation is based on.
+     * @default null
+     */
+    getElevationValue?: AggregateAccessor<DataT> | null;
+    /**
+     * This callback will be called when cell color domain has been calculated.
+     * @default () => {}
+     */
+    onSetColorDomain?: (minMax: [number, number]) => void;
+    /**
+     * This callback will be called when cell elevation domain has been calculated.
+     * @default () => {}
+     */
+    onSetElevationDomain?: (minMax: [number, number]) => void;
+};
+export default class HexagonLayer<ExtraPropsT = {}> extends AggregationLayer<ExtraPropsT & Required<_HexagonLayerProps>> {
+    static layerName: string;
+    static defaultProps: {
+        colorDomain: null;
+        colorRange: number[][];
+        getColorValue: {
+            type: string;
+            value: null;
+        };
+        getColorWeight: {
+            type: string;
+            value: number;
+        };
+        colorAggregation: string;
+        lowerPercentile: {
+            type: string;
+            value: number;
+            min: number;
+            max: number;
+        };
+        upperPercentile: {
+            type: string;
+            value: number;
+            min: number;
+            max: number;
+        };
+        colorScaleType: string;
+        onSetColorDomain: typeof nop;
+        elevationDomain: null;
+        elevationRange: number[];
+        getElevationValue: {
+            type: string;
+            value: null;
+        };
+        getElevationWeight: {
+            type: string;
+            value: number;
+        };
+        elevationAggregation: string;
+        elevationLowerPercentile: {
+            type: string;
+            value: number;
+            min: number;
+            max: number;
+        };
+        elevationUpperPercentile: {
+            type: string;
+            value: number;
+            min: number;
+            max: number;
+        };
+        elevationScale: {
+            type: string;
+            min: number;
+            value: number;
+        };
+        elevationScaleType: string;
+        onSetElevationDomain: typeof nop;
+        radius: {
+            type: string;
+            value: number;
+            min: number;
+        };
+        coverage: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        extruded: boolean;
+        hexagonAggregator: typeof pointToHexbin;
+        getPosition: {
+            type: string;
+            value: (x: any) => any;
+        };
+        material: boolean;
+        _filterData: {
+            type: string;
+            value: null;
+            optional: boolean;
+        };
+    };
+    state: AggregationLayer['state'] & {
+        cpuAggregator: CPUAggregator;
+        aggregatorState: any;
+    };
+    initializeState(): void;
+    updateState(opts: UpdateParameters<this>): void;
     convertLatLngToMeterOffset(hexagonVertices: any): number[][] | null;
+    getPickingInfo({ info }: {
+        info: any;
+    }): any;
     _onGetSublayerColor(cell: any): any;
     _onGetSublayerElevation(cell: any): any;
-    _getSublayerUpdateTriggers(): any;
-}
-declare namespace HexagonLayer {
-    export const layerName: string;
-    export { defaultProps };
+    _getSublayerUpdateTriggers(): {};
+    renderLayers(): ColumnLayer<any, {}>;
 }
-export default HexagonLayer;
-import AggregationLayer from "../aggregation-layer";
-declare namespace defaultProps {
-    export const colorDomain: null;
-    export { defaultColorRange as colorRange };
-    export namespace getColorValue {
-        const type: string;
-        const value: null;
-    }
-    export namespace getColorWeight {
-        const type_1: string;
-        export { type_1 as type };
-        const value_1: number;
-        export { value_1 as value };
-    }
-    export const colorAggregation: string;
-    export namespace lowerPercentile {
-        const type_2: string;
-        export { type_2 as type };
-        const value_2: number;
-        export { value_2 as value };
-        export const min: number;
-        export const max: number;
-    }
-    export namespace upperPercentile {
-        const type_3: string;
-        export { type_3 as type };
-        const value_3: number;
-        export { value_3 as value };
-        const min_1: number;
-        export { min_1 as min };
-        const max_1: number;
-        export { max_1 as max };
-    }
-    export const colorScaleType: string;
-    export { nop as onSetColorDomain };
-    export const elevationDomain: null;
-    export const elevationRange: number[];
-    export namespace getElevationValue {
-        const type_4: string;
-        export { type_4 as type };
-        const value_4: null;
-        export { value_4 as value };
-    }
-    export namespace getElevationWeight {
-        const type_5: string;
-        export { type_5 as type };
-        const value_5: number;
-        export { value_5 as value };
-    }
-    export const elevationAggregation: string;
-    export namespace elevationLowerPercentile {
-        const type_6: string;
-        export { type_6 as type };
-        const value_6: number;
-        export { value_6 as value };
-        const min_2: number;
-        export { min_2 as min };
-        const max_2: number;
-        export { max_2 as max };
-    }
-    export namespace elevationUpperPercentile {
-        const type_7: string;
-        export { type_7 as type };
-        const value_7: number;
-        export { value_7 as value };
-        const min_3: number;
-        export { min_3 as min };
-        const max_3: number;
-        export { max_3 as max };
-    }
-    export namespace elevationScale {
-        const type_8: string;
-        export { type_8 as type };
-        const min_4: number;
-        export { min_4 as min };
-        const value_8: number;
-        export { value_8 as value };
-    }
-    export const elevationScaleType: string;
-    export { nop as onSetElevationDomain };
-    export namespace radius {
-        const type_9: string;
-        export { type_9 as type };
-        const value_9: number;
-        export { value_9 as value };
-        const min_5: number;
-        export { min_5 as min };
-    }
-    export namespace coverage {
-        const type_10: string;
-        export { type_10 as type };
-        const min_6: number;
-        export { min_6 as min };
-        const max_4: number;
-        export { max_4 as max };
-        const value_10: number;
-        export { value_10 as value };
-    }
-    export const extruded: boolean;
-    export { pointToHexbin as hexagonAggregator };
-    export namespace getPosition {
-        const type_11: string;
-        export { type_11 as type };
-        export function value_11(x: any): any;
-        export { value_11 as value };
-    }
-    export const material: boolean;
-    export namespace _filterData {
-        const type_12: string;
-        export { type_12 as type };
-        const value_12: null;
-        export { value_12 as value };
-        export const optional: boolean;
-    }
-}
-import { defaultColorRange } from "../utils/color-utils";
-declare function nop(): void;
-import { pointToHexbin } from "./hexagon-aggregator";
+export {};
 //# sourceMappingURL=hexagon-layer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hexagon-layer.d.ts","sourceRoot":"","sources":["../../src/hexagon-layer/hexagon-layer.js"],"names":[],"mappings":"AAqEA;IA4CE,oEA2BC;IAOD,oCAEC;IAGD,wCAEC;IAED,kCAEC;CA0CF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA3IwC,sCAAe;;;;;;;;;;;;;AA9BxD,6BAAiB"}
+{"version":3,"file":"hexagon-layer.d.ts","sourceRoot":"","sources":["../../src/hexagon-layer/hexagon-layer.ts"],"names":[],"mappings":"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"}