@deck.gl/extensions 8.8.0-alpha.5 → 8.8.0-beta.2

package/src/mask/shader-module.ts

@@ -0,0 +1,86 @@
+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;
+uniform bool mask_maskByInstance;
+vec2 mask_getCoords(vec4 position) {
+  return (position.xy - mask_bounds.xy) / (mask_bounds.zw - mask_bounds.xy);
+}
+`;
+
+const fs = `
+uniform sampler2D mask_texture;
+uniform int mask_channel;
+uniform bool mask_enabled;
+bool mask_isInBounds(vec2 texCoords) {
+  if (!mask_enabled) {
+    return true;
+  }
+  vec4 maskColor = texture2D(mask_texture, texCoords);
+  float maskValue = 1.0;
+  if (mask_channel == 0) {
+    maskValue = maskColor.r;
+  } else if (mask_channel == 1) {
+    maskValue = maskColor.g;
+  } else if (mask_channel == 2) {
+    maskValue = maskColor.b;
+  } else if (mask_channel == 3) {
+    maskValue = maskColor.a;
+  }
+  return maskValue < 0.5;
+}
+`;
+
+const inject = {
+  'vs:#decl': `
+varying vec2 mask_texCoords;
+`,
+  'vs:#main-end': `
+   vec4 mask_common_position;
+   if (mask_maskByInstance) {
+     mask_common_position = project_position(vec4(geometry.worldPosition, 1.0));
+   } else {
+     mask_common_position = geometry.position;
+   }
+   mask_texCoords = mask_getCoords(mask_common_position);
+`,
+  'fs:#decl': `
+varying vec2 mask_texCoords;
+`,
+  'fs:#main-start': `
+  if (mask_enabled) {
+    bool mask = mask_isInBounds(mask_texCoords);
+
+    // Debug: show extent of render target
+    // gl_FragColor = vec4(mask_texCoords, 0.0, 1.0);
+    gl_FragColor = texture2D(mask_texture, mask_texCoords);
+
+    if (!mask) discard;
+  }
+`
+};
+
+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 {};
+};
+
+export default {
+  name: 'mask',
+  dependencies: [project],
+  vs,
+  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/brushing.js

@@ -0,0 +1,83 @@
+// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+import { LayerExtension } from '@deck.gl/core';
+import shaderModule from './shader-module';
+const defaultProps = {
+    getBrushingTarget: { type: 'accessor', value: [0, 0] },
+    brushingTarget: 'source',
+    brushingEnabled: true,
+    brushingRadius: 10000
+};
+export default class BrushingExtension extends LayerExtension {
+    getShaders(extension) {
+        return {
+            modules: [shaderModule]
+        };
+    }
+    initializeState(context, extension) {
+        const attributeManager = this.getAttributeManager();
+        if (attributeManager) {
+            attributeManager.add({
+                brushingTargets: {
+                    size: 2,
+                    accessor: 'getBrushingTarget',
+                    // Hack: extension's defaultProps is not merged with the layer's defaultProps,
+                    // So we can't use the standard accessor when the prop is undefined
+                    update: !this.props.getBrushingTarget && extension.useConstantTargetPositions,
+                    shaderAttributes: {
+                        brushingTargets: {
+                            divisor: 0
+                        },
+                        instanceBrushingTargets: {
+                            divisor: 1
+                        }
+                    }
+                }
+            });
+        }
+        // Trigger redraw when mouse moves
+        // TODO - expose this in a better way
+        extension.onMouseMove = () => {
+            this.getCurrentLayer().setNeedsRedraw();
+        };
+        if (this.context.deck) {
+            this.context.deck.eventManager.on({
+                pointermove: extension.onMouseMove,
+                pointerleave: extension.onMouseMove
+            });
+        }
+    }
+    finalizeState(extension) {
+        // Remove event listeners
+        if (this.context.deck) {
+            this.context.deck.eventManager.off({
+                pointermove: extension.onMouseMove,
+                pointerleave: extension.onMouseMove
+            });
+        }
+    }
+    useConstantTargetPositions(attribute) {
+        attribute.constant = true;
+        attribute.value = new Float32Array(2);
+        return;
+    }
+}
+BrushingExtension.extensionName = 'BrushingExtension';
+BrushingExtension.defaultProps = defaultProps;

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/brushing/shader-module.js

@@ -0,0 +1,116 @@
+// Copyright (c) 2015-2017 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+import { project } from '@deck.gl/core';
+const vs = `
+  uniform bool brushing_enabled;
+  uniform int brushing_target;
+  uniform vec2 brushing_mousePos;
+  uniform float brushing_radius;
+
+  #ifdef NON_INSTANCED_MODEL
+  attribute vec2 brushingTargets;
+  #else
+  attribute vec2 instanceBrushingTargets;
+  #endif
+
+  varying float brushing_isVisible;
+
+  bool brushing_isPointInRange(vec2 position) {
+    if (!brushing_enabled) {
+      return true;
+    }
+    vec2 source_commonspace = project_position(position);
+    vec2 target_commonspace = project_position(brushing_mousePos);
+    float distance = length((target_commonspace - source_commonspace) / project_uCommonUnitsPerMeter.xy);
+
+    return distance <= brushing_radius;
+  }
+
+  bool brushing_arePointsInRange(vec2 sourcePos, vec2 targetPos) {
+    return brushing_isPointInRange(sourcePos) || brushing_isPointInRange(targetPos);
+  }
+
+  void brushing_setVisible(bool visible) {
+    brushing_isVisible = float(visible);
+  }
+`;
+const fs = `
+  uniform bool brushing_enabled;
+  varying float brushing_isVisible;
+`;
+const TARGET = {
+    source: 0,
+    target: 1,
+    custom: 2,
+    source_target: 3
+};
+const inject = {
+    'vs:DECKGL_FILTER_GL_POSITION': `
+    vec2 brushingTarget;
+    vec2 brushingSource;
+    if (brushing_target == 3) {
+      brushingTarget = geometry.worldPositionAlt.xy;
+      brushingSource = geometry.worldPosition.xy;
+    } else if (brushing_target == 0) {
+      brushingTarget = geometry.worldPosition.xy;
+    } else if (brushing_target == 1) {
+      brushingTarget = geometry.worldPositionAlt.xy;
+    } else {
+      #ifdef NON_INSTANCED_MODEL
+      brushingTarget = brushingTargets;
+      #else
+      brushingTarget = instanceBrushingTargets;
+      #endif
+    }
+    bool visible;
+    if (brushing_target == 3) {
+      visible = brushing_arePointsInRange(brushingSource, brushingTarget);
+    } else {
+      visible = brushing_isPointInRange(brushingTarget);
+    }
+    brushing_setVisible(visible);
+  `,
+    'fs:DECKGL_FILTER_COLOR': `
+    if (brushing_enabled && brushing_isVisible < 0.5) {
+      discard;
+    }
+  `
+};
+export default {
+    name: 'brushing',
+    dependencies: [project],
+    vs,
+    fs,
+    inject,
+    getUniforms: opts => {
+        if (!opts || !opts.viewport) {
+            return {};
+        }
+        const { brushingEnabled = true, brushingRadius = 10000, brushingTarget = 'source', mousePosition, viewport } = opts;
+        return {
+            brushing_enabled: Boolean(brushingEnabled && mousePosition && viewport.containsPixel(mousePosition)),
+            brushing_radius: brushingRadius,
+            brushing_target: TARGET[brushingTarget] || 0,
+            brushing_mousePos: mousePosition
+                ? viewport.unproject([mousePosition.x - viewport.x, mousePosition.y - viewport.y])
+                : [0, 0]
+        };
+    }
+};

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"}