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

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

@@ -0,0 +1,93 @@
+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;
+    };
+    extruded: boolean;
+    material: boolean;
+    _filterData: {
+        type: string;
+        value: null;
+        optional: boolean;
+    };
+};
+//# sourceMappingURL=grid-layer.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,13 @@
+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 }: {
+    gl: any;
+    floatTargetSupport: any;
+}): {
+    format: number;
+    type: number;
+};
+//# sourceMappingURL=heatmap-layer-utils.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,96 @@
+declare class HeatmapLayer extends AggregationLayer {
+    _updateHeatmapState(opts: any): void;
+    _getChangeFlags(opts: any): {
+        dataChanged: boolean;
+        viewportChanged: any;
+        viewportZoomChanged: boolean;
+    };
+    _createTextures(): void;
+    _setupAttributes(): void;
+    _setupTextureParams(): void;
+    _createWeightsTransform(shaders?: {}): void;
+    _setupResources(): void;
+    _updateMaxWeightValue(): void;
+    _updateBounds(forceUpdate?: boolean): boolean;
+    _updateTextureRenderingBounds(): void;
+    _updateColorTexture(opts: any): void;
+    _updateWeightmap(): void;
+    _debouncedUpdateWeightmap(fromTimer?: boolean): void;
+    _worldToCommonBounds(worldBounds: any, opts?: {}): 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";
+//# sourceMappingURL=heatmap-layer.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,3 @@
+declare var _default: "varying vec4 outTexture;\nvoid main() {\n  gl_FragColor = outTexture;\n  gl_FragColor.g = outTexture.r / max(1.0, outTexture.a);\n}\n";
+export default _default;
+//# sourceMappingURL=max-fs.glsl.d.ts.map

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

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

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

@@ -0,0 +1,3 @@
+declare var _default: "attribute vec4 inTexture;\nvarying vec4 outTexture;\n\nvoid main()\n{\noutTexture = inTexture;\ngl_Position = vec4(0, 0, 0, 1.);\n// Enforce default value for ANGLE issue (https://bugs.chromium.org/p/angleproject/issues/detail?id=3941)\ngl_PointSize = 1.0;\n}\n";
+export default _default;
+//# sourceMappingURL=max-vs.glsl.d.ts.map

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

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

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

@@ -0,0 +1,3 @@
+declare var _default: "#define SHADER_NAME triangle-layer-fragment-shader\n\nprecision highp float;\n\nuniform float opacity;\nuniform sampler2D texture;\nuniform sampler2D colorTexture;\nuniform float aggregationMode;\n\nvarying vec2 vTexCoords;\nvarying float vIntensityMin;\nvarying float vIntensityMax;\n\nvec4 getLinearColor(float value) {\n  float factor = clamp(value * vIntensityMax, 0., 1.);\n  vec4 color = texture2D(colorTexture, vec2(factor, 0.5));\n  color.a *= min(value * vIntensityMin, 1.0);\n  return color;\n}\n\nvoid main(void) {\n  vec4 weights = texture2D(texture, vTexCoords);\n  float weight = weights.r;\n\n  if (aggregationMode > 0.5) {\n    weight /= max(1.0, weights.a);\n  }\n\n  // discard pixels with 0 weight.\n  if (weight <= 0.) {\n     discard;\n  }\n\n  vec4 linearColor = getLinearColor(weight);\n  linearColor.a *= opacity;\n  gl_FragColor =linearColor;\n}\n";
+export default _default;
+//# sourceMappingURL=triangle-layer-fragment.glsl.d.ts.map

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

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

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

@@ -0,0 +1,3 @@
+declare var _default: "#define SHADER_NAME heatp-map-layer-vertex-shader\n\nuniform sampler2D maxTexture;\nuniform float intensity;\nuniform vec2 colorDomain;\nuniform float threshold;\nuniform float aggregationMode;\n\nattribute vec3 positions;\nattribute vec2 texCoords;\n\nvarying vec2 vTexCoords;\nvarying float vIntensityMin;\nvarying float vIntensityMax;\n\nvoid main(void) {\n  gl_Position = project_position_to_clipspace(positions, vec3(0.0), vec3(0.0));\n  vTexCoords = texCoords;\n  vec4 maxTexture = texture2D(maxTexture, vec2(0.5));\n  float maxValue = aggregationMode < 0.5 ? maxTexture.r : maxTexture.g;\n  float minValue = maxValue * threshold;\n  if (colorDomain[1] > 0.) {\n    // if user specified custom domain use it.\n    maxValue = colorDomain[1];\n    minValue = colorDomain[0];\n  }\n  vIntensityMax = intensity / maxValue;\n  vIntensityMin = intensity / minValue;\n}\n";
+export default _default;
+//# sourceMappingURL=triangle-layer-vertex.glsl.d.ts.map

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

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

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

@@ -0,0 +1,10 @@
+declare class TriangleLayer extends Layer<any> {
+    constructor(...propObjects: Partial<any>[]);
+    _getModel(gl: any): any;
+}
+declare namespace TriangleLayer {
+    const layerName: string;
+}
+export default TriangleLayer;
+import { Layer } from '@deck.gl/core/typed';
+//# sourceMappingURL=triangle-layer.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +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";
+export default _default;
+//# sourceMappingURL=weights-fs.glsl.d.ts.map

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

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

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

@@ -0,0 +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";
+export default _default;
+//# sourceMappingURL=weights-vs.glsl.d.ts.map

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

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

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

@@ -0,0 +1,24 @@
+/**
+ * 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: any, aggregationParams: any): any;
+/**
+ * Get the bounding box of all data points
+ */
+export function getPointsCenter(data: any, aggregationParams: any): number[] | 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: number, viewport: any, center: Array<number>): number;
+//# sourceMappingURL=hexagon-aggregator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hexagon-aggregator.d.ts","sourceRoot":"","sources":["../../src/hexagon-layer/hexagon-aggregator.js"],"names":[],"mappings":"AAuBA;;;;;;;;GAQG;AACH,uEA2CC;AAED;;GAEG;AACH,oFA4BC;AAED;;;;;;;GAOG;AACH,yEAJW,aAAa,UAQvB"}

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

@@ -0,0 +1,130 @@
+declare class HexagonLayer extends AggregationLayer {
+    convertLatLngToMeterOffset(hexagonVertices: any): number[][] | null;
+    _onGetSublayerColor(cell: any): any;
+    _onGetSublayerElevation(cell: any): any;
+    _getSublayerUpdateTriggers(): any;
+}
+declare namespace HexagonLayer {
+    export const layerName: string;
+    export { defaultProps };
+}
+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";
+//# sourceMappingURL=hexagon-layer.d.ts.map

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

@@ -0,0 +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"}

package/typed/index.d.ts

@@ -0,0 +1,13 @@
+export { default as ScreenGridLayer } from './screen-grid-layer/screen-grid-layer';
+export { default as CPUGridLayer } from './cpu-grid-layer/cpu-grid-layer';
+export { default as HexagonLayer } from './hexagon-layer/hexagon-layer';
+export { default as ContourLayer } from './contour-layer/contour-layer';
+export { default as GridLayer } from './grid-layer/grid-layer';
+export { default as GPUGridLayer } from './gpu-grid-layer/gpu-grid-layer';
+export { AGGREGATION_OPERATION } from './utils/aggregation-operation-utils';
+export { default as HeatmapLayer } from './heatmap-layer/heatmap-layer';
+export { default as _GPUGridAggregator } from './utils/gpu-grid-aggregation/gpu-grid-aggregator';
+export { default as _CPUAggregator } from './utils/cpu-aggregator';
+export { default as _AggregationLayer } from './aggregation-layer';
+export { default as _BinSorter } from './utils/bin-sorter';
+//# sourceMappingURL=index.d.ts.map

package/typed/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAC,qBAAqB,EAAC,MAAM,qCAAqC,CAAC;AAG1E,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAC,OAAO,IAAI,kBAAkB,EAAC,MAAM,kDAAkD,CAAC;AAC/F,OAAO,EAAC,OAAO,IAAI,cAAc,EAAC,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAC,OAAO,IAAI,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,oBAAoB,CAAC"}

package/typed/package.json

@@ -0,0 +1,6 @@
+{
+  "internal": true,
+  "main": "../dist/es5/index.js",
+  "module": "../dist/esm/index.js",
+  "types": "index.d.ts"
+}

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

@@ -0,0 +1,33 @@
+declare class ScreenGridCellLayer extends Layer<any> {
+    static isSupported(gl: any): any;
+    constructor(...propObjects: Partial<any>[]);
+    calculateInstancePositions(attribute: any, { numInstances }: {
+        numInstances: any;
+    }): void;
+    _getModel(gl: any): any;
+    _shouldUseMinMax(): boolean;
+    _updateUniforms(oldProps: any, props: any, changeFlags: any): void;
+}
+declare namespace ScreenGridCellLayer {
+    export const layerName: string;
+    export { defaultProps };
+}
+export default ScreenGridCellLayer;
+import { Layer } from '@deck.gl/core/typed';
+declare namespace defaultProps {
+    export namespace cellSizePixels {
+        const value: number;
+        const min: number;
+    }
+    export namespace cellMarginPixels {
+        const value_1: number;
+        export { value_1 as value };
+        const min_1: number;
+        export { min_1 as min };
+        export const max: number;
+    }
+    export const colorDomain: null;
+    export { defaultColorRange as colorRange };
+}
+import { defaultColorRange } from "../utils/color-utils";
+//# sourceMappingURL=screen-grid-cell-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"screen-grid-cell-layer.d.ts","sourceRoot":"","sources":["../../src/screen-grid-layer/screen-grid-cell-layer.js"],"names":[],"mappings":"AAuCA;IACE,iCAEC;IAhCiB,4CAEN;IA4FZ;;aAcC;IAID,wBAYC;IAED,4BAaC;IAED,mEA0BC;CACF"}

package/typed/screen-grid-layer/screen-grid-layer-fragment.glsl.d.ts

@@ -0,0 +1,3 @@
+declare var _default: "#define SHADER_NAME screen-grid-layer-fragment-shader\n\nprecision highp float;\n\nvarying vec4 vColor;\nvarying float vSampleCount;\n\nvoid main(void) {\n  if (vSampleCount <= 0.0) {\n    discard;\n  }\n  gl_FragColor = vColor;\n\n  DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n";
+export default _default;
+//# sourceMappingURL=screen-grid-layer-fragment.glsl.d.ts.map

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

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

package/typed/screen-grid-layer/screen-grid-layer-vertex.glsl.d.ts

@@ -0,0 +1,3 @@
+declare var _default: "#define SHADER_NAME screen-grid-layer-vertex-shader\n#define RANGE_COUNT 6\n\nattribute vec3 positions;\nattribute vec3 instancePositions;\nattribute vec4 instanceCounts;\nattribute vec3 instancePickingColors;\n\nuniform float opacity;\nuniform vec3 cellScale;\nuniform vec4 minColor;\nuniform vec4 maxColor;\nuniform vec4 colorRange[RANGE_COUNT];\nuniform vec2 colorDomain;\nuniform bool shouldUseMinMax;\nuniform sampler2D maxTexture;\n\nvarying vec4 vColor;\nvarying float vSampleCount;\n\nvec4 quantizeScale(vec2 domain, vec4 range[RANGE_COUNT], float value) {\n  vec4 outColor = vec4(0., 0., 0., 0.);\n  if (value >= domain.x && value <= domain.y) {\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  outColor = outColor / 255.;\n  return outColor;\n}\n\nvoid main(void) {\n  vSampleCount = instanceCounts.a;\n\n  float weight = instanceCounts.r;\n  float maxWeight = texture2D(maxTexture, vec2(0.5)).r;\n\n  float step = weight / maxWeight;\n  vec4 minMaxColor = mix(minColor, maxColor, step) / 255.;\n\n  vec2 domain = colorDomain;\n  float domainMaxValid = float(colorDomain.y != 0.);\n  domain.y = mix(maxWeight, colorDomain.y, domainMaxValid);\n  vec4 rangeColor = quantizeScale(domain, colorRange, weight);\n\n  float rangeMinMax = float(shouldUseMinMax);\n  vec4 color = mix(rangeColor, minMaxColor, rangeMinMax);\n  vColor = vec4(color.rgb, color.a * opacity);\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 = vec4(instancePositions + positions * cellScale, 1.);\n}\n";
+export default _default;
+//# sourceMappingURL=screen-grid-layer-vertex.glsl.d.ts.map

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

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

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

@@ -0,0 +1,34 @@
+declare class ScreenGridLayer extends GridAggregationLayer {
+    _updateAccessors(opts: any): void;
+    _resetResults(): void;
+}
+declare namespace ScreenGridLayer {
+    export const layerName: string;
+    export { defaultProps };
+}
+export default ScreenGridLayer;
+import GridAggregationLayer from "../grid-aggregation-layer";
+declare const defaultProps: {
+    getPosition: {
+        type: string;
+        value: (d: any) => any;
+    };
+    getWeight: {
+        type: string;
+        value: number;
+    };
+    gpuAggregation: boolean;
+    aggregation: string;
+    cellSizePixels: {
+        value: number;
+        min: number;
+    };
+    cellMarginPixels: {
+        value: number;
+        min: number;
+        max: number;
+    };
+    colorDomain: null;
+    colorRange: number[][];
+};
+//# sourceMappingURL=screen-grid-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"screen-grid-layer.d.ts","sourceRoot":"","sources":["../../src/screen-grid-layer/screen-grid-layer.js"],"names":[],"mappings":"AAgDA;IAqLE,kCAQC;IAED,sBAKC;CACF;;;;;;;AAzND;;;;;;;;;;;;;;;;;;;;;;EAOE"}

package/typed/utils/aggregation-operation-utils.d.ts

@@ -0,0 +1,13 @@
+export function getMean(pts: any, accessor: any): any;
+export function getSum(pts: any, accessor: any): any;
+export function getMax(pts: any, accessor: any): any;
+export function getMin(pts: any, accessor: any): any;
+export function getValueFunc(aggregation: any, accessor: any, context: any): ((pts: any) => any) | null;
+export function wrapGetValueFunc(getValue: any, context?: {}): (pts: any) => any;
+export namespace AGGREGATION_OPERATION {
+    const SUM: number;
+    const MEAN: number;
+    const MIN: number;
+    const MAX: number;
+}
+//# sourceMappingURL=aggregation-operation-utils.d.ts.map

package/typed/utils/aggregation-operation-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregation-operation-utils.d.ts","sourceRoot":"","sources":["../../src/utils/aggregation-operation-utils.js"],"names":[],"mappings":"AAuCA,sDAOC;AAED,qDAOC;AAED,qDAOC;AAED,qDAOC;AAGD,wGAeC;AAYD,iFAQC"}

package/typed/utils/bin-sorter.d.ts

@@ -0,0 +1,46 @@
+export default class BinSorter {
+    constructor(bins?: any[], props?: {
+        getValue: (points: any) => any;
+        getPoints: (bin: any) => any;
+        getIndex: (bin: any) => any;
+        filterData: null;
+    });
+    aggregatedBins: any[];
+    binMap: any;
+    /**
+     * Get an array of object with aggregated values and index of bins
+     * Array object will be sorted by value optionally.
+     * @param {Array} bins
+     * @param {Function} getValue
+     * @return {Array} array of values and index lookup
+     */
+    getAggregatedBins(bins: any[], props: any): any[];
+    _percentileToIndex(percentileRange: any): number[];
+    /**
+     * Get a mapping from cell/hexagon index to sorted bin
+     * This is used to retrieve bin value for color calculation
+     * @return {Object} bin index to aggregatedBins
+     */
+    getBinMap(): any;
+    /**
+     * Get ths max count of all bins
+     * @return {Number | Boolean} max count
+     */
+    _updateMinMaxValues(): number | boolean;
+    maxCount: number | undefined;
+    maxValue: number | undefined;
+    minValue: number | undefined;
+    totalCount: number | undefined;
+    /**
+     * Get range of values of all bins
+     * @param {Number[]} range
+     * @param {Number} range[0] - lower bound
+     * @param {Number} range[1] - upper bound
+     * @return {Array} array of new value range
+     */
+    getValueRange(percentileRange: any): any[];
+    sortedBins: any[] | undefined;
+    getValueDomainByScale(scale: any, [lower, upper]?: [(number | undefined)?, (number | undefined)?]): any;
+    _getScaleDomain(scaleType: any, [lowerIdx, upperIdx]: [any, any]): any;
+}
+//# sourceMappingURL=bin-sorter.d.ts.map

package/typed/utils/bin-sorter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin-sorter.d.ts","sourceRoot":"","sources":["../../src/utils/bin-sorter.js"],"names":[],"mappings":"AA6CA;IACE;;;;;OAIC;IAHC,sBAAyD;IAEzD,YAA8B;IAGhC;;;;;;OAMG;IACH,kDAmCC;IAED,mDAYC;IAED;;;;OAIG;IACH,iBAMC;IAID;;;OAGG;IACH,uBAFY,gBAAgB,CAiB3B;IAJC,6BAAwB;IACxB,6BAAwB;IACxB,6BAAwB;IACxB,+BAA4B;IAG9B;;;;;;OAMG;IACH,2CAiBC;IAfG,8BAAiF;IAiBrF,wGAUC;IAED,uEAiBC;CACF"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"color-utils.d.ts","sourceRoot":"","sources":["../../src/utils/color-utils.js"],"names":[],"mappings":"AA8BA,+HA0BC;AApCD,2CAOE"}