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

package/package.json

@@ -2,7 +2,7 @@
   "name": "@deck.gl/aggregation-layers",
   "description": "deck.gl layers that aggregate the input data into alternative representations",
   "license": "MIT",
-  "version": "8.8.0-alpha.5",
+  "version": "8.8.0-alpha.6",
   "publishConfig": {
     "access": "public"
   },
@@ -31,12 +31,12 @@
   },
   "dependencies": {
     "@luma.gl/shadertools": "^8.5.13",
-    "@math.gl/web-mercator": "3.6.0-alpha.5",
+    "@math.gl/web-mercator": "3.6.0-alpha.8",
     "d3-hexbin": "^0.2.1"
   },
   "peerDependencies": {
     "@deck.gl/core": "^8.0.0",
     "@deck.gl/layers": "^8.0.0"
   },
-  "gitHead": "a5e210f62321ab78b7cacbcd0614e0ffcdf6bca7"
+  "gitHead": "6885ccab01c91a7632385f566c9377f8ae387e7c"
 }

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

@@ -80,9 +80,14 @@ export function getTextureCoordinates(point, bounds) {
 
 // Returns format and type for creating texture objects
 export function getTextureParams({gl, floatTargetSupport}) {
-  return {
-    // 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: floatTargetSupport ? GL.FLOAT : GL.UNSIGNED_BYTE
-  };
+  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/src/heatmap-layer/heatmap-layer.js

@@ -72,7 +72,11 @@ const defaultProps = {
 const REQUIRED_FEATURES = [
   FEATURES.BLEND_EQUATION_MINMAX, // max weight calculation
   FEATURES.TEXTURE_FLOAT // weight-map as texture
-  // FEATURES.FLOAT_BLEND, // implictly supported when TEXTURE_FLOAT is supported
+];
+
+const FLOAT_TARGET_FEATURES = [
+  FEATURES.COLOR_ATTACHMENT_RGBA32F, // ability to render to float texture
+  FEATURES.FLOAT_BLEND // ability to blend when rendering to float texture
 ];
 
 const DIMENSIONS = {
@@ -266,7 +270,7 @@ export default class HeatmapLayer extends AggregationLayer {
     const {weightsTextureSize} = this.props;
 
     const textureSize = Math.min(weightsTextureSize, getParameters(gl, gl.MAX_TEXTURE_SIZE));
-    const floatTargetSupport = hasFeatures(gl, FEATURES.COLOR_ATTACHMENT_RGBA32F);
+    const floatTargetSupport = hasFeatures(gl, FLOAT_TARGET_FEATURES);
     const {format, type} = getTextureParams({gl, floatTargetSupport});
     const weightsScale = floatTargetSupport ? 1 : 1 / 255;
     this.setState({textureSize, format, type, weightsScale});

package/typed/aggregation-layer.d.ts

@@ -0,0 +1,33 @@
+declare class AggregationLayer extends CompositeLayer<any> {
+    constructor(...propObjects: Partial<any>[]);
+    getAttributes(): {
+        [id: string]: import("modules/core/src/lib/attribute/shader-attribute").IShaderAttribute;
+    };
+    getModuleSettings(): any;
+    updateShaders(shaders: any): void;
+    /**
+     * Checks if aggregation is dirty
+     * @param {Object} updateOpts - object {props, oldProps, changeFlags}
+     * @param {Object} params - object {dimension, compareAll}
+     * @param {Object} params.dimension - {props, accessors} array of props and/or accessors
+     * @param {Boolean} params.compareAll - when `true` it will include non layer props for comparision
+     * @returns {Boolean} - returns true if dimensions' prop or accessor is changed
+     **/
+    isAggregationDirty(updateOpts: any, params?: {
+        dimension: any;
+        compareAll: boolean;
+    }): boolean;
+    /**
+     * Checks if an attribute is changed
+     * @param {String} name - name of the attribute
+     * @returns {Boolean} - `true` if attribute `name` is changed, `false` otherwise,
+     *                       If `name` is not passed or `undefiend`, `true` if any attribute is changed, `false` otherwise
+     **/
+    isAttributeChanged(name: string): boolean;
+}
+declare namespace AggregationLayer {
+    const layerName: string;
+}
+export default AggregationLayer;
+import { CompositeLayer } from '@deck.gl/core/typed';
+//# sourceMappingURL=aggregation-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aggregation-layer.d.ts","sourceRoot":"","sources":["../src/aggregation-layer.js"],"names":[],"mappings":"AAwBA;IAdoB,4CAEN;IA4CZ;;MAEC;IAED,yBAYC;IAED,kCAEC;IAED;;;;;;;QAOI;IACJ;;;gBAuCC;IAED;;;;;QAKI;IACJ,0CAOC;CAWF"}

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

@@ -0,0 +1,39 @@
+declare class ContourLayer extends GridAggregationLayer {
+    _updateAccessors(opts: any): void;
+    _resetResults(): void;
+    _generateContours(): void;
+    _updateThresholdData(props: any): void;
+}
+declare namespace ContourLayer {
+    export const layerName: string;
+    export { defaultProps };
+}
+export default ContourLayer;
+import GridAggregationLayer from "../grid-aggregation-layer";
+declare namespace defaultProps {
+    namespace cellSize {
+        const type: string;
+        const min: number;
+        const max: number;
+        const value: number;
+    }
+    namespace getPosition {
+        const type_1: string;
+        export { type_1 as type };
+        export function value_1(x: any): any;
+        export { value_1 as value };
+    }
+    namespace getWeight {
+        const type_2: string;
+        export { type_2 as type };
+        const value_2: number;
+        export { value_2 as value };
+    }
+    const gpuAggregation: boolean;
+    const aggregation: string;
+    const contours: {
+        threshold: number;
+    }[];
+    const zOffset: number;
+}
+//# sourceMappingURL=contour-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contour-layer.d.ts","sourceRoot":"","sources":["../../src/contour-layer/contour-layer.js"],"names":[],"mappings":"AA4DA;IAiKE,kCAQC;IAED,sBAKC;IAID,0BAoBC;IAED,uCAaC;CACF;;;;;;;;;;;;;;;;;QA/OwC,qCAAe"}

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

@@ -0,0 +1,19 @@
+export function generateContours({ thresholdData, colors, cellWeights, gridSize, gridOrigin, cellSize }: {
+    thresholdData: any;
+    colors: any;
+    cellWeights: any;
+    gridSize: any;
+    gridOrigin: any;
+    cellSize: any;
+}): {
+    contourSegments: {
+        start: any;
+        end: any;
+        contour: any;
+    }[];
+    contourPolygons: {
+        vertices: any;
+        contour: any;
+    }[];
+};
+//# sourceMappingURL=contour-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"contour-utils.d.ts","sourceRoot":"","sources":["../../src/contour-layer/contour-utils.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;EAiEC"}

package/typed/contour-layer/marching-squares-codes.d.ts

@@ -0,0 +1,32 @@
+export const ISOLINES_CODE_OFFSET_MAP: {
+    0: never[];
+    1: number[][][];
+    2: number[][][];
+    3: number[][][];
+    4: number[][][];
+    5: {
+        0: number[][][];
+        1: number[][][];
+    };
+    6: number[][][];
+    7: number[][][];
+    8: number[][][];
+    9: number[][][];
+    10: {
+        0: number[][][];
+        1: number[][][];
+    };
+    11: number[][][];
+    12: number[][][];
+    13: number[][][];
+    14: number[][][];
+    15: never[];
+};
+export const ISOBANDS_CODE_OFFSET_MAP: {
+    [x: number]: number[][][] | {
+        0: number[][][];
+        1: number[][][];
+        2: number[][][];
+    };
+};
+//# sourceMappingURL=marching-squares-codes.d.ts.map

package/typed/contour-layer/marching-squares-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marching-squares-codes.d.ts","sourceRoot":"","sources":["../../src/contour-layer/marching-squares-codes.js"],"names":[],"mappings":"AAsJA;;;;;;;;;;;;;;;;;;;;;;;EAyCE;AAMF;;;;;;EAqKE"}

package/typed/contour-layer/marching-squares.d.ts

@@ -0,0 +1,10 @@
+export function getCode(opts: any): {
+    code: number;
+    meanCode: number;
+};
+export function getVertices(opts: any): any[];
+export namespace CONTOUR_TYPE {
+    const ISO_LINES: number;
+    const ISO_BANDS: number;
+}
+//# sourceMappingURL=marching-squares.d.ts.map

package/typed/contour-layer/marching-squares.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marching-squares.d.ts","sourceRoot":"","sources":["../../src/contour-layer/marching-squares.js"],"names":[],"mappings":"AAkCA;;;EAyEC;AAKD,8CA4DC"}

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

@@ -0,0 +1,131 @@
+declare class CPUGridLayer extends AggregationLayer {
+    _onGetSublayerColor(cell: any): any;
+    _onGetSublayerElevation(cell: any): any;
+    _getSublayerUpdateTriggers(): any;
+}
+declare namespace CPUGridLayer {
+    export const layerName: string;
+    export { defaultProps };
+}
+export default CPUGridLayer;
+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 };
+        export const min: number;
+        export const max: number;
+        const value_2: number;
+        export { value_2 as value };
+    }
+    export namespace upperPercentile {
+        const type_3: string;
+        export { type_3 as type };
+        const min_1: number;
+        export { min_1 as min };
+        const max_1: number;
+        export { max_1 as max };
+        const value_3: number;
+        export { value_3 as value };
+    }
+    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 min_2: number;
+        export { min_2 as min };
+        const max_2: number;
+        export { max_2 as max };
+        const value_6: number;
+        export { value_6 as value };
+    }
+    export namespace elevationUpperPercentile {
+        const type_7: string;
+        export { type_7 as type };
+        const min_3: number;
+        export { min_3 as min };
+        const max_3: number;
+        export { max_3 as max };
+        const value_7: number;
+        export { value_7 as value };
+    }
+    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 { pointToDensityGridDataCPU as gridAggregator };
+    export namespace cellSize {
+        const type_9: string;
+        export { type_9 as type };
+        const min_5: number;
+        export { min_5 as min };
+        const max_4: number;
+        export { max_4 as max };
+        const value_9: number;
+        export { value_9 as value };
+    }
+    export namespace coverage {
+        const type_10: string;
+        export { type_10 as type };
+        const min_6: number;
+        export { min_6 as min };
+        const max_5: number;
+        export { max_5 as max };
+        const value_10: number;
+        export { value_10 as value };
+    }
+    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 extruded: boolean;
+    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 { pointToDensityGridDataCPU } from "./grid-aggregator";
+//# sourceMappingURL=cpu-grid-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cpu-grid-layer.d.ts","sourceRoot":"","sources":["../../src/cpu-grid-layer/cpu-grid-layer.js"],"names":[],"mappings":"AAsEA;IAoCE,oCAEC;IAGD,wCAEC;IAED,kCAEC;CAgCF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAzFwC,sCAAe;;;;;;;;;;;;;;AA/BxD,6BAAiB"}

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

@@ -0,0 +1,23 @@
+/**
+ * Calculate density grid from an array of points
+ * @param {Object} props - object containing :
+ * @param {Iterable} [props.data] - data objects to be aggregated
+ * @param {Integer} [props.cellSize] - size of the grid cell
+ *
+ * @param {Object} aggregationParams - object containing :
+ * @param {Object} gridOffset - {xOffset, yOffset} cell size in meters
+ * @param {Integer} width - width of the grid
+ * @param {Integer} height - height of the grid
+ * @param {Boolean} projectPoints - `true` if doing screen space projection, `false` otherwise
+ * @param {Array} attributes - attributes array containing position values
+ * @param {Viewport} viewport - viewport to be used for projection
+ * @param {Array} posOffset - [xOffset, yOffset] offset to be applied to positions to get cell index
+ * @param {Object} boundingBox - {xMin, yMin, xMax, yMax} bounding box of input data
+ *
+ * @returns {object} - grid data, cell dimension
+ */
+export function pointToDensityGridDataCPU(props: {
+    data?: Iterable<any> | undefined;
+    cellSize?: any;
+}, aggregationParams: any): object;
+//# sourceMappingURL=grid-aggregator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grid-aggregator.d.ts","sourceRoot":"","sources":["../../src/cpu-grid-layer/grid-aggregator.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAf4B,IAAI;IACL,QAAQ;4BAYtB,MAAM,CAWlB"}

package/typed/gpu-grid-layer/gpu-grid-cell-layer-fragment.glsl.d.ts

@@ -0,0 +1,3 @@
+declare var _default: "#version 300 es\n#define SHADER_NAME gpu-grid-cell-layer-fragment-shader\n\nprecision highp float;\n\nin vec4 vColor;\n\nout vec4 fragColor;\n\nvoid main(void) {\n  fragColor = vColor;\n  fragColor = picking_filterColor(fragColor);\n}\n";
+export default _default;
+//# sourceMappingURL=gpu-grid-cell-layer-fragment.glsl.d.ts.map

package/typed/gpu-grid-layer/gpu-grid-cell-layer-fragment.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-grid-cell-layer-fragment.glsl.d.ts","sourceRoot":"","sources":["../../src/gpu-grid-layer/gpu-grid-cell-layer-fragment.glsl.js"],"names":[],"mappings":""}

package/typed/gpu-grid-layer/gpu-grid-cell-layer-vertex.glsl.d.ts

@@ -0,0 +1,3 @@
+declare var _default: "#version 300 es\n#define SHADER_NAME gpu-grid-cell-layer-vertex-shader\n#define RANGE_COUNT 6\n\nin vec3 positions;\nin vec3 normals;\n\nin vec4 colors;\nin vec4 elevations;\nin vec3 instancePickingColors;\n\n// Custom uniforms\nuniform vec2 offset;\nuniform bool extruded;\nuniform float cellSize;\nuniform float coverage;\nuniform float opacity;\nuniform float elevationScale;\n\nuniform ivec2 gridSize;\nuniform vec2 gridOrigin;\nuniform vec2 gridOriginLow;\nuniform vec2 gridOffset;\nuniform vec2 gridOffsetLow;\nuniform vec4 colorRange[RANGE_COUNT];\nuniform vec2 elevationRange;\n\n// Domain uniforms\nuniform vec2 colorDomain;\nuniform bool colorDomainValid;\nuniform vec2 elevationDomain;\nuniform bool elevationDomainValid;\n\nlayout(std140) uniform;\nuniform ColorData\n{\n  vec4 maxMinCount;\n} colorData;\nuniform ElevationData\n{\n  vec4 maxMinCount;\n} elevationData;\n\n#define EPSILON 0.00001\n\n// Result\nout vec4 vColor;\n\nvec4 quantizeScale(vec2 domain, vec4 range[RANGE_COUNT], float value) {\n  vec4 outColor = vec4(0., 0., 0., 0.);\n  if (value >= (domain.x - EPSILON) && value <= (domain.y + EPSILON)) {\n    float domainRange = domain.y - domain.x;\n    if (domainRange <= 0.) {\n      outColor = colorRange[0];\n    } else {\n      float rangeCount = float(RANGE_COUNT);\n      float rangeStep = domainRange / rangeCount;\n      float idx = floor((value - domain.x) / rangeStep);\n      idx = clamp(idx, 0., rangeCount - 1.);\n      int intIdx = int(idx);\n      outColor = colorRange[intIdx];\n    }\n  }\n  return outColor;\n}\n\nfloat linearScale(vec2 domain, vec2 range, float value) {\n  if (value >= (domain.x - EPSILON) && value <= (domain.y + EPSILON)) {\n    return ((value - domain.x) / (domain.y - domain.x)) * (range.y - range.x) + range.x;\n  }\n  return -1.;\n}\n\nvoid main(void) {\n  vec2 clrDomain = colorDomainValid ? colorDomain : vec2(colorData.maxMinCount.a, colorData.maxMinCount.r);\n  vec4 color = quantizeScale(clrDomain, colorRange, colors.r);\n\n  float elevation = 0.0;\n\n  if (extruded) {\n    vec2 elvDomain = elevationDomainValid ? elevationDomain : vec2(elevationData.maxMinCount.a, elevationData.maxMinCount.r);\n    elevation = linearScale(elvDomain, elevationRange, elevations.r);\n    elevation = elevation  * (positions.z + 1.0) / 2.0 * elevationScale;\n  }\n\n  // if aggregated color or elevation is 0 do not render\n  float shouldRender = float(color.r > 0.0 && elevations.r >= 0.0);\n  float dotRadius = cellSize / 2. * coverage * shouldRender;\n\n  int yIndex = (gl_InstanceID / gridSize[0]);\n  int xIndex = gl_InstanceID - (yIndex * gridSize[0]);\n\n  vec2 instancePositionXFP64 = mul_fp64(vec2(gridOffset[0], gridOffsetLow[0]), vec2(float(xIndex), 0.));\n  instancePositionXFP64 = sum_fp64(instancePositionXFP64, vec2(gridOrigin[0], gridOriginLow[0]));\n  vec2 instancePositionYFP64 = mul_fp64(vec2(gridOffset[1], gridOffsetLow[1]), vec2(float(yIndex), 0.));\n  instancePositionYFP64 = sum_fp64(instancePositionYFP64, vec2(gridOrigin[1], gridOriginLow[1]));\n\n  vec3 centroidPosition = vec3(instancePositionXFP64[0], instancePositionYFP64[0], elevation);\n  vec3 centroidPosition64Low = vec3(instancePositionXFP64[1], instancePositionYFP64[1], 0.0);\n  geometry.worldPosition = centroidPosition;\n  vec3 pos = vec3(project_size(positions.xy + offset) * dotRadius, 0.);\n\n  // Set color to be rendered to picking fbo (also used to check for selection highlight).\n  picking_setPickingColor(instancePickingColors);\n\n  gl_Position = project_position_to_clipspace(centroidPosition, centroidPosition64Low, pos, geometry.position);\n\n  // Light calculations\n  // Worldspace is the linear space after Mercator projection\n\n  vec3 normals_commonspace = project_normal(normals);\n\n   if (extruded) {\n    vec3 lightColor = lighting_getLightColor(color.rgb, project_uCameraPosition, geometry.position.xyz, normals_commonspace);\n    vColor = vec4(lightColor, color.a * opacity) / 255.;\n  } else {\n    vColor = vec4(color.rgb, color.a * opacity) / 255.;\n  }\n}\n";
+export default _default;
+//# sourceMappingURL=gpu-grid-cell-layer-vertex.glsl.d.ts.map

package/typed/gpu-grid-layer/gpu-grid-cell-layer-vertex.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-grid-cell-layer-vertex.glsl.d.ts","sourceRoot":"","sources":["../../src/gpu-grid-layer/gpu-grid-cell-layer-vertex.glsl.js"],"names":[],"mappings":""}

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

@@ -0,0 +1,85 @@
+declare class GPUGridCellLayer extends Layer<any> {
+    constructor(...propObjects: Partial<any>[]);
+    _getModel(gl: any): any;
+    bindUniformBuffers(colorMaxMinBuffer: any, elevationMaxMinBuffer: any): void;
+    unbindUniformBuffers(colorMaxMinBuffer: any, elevationMaxMinBuffer: any): void;
+    getDomainUniforms(): {
+        colorDomainValid: boolean;
+        colorDomain: any;
+        elevationDomainValid: boolean;
+        elevationDomain: any;
+    };
+    _setupUniformBuffer(model: any): void;
+}
+declare namespace GPUGridCellLayer {
+    export const layerName: string;
+    export { defaultProps };
+}
+export default GPUGridCellLayer;
+import { Layer } from '@deck.gl/core/typed';
+declare namespace defaultProps {
+    export const colorDomain: null;
+    export { defaultColorRange as colorRange };
+    export const elevationDomain: null;
+    export const elevationRange: number[];
+    export namespace elevationScale {
+        const type: string;
+        const min: number;
+        const value: number;
+    }
+    export namespace gridSize {
+        const type_1: string;
+        export { type_1 as type };
+        const min_1: number;
+        export { min_1 as min };
+        const value_1: number[];
+        export { value_1 as value };
+    }
+    export namespace gridOrigin {
+        const type_2: string;
+        export { type_2 as type };
+        const min_2: number;
+        export { min_2 as min };
+        const value_2: number[];
+        export { value_2 as value };
+    }
+    export namespace gridOffset {
+        const type_3: string;
+        export { type_3 as type };
+        const min_3: number;
+        export { min_3 as min };
+        const value_3: number[];
+        export { value_3 as value };
+    }
+    export namespace cellSize {
+        const type_4: string;
+        export { type_4 as type };
+        const min_4: number;
+        export { min_4 as min };
+        export const max: number;
+        const value_4: number;
+        export { value_4 as value };
+    }
+    export namespace offset {
+        const type_5: string;
+        export { type_5 as type };
+        const min_5: number;
+        export { min_5 as min };
+        const value_5: number[];
+        export { value_5 as value };
+    }
+    export namespace coverage {
+        const type_6: string;
+        export { type_6 as type };
+        const min_6: number;
+        export { min_6 as min };
+        const max_1: number;
+        export { max_1 as max };
+        const value_6: number;
+        export { value_6 as value };
+    }
+    export const extruded: boolean;
+    export const material: boolean;
+}
+import { defaultColorRange } from "../utils/color-utils";
+//# sourceMappingURL=gpu-grid-cell-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-grid-cell-layer.d.ts","sourceRoot":"","sources":["../../src/gpu-grid-layer/gpu-grid-cell-layer.js"],"names":[],"mappings":"AAuDA;IA7CoB,4CAEN;IAsEZ,wBAOC;IA2CD,6EAGC;IAED,+EAGC;IAED;;;;;MAgBC;IAED,sCAQC;CACF"}

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

@@ -0,0 +1,65 @@
+declare class GPUGridLayer extends GridAggregationLayer {
+    getHashKeyForIndex(index: any): string;
+    getPositionForIndex(index: any): any[];
+    _updateAccessors(opts: any): void;
+}
+declare namespace GPUGridLayer {
+    export const layerName: string;
+    export { defaultProps };
+}
+export default GPUGridLayer;
+import GridAggregationLayer from "../grid-aggregation-layer";
+declare namespace defaultProps {
+    export const colorDomain: null;
+    export { defaultColorRange as colorRange };
+    export namespace getColorWeight {
+        const type: string;
+        const value: number;
+    }
+    export const colorAggregation: string;
+    export const elevationDomain: null;
+    export const elevationRange: number[];
+    export namespace getElevationWeight {
+        const type_1: string;
+        export { type_1 as type };
+        const value_1: number;
+        export { value_1 as value };
+    }
+    export const elevationAggregation: string;
+    export namespace elevationScale {
+        const type_2: string;
+        export { type_2 as type };
+        export const min: number;
+        const value_2: number;
+        export { value_2 as value };
+    }
+    export namespace cellSize {
+        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 namespace coverage {
+        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 getPosition {
+        const type_5: string;
+        export { type_5 as type };
+        export function value_5(x: any): any;
+        export { value_5 as value };
+    }
+    export const extruded: boolean;
+    export const material: boolean;
+}
+import { defaultColorRange } from "../utils/color-utils";
+//# sourceMappingURL=gpu-grid-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-grid-layer.d.ts","sourceRoot":"","sources":["../../src/gpu-grid-layer/gpu-grid-layer.js"],"names":[],"mappings":"AAmEA;IAgEE,uCAgBC;IAED,uCAWC;IA6KD,kCAKC;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAlSwC,qCAAe"}

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

@@ -0,0 +1,19 @@
+declare class GridAggregationLayer extends AggregationLayer {
+    updateAggregationState(opts: any): void;
+    allocateResources(numRow: any, numCol: any): void;
+    updateResults({ aggregationData, maxMinData, maxData, minData }: {
+        aggregationData: any;
+        maxMinData: any;
+        maxData: any;
+        minData: any;
+    }): void;
+    _updateAggregation(opts: any): void;
+    _updateWeightBins(): void;
+    _uploadAggregationResults(): void;
+}
+declare namespace GridAggregationLayer {
+    const layerName: string;
+}
+export default GridAggregationLayer;
+import AggregationLayer from "./aggregation-layer";
+//# sourceMappingURL=grid-aggregation-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grid-aggregation-layer.d.ts","sourceRoot":"","sources":["../src/grid-aggregation-layer.js"],"names":[],"mappings":"AA4BA;IA2DE,wCAGC;IAED,kDAoBC;IAED;;;;;aAQC;IAID,oCA8CC;IAED,0BAKC;IAED,kCAmBC;CACF"}