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

package/src/mask/{shader-module.js → shader-module.ts}

@@ -1,4 +1,6 @@
 import {project} from '@deck.gl/core';
+import type {_ShaderModule as ShaderModule} from '@deck.gl/core';
+import type {Texture2D} from '@luma.gl/webgl';
 
 const vs = `
 uniform vec4 mask_bounds;
@@ -60,12 +62,18 @@ varying vec2 mask_texCoords;
 `
 };
 
-const getMaskUniforms = (opts = {}) => {
-  const uniforms = {};
-  if (opts.maskMap) {
-    uniforms.mask_texture = opts.maskMap;
+type MaskModuleSettings = {
+  maskMap?: Texture2D;
+};
+
+/* eslint-disable camelcase */
+const getMaskUniforms = (opts?: MaskModuleSettings | {}): Record<string, any> => {
+  if (opts && 'maskMap' in opts) {
+    return {
+      mask_texture: opts.maskMap
+    };
   }
-  return uniforms;
+  return {};
 };
 
 export default {
@@ -75,4 +83,4 @@ export default {
   fs,
   inject,
   getUniforms: getMaskUniforms
-};
+} as ShaderModule<MaskModuleSettings>;

package/src/path-style/{path-style.js → path-style.ts}

@@ -22,6 +22,8 @@ import {LayerExtension, _mergeShaders as mergeShaders} from '@deck.gl/core';
 import {dashShaders, offsetShaders} from './shaders.glsl';
 import {dist} from 'gl-matrix/vec3';
 
+import type {Layer, LayerContext, Accessor, UpdateParameters} from '@deck.gl/core';
+
 const defaultProps = {
   getDashArray: {type: 'accessor', value: [0, 0]},
   getOffset: {type: 'accessor', value: 0},
@@ -29,16 +31,66 @@ const defaultProps = {
   dashGapPickable: false
 };
 
-export default class PathStyleExtension extends LayerExtension {
-  constructor({dash = false, offset = false, highPrecisionDash = false} = {}) {
+export type PathStyleExtensionProps<DataT = any> = {
+  /**
+   * Accessor for the dash array to draw each path with: `[dashSize, gapSize]` relative to the width of the path.
+   * Requires the `dash` option to be on.
+   */
+  getDashArray?: Accessor<DataT, [number, number]>;
+  /**
+   * Accessor for the offset to draw each path with, relative to the width of the path.
+   * Negative offset is to the left hand side, and positive offset is to the right hand side.
+   * @default 0
+   */
+  getOffset?: Accessor<DataT, number>;
+  /**
+   * If `true`, adjust gaps for the dashes to align at both ends.
+   * @default false
+   */
+  dashJustified?: boolean;
+  /**
+   * If `true`, gaps between solid strokes are pickable. If `false`, only the solid strokes are pickable.
+   * @default false
+   */
+  dashGapPickable?: boolean;
+};
+
+type PathStyleExtensionOptions = {
+  /**
+   * Add capability to render dashed lines.
+   * @default false
+   */
+  dash: boolean;
+  /**
+   * Add capability to offset lines.
+   * @default false
+   */
+  offset: boolean;
+  /**
+   * Improve dash rendering quality in certain circumstances. Note that this option introduces additional performance overhead.
+   * @default false
+   */
+  highPrecisionDash: boolean;
+};
+
+/** Adds selected features to the `PathLayer` and composite layers that render the `PathLayer`. */
+export default class PathStyleExtension extends LayerExtension<PathStyleExtensionOptions> {
+  static defaultProps = defaultProps;
+  static extensionName = 'PathStyleExtension';
+
+  constructor({
+    dash = false,
+    offset = false,
+    highPrecisionDash = false
+  }: Partial<PathStyleExtensionOptions> = {}) {
     super({dash: dash || highPrecisionDash, offset, highPrecisionDash});
   }
 
-  isEnabled(layer) {
-    return layer.state.pathTesselator;
+  isEnabled(layer: Layer<PathStyleExtensionProps>): boolean {
+    return 'pathTesselator' in layer.state;
   }
 
-  getShaders(extension) {
+  getShaders(this: Layer<PathStyleExtensionProps>, extension: this): any {
     if (!extension.isEnabled(this)) {
       return null;
     }
@@ -55,15 +107,13 @@ export default class PathStyleExtension extends LayerExtension {
     return result;
   }
 
-  initializeState(context, extension) {
+  initializeState(this: Layer<PathStyleExtensionProps>, context: LayerContext, extension: this) {
     const attributeManager = this.getAttributeManager();
     if (!attributeManager || !extension.isEnabled(this)) {
       // This extension only works with the PathLayer
       return;
     }
 
-    extension.enabled = true;
-
     if (extension.opts.dash) {
       attributeManager.addInstanced({
         instanceDashArrays: {size: 2, accessor: 'getDashArray'}
@@ -85,12 +135,16 @@ export default class PathStyleExtension extends LayerExtension {
     }
   }
 
-  updateState(params, extension) {
+  updateState(
+    this: Layer<PathStyleExtensionProps>,
+    params: UpdateParameters<Layer<PathStyleExtensionProps>>,
+    extension: this
+  ) {
     if (!extension.isEnabled(this)) {
       return;
     }
 
-    const uniforms = {};
+    const uniforms: any = {};
 
     if (extension.opts.dash) {
       uniforms.dashAlignMode = this.props.dashJustified ? 1 : 0;
@@ -100,7 +154,7 @@ export default class PathStyleExtension extends LayerExtension {
     this.state.model.setUniforms(uniforms);
   }
 
-  getDashOffsets(path) {
+  getDashOffsets(this: Layer<PathStyleExtensionProps>, path: number[] | number[][]): number[] {
     const result = [0];
     const positionSize = this.props.positionFormat === 'XY' ? 2 : 3;
     const isNested = Array.isArray(path[0]);
@@ -121,6 +175,3 @@ export default class PathStyleExtension extends LayerExtension {
     return result;
   }
 }
-
-PathStyleExtension.extensionName = 'PathStyleExtension';
-PathStyleExtension.defaultProps = defaultProps;

package/typed/brushing/brushing.d.ts

@@ -1,19 +1,40 @@
-declare class BrushingExtension extends LayerExtension {
-    useConstantTargetPositions(attribute: any): void;
-}
-declare namespace BrushingExtension {
-    export const extensionName: string;
-    export { defaultProps };
-}
-export default BrushingExtension;
 import { LayerExtension } from '@deck.gl/core/typed';
-declare namespace defaultProps {
-    namespace getBrushingTarget {
-        const type: string;
-        const value: number[];
-    }
-    const brushingTarget: string;
-    const brushingEnabled: boolean;
-    const brushingRadius: number;
+import type { Layer, LayerContext, Accessor } from '@deck.gl/core/typed';
+export declare type BrushingExtensionProps<DataT = any> = {
+    /**
+     * Called to retrieve an arbitrary position for each object that it will be filtered by.
+     * Only effective if `brushingTarget` is set to `custom`.
+     */
+    getBrushingTarget?: Accessor<DataT, [number, number]>;
+    /**
+     * Enable/disable brushing. If brushing is disabled, all objects are rendered.
+     * @default true
+     */
+    brushingEnabled?: boolean;
+    /**
+     * The position used to filter each object by.
+     */
+    brushingTarget?: 'source' | 'target' | 'source_target' | 'custom';
+    /** The brushing radius centered at the pointer, in meters. If a data object is within this circle, it is rendered; otherwise it is hidden.
+     * @default 10000
+     */
+    brushingRadius?: number;
+};
+/** Adds GPU-based data brushing functionalities to layers. It allows the layer to show/hide objects based on the current pointer position. */
+export default class BrushingExtension extends LayerExtension {
+    static defaultProps: {
+        getBrushingTarget: {
+            type: string;
+            value: number[];
+        };
+        brushingTarget: string;
+        brushingEnabled: boolean;
+        brushingRadius: number;
+    };
+    static extensionName: string;
+    getShaders(): any;
+    initializeState(this: Layer<BrushingExtensionProps>, context: LayerContext, extension: this): void;
+    finalizeState(this: Layer<BrushingExtensionProps>, context: LayerContext, extension: this): void;
+    useConstantTargetPositions(attribute: any): void;
 }
 //# sourceMappingURL=brushing.d.ts.map

package/typed/brushing/brushing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"brushing.d.ts","sourceRoot":"","sources":["../../src/brushing/brushing.js"],"names":[],"mappings":"AA+BA;IAoDE,iDAIC;CACF"}
+{"version":3,"file":"brushing.d.ts","sourceRoot":"","sources":["../../src/brushing/brushing.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAC,cAAc,EAAC,MAAM,eAAe,CAAC;AAG7C,OAAO,KAAK,EAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAC,MAAM,eAAe,CAAC;AAUjE,oBAAY,sBAAsB,CAAC,KAAK,GAAG,GAAG,IAAI;IAChD;;;OAGG;IACH,iBAAiB,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACtD;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;OAEG;IACH,cAAc,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,eAAe,GAAG,QAAQ,CAAC;IAClE;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,8IAA8I;AAC9I,MAAM,CAAC,OAAO,OAAO,iBAAkB,SAAQ,cAAc;IAC3D,MAAM,CAAC,YAAY;;;;;;;;MAAgB;IACnC,MAAM,CAAC,aAAa,SAAuB;IAE3C,UAAU,IAAI,GAAG;IAMjB,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,sBAAsB,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,IAAI;IAsC3F,aAAa,CAAC,IAAI,EAAE,KAAK,CAAC,sBAAsB,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,IAAI;IAWzF,0BAA0B,CAAC,SAAS,KAAA;CAKrC"}

package/typed/brushing/shader-module.d.ts

@@ -1,27 +1,12 @@
-declare namespace _default {
-    export const name: string;
-    export const dependencies: (typeof project)[];
-    export { vs };
-    export { fs };
-    export { inject };
-    export function getUniforms(opts: any): {
-        brushing_enabled?: undefined;
-        brushing_radius?: undefined;
-        brushing_target?: undefined;
-        brushing_mousePos?: undefined;
-    } | {
-        brushing_enabled: boolean;
-        brushing_radius: any;
-        brushing_target: any;
-        brushing_mousePos: any;
+import type { Viewport, _ShaderModule as ShaderModule } from '@deck.gl/core/typed';
+import type { BrushingExtensionProps } from './brushing';
+declare type BrushingModuleSettings = {
+    viewport: Viewport;
+    mousePosition?: {
+        x: number;
+        y: number;
     };
-}
+} & BrushingExtensionProps;
+declare const _default: ShaderModule<BrushingModuleSettings>;
 export default _default;
-import { project } from '@deck.gl/core/typed';
-declare const vs: "\n  uniform bool brushing_enabled;\n  uniform int brushing_target;\n  uniform vec2 brushing_mousePos;\n  uniform float brushing_radius;\n\n  #ifdef NON_INSTANCED_MODEL\n  attribute vec2 brushingTargets;\n  #else\n  attribute vec2 instanceBrushingTargets;\n  #endif\n\n  varying float brushing_isVisible;\n\n  bool brushing_isPointInRange(vec2 position) {\n    if (!brushing_enabled) {\n      return true;\n    }\n    vec2 source_commonspace = project_position(position);\n    vec2 target_commonspace = project_position(brushing_mousePos);\n    float distance = length((target_commonspace - source_commonspace) / project_uCommonUnitsPerMeter.xy);\n\n    return distance <= brushing_radius;\n  }\n\n  bool brushing_arePointsInRange(vec2 sourcePos, vec2 targetPos) {\n    return brushing_isPointInRange(sourcePos) || brushing_isPointInRange(targetPos);\n  }\n\n  void brushing_setVisible(bool visible) {\n    brushing_isVisible = float(visible);\n  }\n";
-declare const fs: "\n  uniform bool brushing_enabled;\n  varying float brushing_isVisible;\n";
-declare const inject: {
-    'vs:DECKGL_FILTER_GL_POSITION': string;
-    'fs:DECKGL_FILTER_COLOR': string;
-};
 //# sourceMappingURL=shader-module.d.ts.map

package/typed/brushing/shader-module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader-module.d.ts","sourceRoot":"","sources":["../../src/brushing/shader-module.js"],"names":[],"mappings":";;;;;;IA2Ge;;;;;;;;;;MAqBZ;;;;AA3GH,08BAgCE;AAEF,8FAGE;AASF;;;EAgCE"}
+{"version":3,"file":"shader-module.d.ts","sourceRoot":"","sources":["../../src/brushing/shader-module.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAC,QAAQ,EAAE,aAAa,IAAI,YAAY,EAAC,MAAM,eAAe,CAAC;AAE3E,OAAO,KAAK,EAAC,sBAAsB,EAAC,MAAM,YAAY,CAAC;AAEvD,aAAK,sBAAsB,GAAG;IAE5B,QAAQ,EAAE,QAAQ,CAAC;IACnB,aAAa,CAAC,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;CACxC,GAAG,sBAAsB,CAAC;;AAkF3B,wBA4B0C"}

package/typed/clip/clip.d.ts

@@ -1,12 +1,29 @@
-declare class ClipExtension extends LayerExtension {
-}
-declare namespace ClipExtension {
-    export const extensionName: string;
-    export { defaultProps };
-}
-export default ClipExtension;
-import { LayerExtension } from '@deck.gl/core/typed';
-declare namespace defaultProps {
-    const clipBounds: number[];
+import { LayerExtension, _ShaderModule as ShaderModule } from '@deck.gl/core/typed';
+import type { Layer } from '@deck.gl/core/typed';
+export declare type ClipExtensionProps = {
+    /** Rectangular bounds to be used for clipping the rendered region, in `[left, bottom, right, top]`.
+     * @default [0, 0, 1, 1]
+     */
+    clipBounds?: [number, number, number, number];
+    /**
+     * Controls whether an object is clipped by its anchor (e.g. icon, point) or by its geometry (e.g. path, polygon).
+     * If not specified, it is automatically deduced from the layer.
+     */
+    clipByInstance?: boolean;
+};
+/** Adds support for clipping rendered layers by rectangular bounds. */
+export default class ClipExtension extends LayerExtension {
+    static defaultProps: any;
+    static extensionName: string;
+    getShaders(this: Layer<ClipExtensionProps>): {
+        modules: ShaderModule<any>[];
+        inject: {
+            'vs:#decl': string;
+            'vs:DECKGL_FILTER_GL_POSITION': string;
+            'fs:#decl': string;
+            'fs:DECKGL_FILTER_COLOR': string;
+        };
+    };
+    draw(this: Layer<ClipExtensionProps>, { uniforms }: any): void;
 }
 //# sourceMappingURL=clip.d.ts.map

package/typed/clip/clip.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clip.d.ts","sourceRoot":"","sources":["../../src/clip/clip.js"],"names":[],"mappings":"AAkFA;CAwCC"}
+{"version":3,"file":"clip.d.ts","sourceRoot":"","sources":["../../src/clip/clip.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAC,cAAc,EAAE,aAAa,IAAI,YAAY,EAAC,MAAM,eAAe,CAAC;AAE5E,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,eAAe,CAAC;AAMzC,oBAAY,kBAAkB,GAAG;IAC/B;;OAEG;IACH,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AA0DF,uEAAuE;AACvE,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,cAAc;IACvD,MAAM,CAAC,YAAY,EAAE,GAAG,CAAgB;IACxC,MAAM,CAAC,aAAa,SAAmB;IAEvC,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,kBAAkB,CAAC;;;;;;;;;IAyB1C,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,kBAAkB,CAAC,EAAE,EAAC,QAAQ,EAAC,EAAE,GAAG,GAAG,IAAI;CAgB7D"}

package/typed/data-filter/aggregator.d.ts

@@ -1,10 +1,11 @@
-export function supportsFloatTarget(gl: any): any;
-export function getFramebuffer(gl: any, useFloatTarget: any): any;
-export function getModel(gl: any, shaderOptions: any, useFloatTarget: any): any;
-export namespace parameters {
-    const blend: boolean;
-    const blendFunc: number[];
-    const blendEquation: number[];
-    const depthTest: boolean;
-}
+import { Model, Framebuffer } from '@luma.gl/core';
+export declare function supportsFloatTarget(gl: WebGLRenderingContext): boolean;
+export declare function getFramebuffer(gl: WebGLRenderingContext, useFloatTarget: boolean): Framebuffer;
+export declare function getModel(gl: WebGLRenderingContext, shaderOptions: any, useFloatTarget: boolean): Model;
+export declare const parameters: {
+    blend: boolean;
+    blendFunc: number[];
+    blendEquation: number[];
+    depthTest: boolean;
+};
 //# sourceMappingURL=aggregator.d.ts.map

package/typed/data-filter/aggregator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregator.d.ts","sourceRoot":"","sources":["../../src/data-filter/aggregator.js"],"names":[],"mappings":"AAkDA,kDASC;AAGD,kEAmBC;AAGD,gFAeC"}
+{"version":3,"file":"aggregator.d.ts","sourceRoot":"","sources":["../../src/data-filter/aggregator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAa,WAAW,EAAW,MAAM,eAAe,CAAC;AAkDtE,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,qBAAqB,GAAG,OAAO,CAStE;AAGD,wBAAgB,cAAc,CAAC,EAAE,EAAE,qBAAqB,EAAE,cAAc,EAAE,OAAO,GAAG,WAAW,CAmB9F;AAGD,wBAAgB,QAAQ,CACtB,EAAE,EAAE,qBAAqB,EACzB,aAAa,EAAE,GAAG,EAClB,cAAc,EAAE,OAAO,GACtB,KAAK,CAeP;AAED,eAAO,MAAM,UAAU;;;;;CAKtB,CAAC"}

package/typed/data-filter/data-filter.d.ts

@@ -1,32 +1,90 @@
-declare class DataFilterExtension extends LayerExtension {
-    constructor({ filterSize, fp64, countItems }?: {
-        filterSize?: number | undefined;
-        fp64?: boolean | undefined;
-        countItems?: boolean | undefined;
-    });
-}
-declare namespace DataFilterExtension {
-    export const extensionName: string;
-    export { defaultProps };
-}
-export default DataFilterExtension;
 import { LayerExtension } from '@deck.gl/core/typed';
-declare namespace defaultProps {
-    namespace getFilterValue {
-        const type: string;
-        const value: number;
-    }
-    namespace onFilteredItemsChange {
-        const type_1: string;
-        export { type_1 as type };
-        const value_1: null;
-        export { value_1 as value };
-        export const compare: boolean;
-    }
-    const filterEnabled: boolean;
-    const filterRange: number[];
-    const filterSoftRange: null;
-    const filterTransformSize: boolean;
-    const filterTransformColor: boolean;
+import type { Layer, LayerContext, Accessor, UpdateParameters } from '@deck.gl/core/typed';
+export declare type DataFilterExtensionProps<DataT = any> = {
+    /**
+     * Accessor to retrieve the value for each object that it will be filtered by.
+     * Returns either a number (if `filterSize: 1`) or an array of numbers.
+     */
+    getFilterValue?: Accessor<DataT, number | number[]>;
+    /**
+     * Enable/disable the data filter. If the data filter is disabled, all objects are rendered.
+     * @default true
+     */
+    filterEnabled?: boolean;
+    /**
+     * The [min, max] bounds which defines whether an object should be rendered.
+     * If an object's filtered value is within the bounds, the object will be rendered; otherwise it will be hidden.
+     * @default [-1, 1]
+     */
+    filterRange?: [number, number] | [number, number][];
+    /**
+     * If specified, objects will be faded in/out instead of abruptly shown/hidden.
+     * When the filtered value is outside of the bounds defined by `filterSoftRange` but still within the bounds defined by `filterRange`, the object will be rendered as "faded."
+     * @default null
+     */
+    filterSoftRange?: [number, number] | [number, number][] | null;
+    /**
+     * When an object is "faded", manipulate its size so that it appears smaller or thinner. Only works if `filterSoftRange` is specified.
+     * @default true
+     */
+    filterTransformSize?: boolean;
+    /**
+     * When an object is "faded", manipulate its opacity so that it appears more translucent. Only works if `filterSoftRange` is specified.
+     * @default true
+     */
+    filterTransformColor?: boolean;
+    /**
+     * Only called if the `countItems` option is enabled.
+     */
+    onFilteredItemsChange?: (evt: {
+        /** The id of the source layer. */
+        id: string;
+        /** The number of data objects that pass the filter. */
+        count: number;
+    }) => void;
+};
+declare type DataFilterExtensionOptions = {
+    /**
+     * The size of the filter (number of columns to filter by). The data filter can show/hide data based on 1-4 numeric properties of each object.
+     * @default 1
+     */
+    filterSize: number;
+    /**
+     * Use 64-bit precision instead of 32-bit.
+     * @default false
+     */
+    fp64: boolean;
+    /**
+     * If `true`, reports the number of filtered objects with the `onFilteredItemsChange` callback.
+     * @default `false`.
+     */
+    countItems: boolean;
+};
+/** Adds GPU-based data filtering functionalities to layers. It allows the layer to show/hide objects based on user-defined properties. */
+export default class DataFilterExtension extends LayerExtension<DataFilterExtensionOptions> {
+    static defaultProps: {
+        getFilterValue: {
+            type: string;
+            value: number;
+        };
+        onFilteredItemsChange: {
+            type: string;
+            value: null;
+            compare: boolean;
+        };
+        filterEnabled: boolean;
+        filterRange: number[];
+        filterSoftRange: null;
+        filterTransformSize: boolean;
+        filterTransformColor: boolean;
+    };
+    static extensionName: string;
+    constructor({ filterSize, fp64, countItems }?: Partial<DataFilterExtensionOptions>);
+    getShaders(this: Layer<DataFilterExtensionProps>, extension: this): any;
+    initializeState(this: Layer<DataFilterExtensionProps>, context: LayerContext, extension: this): void;
+    updateState(this: Layer<DataFilterExtensionProps>, { props, oldProps }: UpdateParameters<Layer<DataFilterExtensionProps>>): void;
+    draw(this: Layer<DataFilterExtensionProps>, params: any, extension: this): void;
+    finalizeState(this: Layer<DataFilterExtensionProps>): void;
 }
+export {};
 //# sourceMappingURL=data-filter.d.ts.map

package/typed/data-filter/data-filter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-filter.d.ts","sourceRoot":"","sources":["../../src/data-filter/data-filter.js"],"names":[],"mappings":"AA4CA;IACE;;;;OAMC;CA6HF"}
+{"version":3,"file":"data-filter.d.ts","sourceRoot":"","sources":["../../src/data-filter/data-filter.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAC,cAAc,EAAC,MAAM,eAAe,CAAC;AAM7C,OAAO,KAAK,EAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,gBAAgB,EAAC,MAAM,eAAe,CAAC;AAanF,oBAAY,wBAAwB,CAAC,KAAK,GAAG,GAAG,IAAI;IAClD;;;OAGG;IACH,cAAc,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC,CAAC;IACpD;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IACpD;;;;OAIG;IACH,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,CAAC;IAC/D;;;OAGG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;OAGG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;OAEG;IACH,qBAAqB,CAAC,EAAE,CAAC,GAAG,EAAE;QAC5B,kCAAkC;QAClC,EAAE,EAAE,MAAM,CAAC;QACX,uDAAuD;QACvD,KAAK,EAAE,MAAM,CAAC;KACf,KAAK,IAAI,CAAC;CACZ,CAAC;AAEF,aAAK,0BAA0B,GAAG;IAChC;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,IAAI,EAAE,OAAO,CAAC;IACd;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AASF,0IAA0I;AAC1I,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,cAAc,CAAC,0BAA0B,CAAC;IACzF,MAAM,CAAC,YAAY;;;;;;;;;;;;;;;MAAgB;IACnC,MAAM,CAAC,aAAa,SAAyB;gBAEjC,EACV,UAAc,EACd,IAAY,EACZ,UAAkB,EACnB,GAAE,OAAO,CAAC,0BAA0B,CAAM;IAQ3C,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,wBAAwB,CAAC,EAAE,SAAS,EAAE,IAAI,GAAG,GAAG;IAYvE,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,wBAAwB,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,IAAI;IAyD7F,WAAW,CACT,IAAI,EAAE,KAAK,CAAC,wBAAwB,CAAC,EACrC,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAE,gBAAgB,CAAC,KAAK,CAAC,wBAAwB,CAAC,CAAC;IAgBtE,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,wBAAwB,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI;IAoCxE,aAAa,CAAC,IAAI,EAAE,KAAK,CAAC,wBAAwB,CAAC;CAQpD"}

package/typed/data-filter/shader-module.d.ts

@@ -1,26 +1,9 @@
-export namespace shaderModule {
-    export const name: string;
-    export { vs };
-    export { fs };
-    export { inject };
-    export { getUniforms };
-}
-export namespace shaderModule64 {
-    const name_1: string;
-    export { name_1 as name };
-    export { vs };
-    export { fs };
-    export { inject };
-    export { getUniforms64 as getUniforms };
-}
-declare const vs: "\nuniform DATAFILTER_TYPE filter_min;\nuniform DATAFILTER_TYPE filter_softMin;\nuniform DATAFILTER_TYPE filter_softMax;\nuniform DATAFILTER_TYPE filter_max;\nuniform bool filter_useSoftMargin;\nuniform bool filter_enabled;\nuniform bool filter_transformSize;\n\n#ifdef NON_INSTANCED_MODEL\n  #define DATAFILTER_ATTRIB filterValues\n  #define DATAFILTER_ATTRIB_64LOW filterValues64Low\n#else\n  #define DATAFILTER_ATTRIB instanceFilterValues\n  #define DATAFILTER_ATTRIB_64LOW instanceFilterValues64Low\n#endif\n\nattribute DATAFILTER_TYPE DATAFILTER_ATTRIB;\n#ifdef DATAFILTER_DOUBLE\n  attribute DATAFILTER_TYPE DATAFILTER_ATTRIB_64LOW;\n\n  uniform DATAFILTER_TYPE filter_min64High;\n  uniform DATAFILTER_TYPE filter_max64High;\n#endif\n\nvarying float dataFilter_value;\n\nfloat dataFilter_reduceValue(float value) {\n  return value;\n}\nfloat dataFilter_reduceValue(vec2 value) {\n  return min(value.x, value.y);\n}\nfloat dataFilter_reduceValue(vec3 value) {\n  return min(min(value.x, value.y), value.z);\n}\nfloat dataFilter_reduceValue(vec4 value) {\n  return min(min(value.x, value.y), min(value.z, value.w));\n}\nvoid dataFilter_setValue(DATAFILTER_TYPE valueFromMin, DATAFILTER_TYPE valueFromMax) {\n  if (filter_enabled) {\n    if (filter_useSoftMargin) {\n      dataFilter_value = dataFilter_reduceValue(\n        smoothstep(filter_min, filter_softMin, valueFromMin) *\n        (1.0 - smoothstep(filter_softMax, filter_max, valueFromMax))\n      );\n    } else {\n      dataFilter_value = dataFilter_reduceValue(\n        step(filter_min, valueFromMin) * step(valueFromMax, filter_max)\n      );\n    }\n  } else {\n    dataFilter_value = 1.0;\n  }\n}\n";
-declare const fs: "\nuniform bool filter_transformColor;\nvarying float dataFilter_value;\n";
-declare const inject: {
-    'vs:#main-start': string;
-    'vs:DECKGL_FILTER_SIZE': string;
-    'fs:DECKGL_FILTER_COLOR': string;
-};
-declare function getUniforms(opts: any): {};
-declare function getUniforms64(opts: any): {};
+import { _ShaderModule as ShaderModule } from '@deck.gl/core/typed';
+import type { DataFilterExtensionProps } from './data-filter';
+declare type DataFilterModuleSettings = {
+    extensions: any[];
+} & DataFilterExtensionProps;
+export declare const shaderModule: ShaderModule<DataFilterModuleSettings>;
+export declare const shaderModule64: ShaderModule<DataFilterModuleSettings>;
 export {};
 //# sourceMappingURL=shader-module.d.ts.map

package/typed/data-filter/shader-module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader-module.d.ts","sourceRoot":"","sources":["../../src/data-filter/shader-module.js"],"names":[],"mappings":";;;;;;;;;;;;;;;AAGA,upDAuDE;AAEF,6FAGE;AAgEF;;;;EAwBE;AAtFF,4CA+BC;AAED,8CA2BC"}
+{"version":3,"file":"shader-module.d.ts","sourceRoot":"","sources":["../../src/data-filter/shader-module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,IAAI,YAAY,EAAC,MAAM,qBAAqB,CAAC;AAElE,OAAO,KAAK,EAAC,wBAAwB,EAAC,MAAM,eAAe,CAAC;AAmE5D,aAAK,wBAAwB,GAAG;IAC9B,UAAU,EAAE,GAAG,EAAE,CAAC;CACnB,GAAG,wBAAwB,CAAC;AA2F7B,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,wBAAwB,CAM/D,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,wBAAwB,CAMjE,CAAC"}

package/typed/fill-style/fill-style.d.ts

@@ -1,44 +1,77 @@
-declare class FillStyleExtension extends LayerExtension {
-    constructor({ pattern }?: {
-        pattern?: boolean | undefined;
-    });
-    isEnabled(layer: any): any;
-    loadPatternAtlas({ fillPatternAtlas, fetch }: {
-        fillPatternAtlas: any;
-        fetch: any;
-    }): Promise<void>;
-    loadPatternMapping({ fillPatternMapping, fetch }: {
-        fillPatternMapping: any;
-        fetch: any;
-    }): Promise<void>;
-    getPatternFrame(name: any): any[];
-}
-declare namespace FillStyleExtension {
-    export const extensionName: string;
-    export { defaultProps };
-}
-export default FillStyleExtension;
 import { LayerExtension } from '@deck.gl/core/typed';
-declare namespace defaultProps {
-    const fillPatternEnabled: boolean;
-    const fillPatternAtlas: null;
-    const fillPatternMapping: null;
-    const fillPatternMask: boolean;
-    namespace getFillPattern {
-        const type: string;
-        function value(d: any): any;
-    }
-    namespace getFillPatternScale {
-        const type_1: string;
-        export { type_1 as type };
-        const value_1: number;
-        export { value_1 as value };
-    }
-    namespace getFillPatternOffset {
-        const type_2: string;
-        export { type_2 as type };
-        const value_2: number[];
-        export { value_2 as value };
-    }
+import type { Layer, LayerContext, Accessor, AccessorFunction, Texture, UpdateParameters } from '@deck.gl/core/typed';
+export declare type FillStyleExtensionProps<DataT = any> = {
+    /** Cheap toggle to enable/disable pattern fill. Requires the `pattern` option to be on.
+     * @default true
+     */
+    fillPatternEnabled?: boolean;
+    /** Sprite image url or texture that packs all your patterns into one layout. */
+    fillPatternAtlas?: Texture;
+    /** Pattern names mapped to pattern definitions, or a url that points to a JSON file. */
+    fillPatternMapping?: string | Record<string, {
+        /** Left position of the pattern on the atlas */
+        x: number;
+        /** Top position of the pattern on the atlas */
+        y: number;
+        /** Width of the pattern */
+        width: number;
+        /** Height of the pattern */
+        height: number;
+    }>;
+    /**
+     * Whether to treat the patterns as transparency masks.
+     * @default true
+     */
+    fillPatternMask?: boolean;
+    /** Accessor for the name of the pattern. */
+    getFillPattern?: AccessorFunction<DataT, string>;
+    /** Accessor for the scale of the pattern, relative to the original size. If the pattern is 24 x 24 pixels, scale `1` roughly yields 24 meters.
+     * @default 1
+     */
+    getFillPatternScale?: Accessor<DataT, number>;
+    /**
+     * Accessor for the offset of the pattern, relative to the original size. Offset `[0.5, 0.5]` shifts the pattern alignment by half.
+     * @default [0, 0]
+     */
+    getFillPatternOffset?: Accessor<DataT, [number, number]>;
+};
+declare type FillStyleExtensionOptions = {
+    /** If `true`, adds the ability to tile the filled area with a pattern.
+     * @default false
+     */
+    pattern: boolean;
+};
+/** Adds selected features to layers that render a "fill", such as the `PolygonLayer` and `ScatterplotLayer`. */
+export default class FillStyleExtension extends LayerExtension<FillStyleExtensionOptions> {
+    static defaultProps: {
+        fillPatternEnabled: boolean;
+        fillPatternAtlas: null;
+        fillPatternMapping: null;
+        fillPatternMask: boolean;
+        getFillPattern: {
+            type: string;
+            value: (d: any) => any;
+        };
+        getFillPatternScale: {
+            type: string;
+            value: number;
+        };
+        getFillPatternOffset: {
+            type: string;
+            value: number[];
+        };
+    };
+    static extensionName: string;
+    constructor({ pattern }?: Partial<FillStyleExtensionOptions>);
+    isEnabled(layer: Layer<FillStyleExtensionProps>): boolean;
+    getShaders(this: Layer<FillStyleExtensionProps>, extension: this): any;
+    initializeState(this: Layer<FillStyleExtensionProps>, context: LayerContext, extension: this): void;
+    updateState(this: Layer<FillStyleExtensionProps>, { props, oldProps }: UpdateParameters<Layer<FillStyleExtensionProps>>, extension: this): void;
+    draw(this: Layer<FillStyleExtensionProps>, params: any, extension: this): void;
+    finalizeState(this: Layer<FillStyleExtensionProps>): void;
+    loadPatternAtlas(this: Layer<FillStyleExtensionProps>): Promise<void>;
+    loadPatternMapping(this: Layer<FillStyleExtensionProps>): Promise<void>;
+    getPatternFrame(this: Layer<FillStyleExtensionProps>, name: string): any[];
 }
+export {};
 //# sourceMappingURL=fill-style.d.ts.map

package/typed/fill-style/fill-style.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fill-style.d.ts","sourceRoot":"","sources":["../../src/fill-style/fill-style.js"],"names":[],"mappings":"AAyBA;IACE;;OAEC;IAED,2BAEC;IAoGD;;;sBAeC;IAED;;;sBAYC;IAED,kCAIC;CACF;;;;;;;;;;;;;;QA7J2C,4BAAc"}
+{"version":3,"file":"fill-style.d.ts","sourceRoot":"","sources":["../../src/fill-style/fill-style.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAC,MAAM,eAAe,CAAC;AAM7C,OAAO,KAAK,EACV,KAAK,EACL,YAAY,EACZ,QAAQ,EACR,gBAAgB,EAChB,OAAO,EACP,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAYvB,oBAAY,uBAAuB,CAAC,KAAK,GAAG,GAAG,IAAI;IACjD;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,gFAAgF;IAChF,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,wFAAwF;IACxF,kBAAkB,CAAC,EACf,MAAM,GACN,MAAM,CACJ,MAAM,EACN;QACE,gDAAgD;QAChD,CAAC,EAAE,MAAM,CAAC;QACV,+CAA+C;QAC/C,CAAC,EAAE,MAAM,CAAC;QACV,2BAA2B;QAC3B,KAAK,EAAE,MAAM,CAAC;QACd,4BAA4B;QAC5B,MAAM,EAAE,MAAM,CAAC;KAChB,CACF,CAAC;IACN;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,4CAA4C;IAC5C,cAAc,CAAC,EAAE,gBAAgB,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACjD;;OAEG;IACH,mBAAmB,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAC9C;;;OAGG;IACH,oBAAoB,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC1D,CAAC;AAEF,aAAK,yBAAyB,GAAG;IAC/B;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAWF,gHAAgH;AAChH,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,cAAc,CAAC,yBAAyB,CAAC;IACvF,MAAM,CAAC,YAAY;;;;;;;;;;;;;;;;;MAAgB;IACnC,MAAM,CAAC,aAAa,SAAwB;gBAEhC,EAAC,OAAe,EAAC,GAAE,OAAO,CAAC,yBAAyB,CAAM;IAItE,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,uBAAuB,CAAC,GAAG,OAAO;IAIzD,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,uBAAuB,CAAC,EAAE,SAAS,EAAE,IAAI,GAAG,GAAG;IAUtE,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,uBAAuB,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,IAAI;IA0D5F,WAAW,CACT,IAAI,EAAE,KAAK,CAAC,uBAAuB,CAAC,EACpC,EAAC,KAAK,EAAE,QAAQ,EAAC,EAAE,gBAAgB,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC,EACnE,SAAS,EAAE,IAAI;IAcjB,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,uBAAuB,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI;IAWvE,aAAa,CAAC,IAAI,EAAE,KAAK,CAAC,uBAAuB,CAAC;IAM5C,gBAAgB,CAAC,IAAI,EAAE,KAAK,CAAC,uBAAuB,CAAC;IAkBrD,kBAAkB,CAAC,IAAI,EAAE,KAAK,CAAC,uBAAuB,CAAC;IAe7D,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,uBAAuB,CAAC,EAAE,IAAI,EAAE,MAAM;CAKnE"}