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

package/src/utils/{color-utils.js → color-utils.ts}

@@ -18,7 +18,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-export const defaultColorRange = [
+export const defaultColorRange: [number, number, number][] = [
   [255, 255, 178],
   [254, 217, 118],
   [254, 178, 76],

package/typed/aggregation-layer.d.ts

@@ -1,5 +1,14 @@
-declare class AggregationLayer extends CompositeLayer<any> {
-    constructor(...propObjects: Partial<any>[]);
+import { CompositeLayer, AttributeManager, UpdateParameters, CompositeLayerProps } from '@deck.gl/core/typed';
+export declare type AggregationLayerProps<DataT = any> = CompositeLayerProps<DataT>;
+export default abstract class AggregationLayer<ExtraPropsT = {}> extends CompositeLayer<ExtraPropsT> {
+    static layerName: string;
+    state: CompositeLayer['state'] & {
+        ignoreProps?: Record<string, any>;
+        dimensions?: any;
+    };
+    initializeAggregationLayer(dimensions: any): void;
+    updateState(opts: UpdateParameters<this>): void;
+    updateAttributes(changedAttributes: any): void;
     getAttributes(): {
         [id: string]: import("modules/core/src/lib/attribute/shader-attribute").IShaderAttribute;
     };
@@ -14,20 +23,16 @@ declare class AggregationLayer extends CompositeLayer<any> {
      * @returns {Boolean} - returns true if dimensions' prop or accessor is changed
      **/
     isAggregationDirty(updateOpts: any, params?: {
-        dimension: any;
-        compareAll: boolean;
-    }): boolean;
+        compareAll?: boolean;
+        dimension?: any;
+    }): string | 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;
+    isAttributeChanged(name?: string): any;
+    _getAttributeManager(): AttributeManager;
 }
-export default AggregationLayer;
-import { CompositeLayer } from '@deck.gl/core/typed';
 //# sourceMappingURL=aggregation-layer.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"aggregation-layer.d.ts","sourceRoot":"","sources":["../src/aggregation-layer.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,cAAc,EACd,gBAAgB,EAEhB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,eAAe,CAAC;AAIvB,oBAAY,qBAAqB,CAAC,KAAK,GAAG,GAAG,IAAI,mBAAmB,CAAC,KAAK,CAAC,CAAC;AAE5E,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,gBAAgB,CAC5C,WAAW,GAAG,EAAE,CAChB,SAAQ,cAAc,CAAC,WAAW,CAAC;IACnC,MAAM,CAAC,SAAS,SAAsB;IAEtC,KAAK,EAAG,cAAc,CAAC,OAAO,CAAC,GAAG;QAChC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAClC,UAAU,CAAC,EAAE,GAAG,CAAC;KAClB,CAAC;IAEF,0BAA0B,CAAC,UAAU,EAAE,GAAG;IAU1C,WAAW,CAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAexC,gBAAgB,CAAC,iBAAiB,KAAA;IAMlC,aAAa;;;IAIb,iBAAiB;IAcjB,aAAa,CAAC,OAAO,KAAA;IAIrB;;;;;;;QAOI;IACJ,kBAAkB,CAChB,UAAU,KAAA,EACV,MAAM,GAAE;QAAC,UAAU,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,GAAG,CAAA;KAAM,GACnD,MAAM,GAAG,OAAO;IAyCnB;;;;;QAKI;IACJ,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM;IAYhC,oBAAoB;CAMrB"}

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

@@ -1,39 +1,74 @@
-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;
+import { Accessor, AccessorFunction, Color, Layer, Position, UpdateParameters, DefaultProps } from '@deck.gl/core/typed';
+import GridAggregationLayer, { GridAggregationLayerProps } from '../grid-aggregation-layer';
+/** All properties supported by ContourLayer. */
+export declare type ContourLayerProps<DataT = any> = _ContourLayerProps<DataT> & GridAggregationLayerProps<DataT>;
+/** Properties added by ContourLayer. */
+export declare type _ContourLayerProps<DataT> = {
+    /**
+     * Size of each cell in meters.
+     * @default 1000
+     */
+    cellSize?: number;
+    /**
+     * When set to true, aggregation is performed on GPU, provided other conditions are met.
+     * @default true
+     */
+    gpuAggregation?: boolean;
+    /**
+     * Defines the type of aggregation operation, valid values are 'SUM', 'MEAN', 'MIN' and 'MAX'.
+     * @default 'SUM'
+     */
+    aggregation?: 'SUM' | 'MEAN' | 'MIN' | 'MAX';
+    /**
+     * Definition of contours to be drawn.
+     * @default [{threshold: 1}]
+     */
+    contours: {
+        /**
+         * Isolines: `threshold` value must be a single `Number`, Isolines are generated based on this threshold value.
+         *
+         * Isobands: `threshold` value must be an Array of two `Number`s. Isobands are generated using `[threshold[0], threshold[1])` as threshold range, i.e area that has values `>= threshold[0]` and `< threshold[1]` are rendered with corresponding color. NOTE: `threshold[0]` is inclusive and `threshold[1]` is not inclusive.
+         */
+        threshold: number | number[];
+        /**
+         * RGBA color array to be used to render the contour.
+         * @default [255, 255, 255, 255]
+         */
+        color?: Color;
+        /**
+         * Applicable for `Isoline`s only, width of the Isoline in pixels.
+         * @default 1
+         */
+        strokeWidth?: number;
+        /** Defines z order of the contour. */
+        zIndex?: number;
     }[];
-    const zOffset: number;
+    /**
+     * A very small z offset that is added for each vertex of a contour (Isoline or Isoband).
+     * @default 0.005
+     */
+    zOffset?: number;
+    /**
+     * Method called to retrieve the position of each object.
+     * @default object => object.position
+     */
+    getPosition?: AccessorFunction<DataT, Position>;
+    /**
+     * The weight of each object.
+     * @default 1
+     */
+    getWeight?: Accessor<DataT, number>;
+};
+export default class ContourLayer<DataT = any, ExtraPropsT = {}> extends GridAggregationLayer<ExtraPropsT & Required<_ContourLayerProps<DataT>>> {
+    static layerName: string;
+    static defaultProps: DefaultProps<ContourLayerProps<any>>;
+    initializeState(): void;
+    updateState(opts: UpdateParameters<this>): void;
+    renderLayers(): Layer[];
+    updateAggregationState(opts: any): void;
+    private _updateAccessors;
+    private _resetResults;
+    private _generateContours;
+    private _updateThresholdData;
 }
 //# sourceMappingURL=contour-layer.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"contour-layer.d.ts","sourceRoot":"","sources":["../../src/contour-layer/contour-layer.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,KAAK,EACL,KAAK,EAEL,QAAQ,EACR,gBAAgB,EAChB,YAAY,EACb,MAAM,eAAe,CAAC;AAKvB,OAAO,oBAAoB,EAAE,EAAC,yBAAyB,EAAC,MAAM,2BAA2B,CAAC;AAgC1F,gDAAgD;AAChD,oBAAY,iBAAiB,CAAC,KAAK,GAAG,GAAG,IAAI,kBAAkB,CAAC,KAAK,CAAC,GACpE,yBAAyB,CAAC,KAAK,CAAC,CAAC;AAEnC,wCAAwC;AACxC,oBAAY,kBAAkB,CAAC,KAAK,IAAI;IACtC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,WAAW,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;IAE7C;;;OAGG;IACH,QAAQ,EAAE;QACR;;;;WAIG;QACH,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;QAE7B;;;WAGG;QACH,KAAK,CAAC,EAAE,KAAK,CAAC;QAEd;;;WAGG;QACH,WAAW,CAAC,EAAE,MAAM,CAAC;QAErB,sCAAsC;QACtC,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,EAAE,CAAC;IAEJ;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAEhD;;;OAGG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;CACrC,CAAC;AACF,MAAM,CAAC,OAAO,OAAO,YAAY,CAAC,KAAK,GAAG,GAAG,EAAE,WAAW,GAAG,EAAE,CAAE,SAAQ,oBAAoB,CAC3F,WAAW,GAAG,QAAQ,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAClD;IACC,MAAM,CAAC,SAAS,SAAkB;IAClC,MAAM,CAAC,YAAY,uCAAgB;IAEnC,eAAe,IAAI,IAAI;IA2BvB,WAAW,CAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;IAgB/C,YAAY,IAAI,KAAK,EAAE;IA4CvB,sBAAsB,CAAC,IAAI,KAAA;IAyE3B,OAAO,CAAC,gBAAgB;IAUxB,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,iBAAiB;IAsBzB,OAAO,CAAC,oBAAoB;CAc7B"}

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

@@ -1,18 +1,17 @@
-export function generateContours({ thresholdData, colors, cellWeights, gridSize, gridOrigin, cellSize }: {
+export declare function generateContours({ thresholdData, cellWeights, gridSize, gridOrigin, cellSize }: {
     thresholdData: any;
-    colors: any;
-    cellWeights: any;
-    gridSize: any;
-    gridOrigin: any;
-    cellSize: any;
+    cellWeights: Float32Array;
+    gridSize: number[];
+    gridOrigin: number[];
+    cellSize: number[];
 }): {
     contourSegments: {
-        start: any;
-        end: any;
+        start: number[];
+        end: number[];
         contour: any;
     }[];
     contourPolygons: {
-        vertices: any;
+        vertices: number[][];
         contour: any;
     }[];
 };

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

@@ -1 +1 @@
-{"version":3,"file":"contour-utils.d.ts","sourceRoot":"","sources":["../../src/contour-layer/contour-utils.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;EAiEC"}
+{"version":3,"file":"contour-utils.d.ts","sourceRoot":"","sources":["../../src/contour-layer/contour-utils.ts"],"names":[],"mappings":"AAIA,wBAAgB,gBAAgB,CAAC,EAC/B,aAAa,EACb,WAAW,EACX,QAAQ,EACR,UAAU,EACV,QAAQ,EACT,EAAE;IACD,aAAa,EAAE,GAAG,CAAC;IACnB,WAAW,EAAE,YAAY,CAAC;IAC1B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;;eACgC,MAAM,EAAE;aAAO,MAAM,EAAE;iBAAW,GAAG;;;kBAClC,MAAM,EAAE,EAAE;iBAAW,GAAG;;EAyD3D"}

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

@@ -1,4 +1,4 @@
-export const ISOLINES_CODE_OFFSET_MAP: {
+export declare const ISOLINES_CODE_OFFSET_MAP: {
     0: never[];
     1: number[][][];
     2: number[][][];
@@ -22,7 +22,7 @@ export const ISOLINES_CODE_OFFSET_MAP: {
     14: number[][][];
     15: never[];
 };
-export const ISOBANDS_CODE_OFFSET_MAP: {
+export declare const ISOBANDS_CODE_OFFSET_MAP: {
     [x: number]: number[][][] | {
         0: number[][][];
         1: number[][][];

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

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

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

@@ -1,10 +1,10 @@
-export function getCode(opts: any): {
+export declare const CONTOUR_TYPE: {
+    ISO_LINES: number;
+    ISO_BANDS: number;
+};
+export declare 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;
-}
+export declare function getVertices(opts: any): number[][] | number[][][];
 //# sourceMappingURL=marching-squares.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"marching-squares.d.ts","sourceRoot":"","sources":["../../src/contour-layer/marching-squares.js"],"names":[],"mappings":"AAkCA;;;EAyEC;AAKD,8CA4DC"}
+{"version":3,"file":"marching-squares.d.ts","sourceRoot":"","sources":["../../src/contour-layer/marching-squares.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,YAAY;;;CAGxB,CAAC;AAyBF,wBAAgB,OAAO,CAAC,IAAI,KAAA;;;EAyE3B;AAKD,wBAAgB,WAAW,CAAC,IAAI,KAAA,6BA4D/B"}

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

@@ -1,131 +1,152 @@
-declare class CPUGridLayer extends AggregationLayer {
+import { Accessor, AccessorFunction, Color, Position, Material, DefaultProps } from '@deck.gl/core/typed';
+import AggregationLayer, { AggregationLayerProps } from '../aggregation-layer';
+import Layer, { UpdateParameters } from 'modules/core/src/lib/layer';
+import { GetPickingInfoParams, PickingInfo } from 'modules/core/src/lib/picking/pick-info';
+import { AggregateAccessor } from '../types';
+/** All properties supported by CPUGridLayer. */
+export declare type CPUGridLayerProps<DataT = any> = _CPUGridLayerProps<DataT> & AggregationLayerProps<DataT>;
+/** Properties added by CPUGridLayer. */
+export declare type _CPUGridLayerProps<DataT> = {
+    /**
+     * Size of each cell in meters.
+     * @default 1000
+     */
+    cellSize?: number;
+    /**
+     * Color scale domain, default is set to the extent of aggregated weights in each cell.
+     * @default [min(colorWeight), max(colorWeight)]
+     */
+    colorDomain?: [number, number] | null;
+    /**
+     * Default: [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6) `6-class YlOrRd`
+     */
+    colorRange?: Color[];
+    /**
+     * Cell size multiplier, clamped between 0 - 1.
+     * @default 1
+     */
+    coverage?: number;
+    /**
+     * Elevation scale input domain, default is set to between 0 and the max of aggregated weights in each cell.
+     * @default [0, max(elevationWeight)]
+     */
+    elevationDomain?: [number, number] | null;
+    /**
+     * Elevation scale output range.
+     * @default [0, 1000]
+     */
+    elevationRange?: [number, number];
+    /**
+     * Cell elevation multiplier.
+     * @default 1
+     */
+    elevationScale?: number;
+    /**
+     * Whether to enable cell elevation. If set to false, all cell will be flat.
+     * @default true
+     */
+    extruded?: boolean;
+    /**
+     * Filter cells and re-calculate color by `upperPercentile`.
+     * Cells with value arger than the upperPercentile will be hidden.
+     * @default 100
+     */
+    upperPercentile?: number;
+    /**
+     * Filter cells and re-calculate color by `lowerPercentile`.
+     * Cells with value smaller than the lowerPercentile will be hidden.
+     * @default 0
+     */
+    lowerPercentile?: number;
+    /**
+     * Filter cells and re-calculate elevation by `elevationUpperPercentile`.
+     * Cells with elevation value larger than the `elevationUpperPercentile` will be hidden.
+     * @default 100
+     */
+    elevationUpperPercentile?: number;
+    /**
+     * Filter cells and re-calculate elevation by `elevationLowerPercentile`.
+     * Cells 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', 'linear', 'quantile' and 'ordinal'.
+     * @default 'quantize'
+     */
+    colorScaleType?: 'quantize' | 'linear' | 'quantile' | 'ordinal';
+    /**
+     * Scaling function used to determine the elevation of the grid cell, only supports 'linear'.
+     */
+    elevationScaleType?: 'linear';
+    gridAggregator?: (props: any, params: any) => any;
+    /**
+     * Material settings for lighting effect. Applies if `extruded: true`.
+     *
+     * @default true
+     * @see https://deck.gl/docs/developer-guide/using-lighting
+     */
+    material?: Material;
+    /**
+     * 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 cell.
+     * @default 1
+     */
+    getColorWeight?: Accessor<DataT, number>;
+    /**
+     * After data objects are aggregated into cells, 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 cell.
+     * @default 1
+     */
+    getElevationWeight?: Accessor<DataT, number>;
+    /**
+     * After data objects are aggregated into cells, 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 bin color domain has been calculated.
+     * @default () => {}
+     */
+    onSetColorDomain?: (minMax: [number, number]) => void;
+    /**
+     * This callback will be called when bin elevation domain has been calculated.
+     * @default () => {}
+     */
+    onSetElevationDomain?: (minMax: [number, number]) => void;
+    /**
+     * (Experimental) Filter data objects
+     */
+    _filterData: null | ((d: DataT) => boolean);
+};
+export default class CPUGridLayer<DataT = any, ExtraPropsT = {}> extends AggregationLayer<ExtraPropsT & Required<_CPUGridLayerProps<DataT>>> {
+    static layerName: string;
+    static defaultProps: DefaultProps<CPUGridLayerProps<any>>;
+    initializeState(): void;
+    updateState(opts: UpdateParameters<this>): void;
+    getPickingInfo({ info }: GetPickingInfoParams): PickingInfo;
     _onGetSublayerColor(cell: any): any;
     _onGetSublayerElevation(cell: any): any;
     _getSublayerUpdateTriggers(): any;
+    renderLayers(): Layer;
 }
-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

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

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

@@ -1,3 +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";
+declare const _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

@@ -1 +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":""}
+{"version":3,"file":"gpu-grid-cell-layer-fragment.glsl.d.ts","sourceRoot":"","sources":["../../src/gpu-grid-layer/gpu-grid-cell-layer-fragment.glsl.ts"],"names":[],"mappings":";AAoBA,wBAcE"}

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

@@ -1,3 +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";
+declare const _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

@@ -1 +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":""}
+{"version":3,"file":"gpu-grid-cell-layer-vertex.glsl.d.ts","sourceRoot":"","sources":["../../src/gpu-grid-layer/gpu-grid-cell-layer-vertex.glsl.ts"],"names":[],"mappings":";AAsBA,wBAwHE"}