@deck.gl/carto 9.0.16 → 9.0.18

package/package.json

@@ -3,7 +3,7 @@
   "description": "CARTO official integration with Deck.gl. Build geospatial applications using CARTO and Deck.gl.",
   "license": "MIT",
   "type": "module",
-  "version": "9.0.16",
+  "version": "9.0.18",
   "publishConfig": {
     "access": "public"
   },
@@ -73,5 +73,5 @@
     "@deck.gl/layers": "^9.0.0",
     "@loaders.gl/core": "^4.2.0"
   },
-  "gitHead": "87e1629767fae5167a43dc9fa04786a16879f7aa"
+  "gitHead": "32f7e51eb96319739a18a3ca22092e60948fcbdb"
 }

package/src/api/carto-api-error.ts

@@ -16,7 +16,15 @@ export class CartoAPIError extends Error {
   /** Response from server */
   response?: Response;
 
-  constructor(error: Error, errorContext: APIErrorContext, response?: Response) {
+  /** JSON Response from server */
+  responseJson?: any;
+
+  constructor(
+    error: Error,
+    errorContext: APIErrorContext,
+    response?: Response,
+    responseJson?: any
+  ) {
     let responseString = 'Failed to connect';
     if (response) {
       responseString = 'Server returned: ';
@@ -46,6 +54,7 @@ export class CartoAPIError extends Error {
 
     this.name = 'CartoAPIError';
     this.response = response;
+    this.responseJson = responseJson;
     this.error = error;
     this.errorContext = errorContext;
   }

package/src/api/common.ts

@@ -1,16 +1,4 @@
-import {VERSION} from '@deck.gl/core';
-
 export const DEFAULT_API_BASE_URL = 'https://gcp-us-east1.api.carto.com';
 export const DEFAULT_CLIENT = 'deck-gl-carto';
 export const V3_MINOR_VERSION = '3.4';
 export const MAX_GET_LENGTH = 8192;
-
-export const DEFAULT_PARAMETERS = {
-  v: V3_MINOR_VERSION,
-  deckglVersion: VERSION
-};
-
-export const DEFAULT_HEADERS = {
-  Accept: 'application/json',
-  'Content-Type': 'application/json'
-};

package/src/api/request-with-parameters.ts

@@ -1,37 +1,45 @@
+import {VERSION} from '@deck.gl/core';
 import {isPureObject} from '../utils';
 import {CartoAPIError} from './carto-api-error';
-import {DEFAULT_HEADERS, DEFAULT_PARAMETERS, MAX_GET_LENGTH} from './common';
+import {MAX_GET_LENGTH, V3_MINOR_VERSION} from './common';
 import type {APIErrorContext} from './types';
 
 /**
- * Simple encode parameter
+ * Parameters added to all requests issued with `requestWithParameters()`.
+ * These parameters override parameters already in the base URL, but not
+ * user-provided parameters.
  */
-function encodeParameter(name: string, value: unknown): string {
-  if (isPureObject(value) || Array.isArray(value)) {
-    return `${name}=${encodeURIComponent(JSON.stringify(value))}`;
-  }
-  return `${name}=${encodeURIComponent(value as string | boolean | number)}`;
-}
+const DEFAULT_PARAMETERS = {
+  v: V3_MINOR_VERSION,
+  deckglVersion: VERSION
+};
+
+const DEFAULT_HEADERS = {
+  Accept: 'application/json',
+  'Content-Type': 'application/json'
+};
 
 const REQUEST_CACHE = new Map<string, Promise<unknown>>();
+
 export async function requestWithParameters<T = any>({
   baseUrl,
-  parameters,
-  headers: customHeaders,
+  parameters = {},
+  headers: customHeaders = {},
   errorContext
 }: {
   baseUrl: string;
   parameters?: Record<string, unknown>;
-  headers: Record<string, string>;
+  headers?: Record<string, string>;
   errorContext: APIErrorContext;
 }): Promise<T> {
   parameters = {...DEFAULT_PARAMETERS, ...parameters};
-  const key = createCacheKey(baseUrl, parameters || {}, customHeaders || {});
+  baseUrl = excludeURLParameters(baseUrl, Object.keys(parameters));
+  const key = createCacheKey(baseUrl, parameters, customHeaders);
   if (REQUEST_CACHE.has(key)) {
     return REQUEST_CACHE.get(key) as Promise<T>;
   }
 
-  const url = parameters ? createURLWithParameters(baseUrl, parameters) : baseUrl;
+  const url = createURLWithParameters(baseUrl, parameters);
   const headers = {...DEFAULT_HEADERS, ...customHeaders};
 
   /* global fetch */
@@ -41,12 +49,14 @@ export async function requestWithParameters<T = any>({
       : fetch(url, {headers});
 
   let response: Response | undefined;
+  let responseJson;
   const jsonPromise: Promise<T> = fetchPromise
     .then((_response: Response) => {
       response = _response;
       return response.json();
     })
     .then((json: any) => {
+      responseJson = json;
       if (!response || !response.ok) {
         throw new Error(json.error);
       }
@@ -54,7 +64,7 @@ export async function requestWithParameters<T = any>({
     })
     .catch((error: Error) => {
       REQUEST_CACHE.delete(key);
-      throw new CartoAPIError(error, errorContext, response);
+      throw new CartoAPIError(error, errorContext, response, responseJson);
     });
 
   REQUEST_CACHE.set(key, jsonPromise);
@@ -71,9 +81,35 @@ function createCacheKey(
   return JSON.stringify({baseUrl, parameters: parameterEntries, headers: headerEntries});
 }
 
-function createURLWithParameters(baseUrl: string, parameters: Record<string, unknown>): string {
-  const encodedParameters = Object.entries(parameters).map(([key, value]) =>
-    encodeParameter(key, value)
-  );
-  return `${baseUrl}?${encodedParameters.join('&')}`;
+/**
+ * Appends query string parameters to a URL. Existing URL parameters are kept,
+ * unless there is a conflict, in which case the new parameters override
+ * those already in the URL.
+ */
+function createURLWithParameters(
+  baseUrlString: string,
+  parameters: Record<string, unknown>
+): string {
+  const baseUrl = new URL(baseUrlString);
+  for (const [key, value] of Object.entries(parameters)) {
+    if (isPureObject(value) || Array.isArray(value)) {
+      baseUrl.searchParams.set(key, JSON.stringify(value));
+    } else {
+      baseUrl.searchParams.set(key, (value as string | boolean | number).toString());
+    }
+  }
+  return baseUrl.toString();
+}
+
+/**
+ * Deletes query string parameters from a URL.
+ */
+function excludeURLParameters(baseUrlString: string, parameters: string[]) {
+  const baseUrl = new URL(baseUrlString);
+  for (const param of parameters) {
+    if (baseUrl.searchParams.has(param)) {
+      baseUrl.searchParams.delete(param);
+    }
+  }
+  return baseUrl.toString();
 }

package/src/api/types.ts

@@ -66,11 +66,11 @@ export interface Filters {
 }
 
 interface Filter {
-  [FilterTypes.In]: number[];
-  [FilterTypes.Between]: number[][];
-  [FilterTypes.ClosedOpen]: number[][];
-  [FilterTypes.Time]: number[][];
-  [FilterTypes.StringSearch]: string[];
+  [FilterTypes.In]?: number[];
+  [FilterTypes.Between]?: number[][];
+  [FilterTypes.ClosedOpen]?: number[][];
+  [FilterTypes.Time]?: number[][];
+  [FilterTypes.StringSearch]?: string[];
 }
 
 export enum FilterTypes {

package/src/index.ts

@@ -1,23 +1,23 @@
 import {default as H3TileLayer} from './layers/h3-tile-layer';
+import {default as HeatmapTileLayer} from './layers/heatmap-tile-layer';
 import {default as _PointLabelLayer} from './layers/point-label-layer';
 import {default as QuadbinTileLayer} from './layers/quadbin-tile-layer';
-import {default as QuadbinHeatmapTileLayer} from './layers/quadbin-heatmap-tile-layer';
 import {default as RasterTileLayer} from './layers/raster-tile-layer';
 import {default as VectorTileLayer} from './layers/vector-tile-layer';
 const CARTO_LAYERS = {
   H3TileLayer,
+  HeatmapTileLayer,
   _PointLabelLayer,
   QuadbinTileLayer,
-  QuadbinHeatmapTileLayer,
   RasterTileLayer,
   VectorTileLayer
 };
 export {
   CARTO_LAYERS,
   H3TileLayer,
+  HeatmapTileLayer,
   _PointLabelLayer,
   QuadbinTileLayer,
-  QuadbinHeatmapTileLayer,
   RasterTileLayer,
   VectorTileLayer
 };

package/src/layers/heatmap-tile-layer.ts

@@ -0,0 +1,236 @@
+import {getResolution} from 'quadbin';
+
+import {Accessor, CompositeLayer, CompositeLayerProps, DefaultProps, Layer} from '@deck.gl/core';
+import {SolidPolygonLayer} from '@deck.gl/layers';
+
+import {HeatmapProps, heatmap} from './heatmap';
+import {RTTModifier, PostProcessModifier} from './post-process-utils';
+import QuadbinTileLayer, {QuadbinTileLayerProps} from './quadbin-tile-layer';
+import {TilejsonPropType} from './utils';
+import {TilejsonResult} from '../sources';
+import {_Tile2DHeader as Tile2DHeader} from '@deck.gl/geo-layers';
+
+/**
+ * Computes the unit density (inverse of cell area)
+ */
+function unitDensityForCell(cell: bigint) {
+  const cellResolution = Number(getResolution(cell));
+  return Math.pow(4.0, cellResolution);
+}
+
+// Modified polygon layer to draw offscreen and output value expected by heatmap
+class RTTSolidPolygonLayer extends RTTModifier(SolidPolygonLayer) {
+  static layerName = 'RTTSolidPolygonLayer';
+
+  getShaders(type) {
+    const shaders = super.getShaders(type);
+    shaders.inject = {
+      'vs:#decl': `
+uniform float densityFactor;
+`,
+      'vs:#main-end': `
+      // Value from getWeight accessor
+  float weight = elevations;
+
+  // Keep "power" delivered to screen constant when tiles update
+  // by outputting normalized density 
+  weight *= densityFactor;
+
+  // Pack float into 3 channels to pass to heatmap shader
+  // SCALE value important, as we don't want to saturate
+  // but also want enough definition to avoid banding
+  const vec3 SHIFT = vec3(1.0, 256.0, 256.0 * 256.0);
+  const float MAX_VAL = SHIFT.z * 255.0;
+  const float SCALE = MAX_VAL / 8.0;
+  weight *= SCALE;
+  weight = clamp(weight, 0.0, MAX_VAL);
+  vColor = vec4(mod(vec3(weight, floor(weight / SHIFT.yz)), 256.0), 255.0) / 255.0;
+`
+    };
+    return shaders;
+  }
+
+  draw(this, opts: any) {
+    const cell = this.props!.data[0];
+    const maxDensity = this.props.elevationScale;
+    const densityFactor = unitDensityForCell(cell.id) / maxDensity;
+    for (const model of this.state.models) {
+      model.setUniforms({densityFactor});
+    }
+
+    super.draw(opts);
+  }
+}
+
+// Modify QuadbinTileLayer to apply heatmap post process effect
+const PostProcessQuadbinTileLayer = PostProcessModifier(QuadbinTileLayer, heatmap);
+
+const defaultProps: DefaultProps<HeatmapTileLayerProps> = {
+  data: TilejsonPropType,
+  getWeight: {type: 'accessor', value: 1},
+  onMaxDensityChange: {type: 'function', optional: true, value: null},
+  colorDomain: {type: 'array', value: [0, 1]},
+  intensity: {type: 'number', value: 1},
+  radiusPixels: {type: 'number', min: 0, max: 100, value: 20}
+};
+
+/** All properties supported by HeatmapTileLayer. */
+export type HeatmapTileLayerProps<DataT = unknown> = _HeatmapTileLayerProps<DataT> &
+  CompositeLayerProps & {
+    data: null | TilejsonResult | Promise<TilejsonResult>;
+  };
+
+/** Properties added by HeatmapTileLayer. */
+type _HeatmapTileLayerProps<DataT> = QuadbinTileLayerProps<DataT> &
+  HeatmapProps & {
+    /**
+     * The weight of each object.
+     *
+     * @default 1
+     */
+    getWeight?: Accessor<DataT, number>;
+
+    /** Called when maximum density in displayed tiles changes. */
+    onMaxDensityChange?: ((maxDensity: number) => void) | null;
+  };
+
+class HeatmapTileLayer<DataT = any, ExtraProps extends {} = {}> extends CompositeLayer<
+  ExtraProps & Required<_HeatmapTileLayerProps<DataT>>
+> {
+  static layerName = 'HeatmapTileLayer';
+  static defaultProps = defaultProps;
+
+  state!: {
+    isLoaded: boolean;
+    tiles: Set<Tile2DHeader>;
+    viewportChanged?: boolean;
+  };
+  initializeState() {
+    this.state = {
+      isLoaded: false,
+      tiles: new Set(),
+      viewportChanged: false
+    };
+  }
+
+  shouldUpdateState({changeFlags}): boolean {
+    const {viewportChanged} = changeFlags;
+    this.setState({viewportChanged});
+    return changeFlags.somethingChanged;
+  }
+
+  renderLayers(): Layer {
+    const {
+      data,
+      getWeight,
+      colorDomain,
+      colorRange,
+      intensity,
+      radiusPixels,
+      _subLayerProps,
+      updateTriggers,
+      onMaxDensityChange,
+      onViewportLoad,
+      onTileLoad,
+      onTileUnload,
+      ...tileLayerProps
+    } = this.props;
+
+    // Inject modified polygon layer as sublayer into TileLayer
+    const subLayerProps = {
+      ..._subLayerProps,
+      cell: {
+        ..._subLayerProps?.cell,
+        _subLayerProps: {
+          ..._subLayerProps?.cell?._subLayerProps,
+          fill: {
+            ..._subLayerProps?.cell?._subLayerProps?.fill,
+            type: RTTSolidPolygonLayer
+          }
+        }
+      }
+    };
+
+    let tileZ = 0;
+    let maxDensity = 0;
+    const tiles = [...this.state.tiles].filter(t => t.isVisible && t.data);
+    for (const tile of tiles) {
+      const cell = tile.data[0];
+      const unitDensity = unitDensityForCell(cell.id);
+      maxDensity = Math.max(tile.userData!.maxWeight * unitDensity, maxDensity);
+      tileZ = Math.max(tile.zoom, tileZ);
+    }
+
+    // Between zoom levels the max density will change, but it isn't possible to know by what factor. Uniform data distributions lead to a factor of 4, while very localized data gives 1. As a heurstic estimate with a value inbetween (2) to make the transitions less obvious.
+    const overzoom = this.context.viewport.zoom - tileZ;
+    const estimatedMaxDensity = maxDensity * Math.pow(2, overzoom);
+
+    maxDensity = estimatedMaxDensity;
+    if (typeof onMaxDensityChange === 'function') {
+      onMaxDensityChange(maxDensity);
+    }
+    return new PostProcessQuadbinTileLayer(
+      tileLayerProps as Omit<QuadbinTileLayerProps, 'data'>,
+      this.getSubLayerProps({
+        id: 'heatmap',
+        data,
+
+        // Re-use existing props to pass down values to sublayer
+        // TODO replace with custom layer
+        getFillColor: 0,
+        getElevation: getWeight,
+        elevationScale: maxDensity,
+
+        colorDomain,
+
+        colorRange,
+        radiusPixels,
+        intensity,
+        _subLayerProps: subLayerProps,
+        refinementStrategy: 'no-overlap',
+
+        // Disable line rendering
+        extruded: false,
+        stroked: false,
+
+        updateTriggers: {
+          getElevation: updateTriggers.getWeight
+        },
+
+        // Tile stats
+        onViewportLoad: tiles => {
+          this.setState({isLoaded: true});
+          if (typeof onViewportLoad === 'function') {
+            onViewportLoad(tiles);
+          }
+        },
+        onTileLoad: (tile: Tile2DHeader) => {
+          let maxWeight = -Infinity;
+          if (typeof getWeight !== 'function') {
+            maxWeight = getWeight;
+          } else if (tile.content) {
+            for (const d of tile.content) {
+              maxWeight = Math.max(getWeight(d, {} as any), maxWeight);
+            }
+          }
+          tile.userData = {maxWeight};
+
+          this.state.tiles.add(tile);
+
+          if (typeof onTileLoad === 'function') {
+            onTileLoad(tile);
+          }
+        },
+        onTileUnload: (tile: Tile2DHeader) => {
+          this.state.tiles.delete(tile);
+          if (typeof onTileUnload === 'function') {
+            onTileUnload(tile);
+          }
+        },
+        transitions: {elevationScale: {type: 'spring', stiffness: 0.3, damping: 0.5}}
+      })
+    );
+  }
+}
+
+export default HeatmapTileLayer;

package/src/layers/heatmap.ts

@@ -1,5 +1,4 @@
 import type {ShaderPass} from '@luma.gl/shadertools';
-import {random} from '@luma.gl/shadertools';
 import {Color} from '@deck.gl/core';
 const glsl = (s: TemplateStringsArray) => `${s}`;
 
@@ -21,11 +20,10 @@ uniform heatmapUniforms {
   vec3 color4;
   vec3 color5;
   vec3 color6;
+  float intensity;
   float opacity;
 } heatmap;
 
-// Controls quality of heatmap, larger values increase quality at expense of performance
-const float SUPPORT = 8.0;
 const vec4 STOPS = vec4(0.2, 0.4, 0.6, 0.8);
 
 vec3 colorGradient(float value) {
@@ -44,20 +42,18 @@ vec3 colorGradient(float value) {
   } else if (value < STOPS.w) {
     range = STOPS.zw;
     c1 = heatmap.color4; c2 = heatmap.color5;
-  } else if (value < 1.0 ) {
+  } else {
     range = vec2(STOPS.w, 1.0);
     c1 = heatmap.color5; c2 = heatmap.color6;
-  } else {
-    // Fade out to white
-    range = vec2(1.0, 10.0);
-    c1 = heatmap.color6; c2 = vec3(255.0);
   }
 
-  float f = (value - range.x) / (range.y - range.x);
+  float f = (clamp(value, 0.0, 1.0) - range.x) / (range.y - range.x);
   return mix(c1, c2, f) / 255.0;
 }
 
 const vec3 SHIFT = vec3(1.0, 256.0, 256.0 * 256.0);
+const float MAX_VAL = SHIFT.z * 255.0;
+const float SCALE = MAX_VAL / 8.0;
 vec4 pack(float value) {
   return vec4(mod(vec3(value, floor(value / SHIFT.yz)), 256.0), 255.0) / 255.0;
 }
@@ -69,16 +65,15 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   bool firstPass = (heatmap.delta.y < 0.5);
   float accumulator = 0.0;
 
-  // Randomize the lookup values to hide the fixed number of samples
-  float offset = 0.5 * random(vec3(12.9898, 78.233, 151.7182), 0.0);
+  // Controls quality of heatmap, larger values increase quality at expense of performance
+  float SUPPORT = clamp(heatmap.radiusPixels / 2.0, 8.0, 32.0);
 
   // Gaussian normalization parameters
-  const float sigma = SUPPORT / 3.0;
-  const float a = -0.5 / (sigma * sigma);
-  const float w0 = 0.3989422804014327 / sigma; // 1D normalization
-
+  float sigma = SUPPORT / 3.0;
+  float a = -0.5 / (sigma * sigma);
+  float w0 = 0.3989422804014327 / sigma; // 1D normalization
   for (float t = -SUPPORT; t <= SUPPORT; t++) {
-    vec2 percent = (t * heatmap.delta + offset - 0.5) / SUPPORT;
+    vec2 percent = (t * heatmap.delta - 0.5) / SUPPORT;
     vec2 delta = percent * heatmap.radiusPixels / texSize;
     vec4 offsetColor = texture(source, texCoord + delta);
 
@@ -95,8 +90,18 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
     return pack(accumulator);
   }
 
+  // Undo scaling to obtain normalized density
+  float density = 10.0 * heatmap.intensity * accumulator / SCALE;
+ 
+  // Domain also in normalized density units
+  vec2 domain = heatmap.colorDomain;
+
   // Apply domain
-  float f = (accumulator - heatmap.colorDomain[0]) / (heatmap.colorDomain[1] - heatmap.colorDomain[0]);
+  float f = (density - domain[0]) / (domain[1] - domain[0]);
+
+  // sqrt/log scaling??
+  // float f = (log(density) - log(domain[0] + 1.0)) / (log(domain[1] + 1.0) - log(domain[0] + 1.0));
+  // f = sqrt(f);
 
   // Color map
   vec4 color = vec4(0.0);
@@ -138,6 +143,10 @@ export type HeatmapProps = {
    * @default `6-class YlOrRd` - [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6)
    */
   colorRange: Color[];
+  /**
+   * Value that is multiplied with the total weight at a pixel to obtain the final weight. A value larger than 1 biases the output color towards the higher end of the spectrum, and a value less than 1 biases the output color towards the lower end of the spectrum.
+   */
+  intensity?: number;
   opacity: number;
 };
 
@@ -151,6 +160,7 @@ export type HeatmapUniforms = {
   color4?: [number, number, number];
   color5?: [number, number, number];
   color6?: [number, number, number];
+  intensity: number;
   opacity?: number;
 };
 
@@ -166,6 +176,7 @@ export const heatmap: ShaderPass<HeatmapProps, HeatmapUniforms> = {
     color4: {value: [0, 0, 0]},
     color5: {value: [0, 0, 0]},
     color6: {value: [0, 0, 0]},
+    intensity: {value: 1, min: 0.1, max: 10},
     opacity: {value: 1, min: 0, max: 1}
   },
   uniformTypes: {
@@ -178,6 +189,7 @@ export const heatmap: ShaderPass<HeatmapProps, HeatmapUniforms> = {
     color4: 'vec3<f32>',
     color5: 'vec3<f32>',
     color6: 'vec3<f32>',
+    intensity: 'f32',
     opacity: 'f32'
   },
   getUniforms: opts => {
@@ -186,6 +198,7 @@ export const heatmap: ShaderPass<HeatmapProps, HeatmapUniforms> = {
       colorRange = defaultColorRange,
       radiusPixels = 20,
       colorDomain = [0, 1],
+      intensity = 1,
       opacity = 1
     } = opts as HeatmapProps & {delta: [number, number]};
     const [color1, color2, color3, color4, color5, color6] = colorRange;
@@ -199,10 +212,10 @@ export const heatmap: ShaderPass<HeatmapProps, HeatmapUniforms> = {
       color6,
       radiusPixels,
       colorDomain,
+      intensity,
       opacity
     };
   },
-  dependencies: [random],
   fs,
   passes: [
     {sampler: true, uniforms: {delta: [1, 0]}},

package/src/layers/vector-tile-layer.ts

@@ -14,9 +14,6 @@ import {
   _TileLoadProps as TileLoadProps
 } from '@deck.gl/geo-layers';
 import {GeoJsonLayer} from '@deck.gl/layers';
-import {binaryToGeojson} from '@loaders.gl/gis';
-import type {BinaryFeatureCollection} from '@loaders.gl/schema';
-import type {Feature, Geometry} from 'geojson';
 
 import type {TilejsonResult} from '../sources/types';
 import {TilejsonPropType, injectAccessToken, mergeBoundaryData} from './utils';
@@ -148,16 +145,9 @@ export default class VectorTileLayer<
     return subLayer;
   }
 
-  getPickingInfo(params) {
-    const info = super.getPickingInfo(params);
-
-    if (this.state.binary && info.index !== -1) {
-      const {data} = params.sourceLayer!.props;
-      info.object = binaryToGeojson(data as BinaryFeatureCollection, {
-        globalFeatureId: info.index
-      }) as Feature<Geometry, FeaturePropertiesT>;
-    }
-
-    return info;
+  protected override _isWGS84(): boolean {
+    // CARTO binary tile coordinates are [lng, lat], not tile-relative like MVT.
+    if (this.state.mvt) return super._isWGS84();
+    return true;
   }
 }

package/src/sources/raster-source.ts

@@ -1,12 +1,17 @@
 import {baseSource} from './base-source';
-import type {SourceOptions, TilejsonResult, TilesetSourceOptions} from './types';
+import type {FilterOptions, SourceOptions, TilejsonResult, TilesetSourceOptions} from './types';
 
-export type RasterSourceOptions = SourceOptions & TilesetSourceOptions;
-type UrlParameters = {name: string};
+export type RasterSourceOptions = SourceOptions & TilesetSourceOptions & FilterOptions;
+type UrlParameters = {
+  name: string;
+  filters?: Record<string, unknown>;
+};
 
 export const rasterSource = async function (options: RasterSourceOptions): Promise<TilejsonResult> {
-  const {tableName} = options;
+  const {tableName, filters} = options;
   const urlParameters: UrlParameters = {name: tableName};
-
+  if (filters) {
+    urlParameters.filters = filters;
+  }
   return baseSource<UrlParameters>('raster', options, urlParameters) as Promise<TilejsonResult>;
 };

package/dist/layers/quadbin-heatmap-tile-layer.d.ts

@@ -1,24 +0,0 @@
-import { Accessor, CompositeLayer, CompositeLayerProps, DefaultProps, Layer } from '@deck.gl/core';
-import { HeatmapProps } from "./heatmap.js";
-import { QuadbinTileLayerProps } from "./quadbin-tile-layer.js";
-import { TilejsonResult } from "../sources.js";
-/** All properties supported by QuadbinHeatmapTileLayer. */
-export type QuadbinHeatmapTileLayerProps<DataT = unknown> = _QuadbinHeatmapTileLayerProps<DataT> & CompositeLayerProps & {
-    data: null | TilejsonResult | Promise<TilejsonResult>;
-};
-/** Properties added by QuadbinHeatmapTileLayer. */
-type _QuadbinHeatmapTileLayerProps<DataT> = QuadbinTileLayerProps<DataT> & HeatmapProps & {
-    /**
-     * The weight of each object.
-     *
-     * @default 1
-     */
-    getWeight?: Accessor<DataT, number>;
-};
-declare class QuadbinHeatmapTileLayer<DataT = any, ExtraProps extends {} = {}> extends CompositeLayer<ExtraProps & Required<_QuadbinHeatmapTileLayerProps<DataT>>> {
-    static layerName: string;
-    static defaultProps: DefaultProps<QuadbinHeatmapTileLayerProps<unknown>>;
-    renderLayers(): Layer;
-}
-export default QuadbinHeatmapTileLayer;
-//# sourceMappingURL=quadbin-heatmap-tile-layer.d.ts.map