@carto/api-client 0.4.1-alpha.0 → 0.4.1-alpha.1

package/build/models/model.d.ts

@@ -1,7 +1,6 @@
 import { Filter, FilterLogicalOperator, MapType, QueryParameters, SpatialFilter } from '../types.js';
 import { ModelRequestOptions } from './common.js';
 import { ApiVersion } from '../constants.js';
-import { SpatialDataType, SpatialFilterPolyfillMode } from '../sources/types.js';
 /** @internalRemarks Source: @carto/react-api */
 declare const AVAILABLE_MODELS: readonly ["category", "histogram", "formula", "pick", "timeseries", "range", "scatterplot", "table"];
 export type Model = (typeof AVAILABLE_MODELS)[number];
@@ -15,14 +14,9 @@ export interface ModelSource {
     data: string;
     filters?: Record<string, Filter>;
     filtersLogicalOperator?: FilterLogicalOperator;
+    geoColumn?: string;
     spatialFilter?: SpatialFilter;
     queryParameters?: QueryParameters;
-    spatialDataColumn?: string;
-    spatialDataType?: SpatialDataType;
-    spatialFiltersResolution?: number;
-    spatialFiltersMode?: SpatialFilterPolyfillMode;
-    /** original resolution of the spatial index data as stored in the DW */
-    dataResolution?: number;
 }
 /**
  * Execute a SQL model request.

package/build/sources/index.d.ts

@@ -1,5 +1,5 @@
 export { SOURCE_DEFAULTS } from './base-source';
-export type { TilejsonResult, GeojsonResult, JsonResult, QueryResult, } from './types';
+export type { VectorLayer, RasterMetadataBandStats, RasterBandColorinterp, RasterMetadataBand, RasterMetadata, TilejsonResult, GeojsonResult, JsonResult, QueryResult, } from './types';
 export { boundaryQuerySource } from './boundary-query-source';
 export type { BoundaryQuerySourceOptions } from './boundary-query-source';
 export { boundaryTableSource } from './boundary-table-source';

package/build/sources/types.d.ts

@@ -39,29 +39,23 @@ export type SourceOptionalOptions = {
      */
     maxLengthURL?: number;
     /**
-     * The column name and the type of geospatial support.
-     *
-     * If not present, defaults to `'geom'` for generic queries, `'quadbin'` for Quadbin sources and `'h3'` for H3 sources.
+     * By default, local in-memory caching is enabled.
      */
-    spatialDataColumn?: string;
+    localCache?: LocalCacheOptions;
+};
+export type LocalCacheOptions = {
     /**
-     * The type of geospatial support. Defaults to `'geo'`.
+     * Map that stores requests and their responses.
      */
-    spatialDataType?: SpatialDataType;
+    cache?: Map<string, Promise<unknown>>;
     /**
-     * Relative resolution of a tile. Higher values increase density and data size. At `tileResolution = 1`, tile geometry is
-     * quantized to a 1024x1024 grid. Increasing or decreasing the resolution will increase or decrease the dimensions of
-     * the quantization grid proportionately.
-     *
-     * Supported `tileResolution` values, with corresponding grid sizes:
+     * Cache control
+     *  * `no-cache`: If present, the source will always fetch from original source.
+     *  * `no-store`: If present, source will not store result in cache (for later reuse).
      *
-     * - 0.25: 256x256
-     * - 0.5: 512x512
-     * - 1: 1024x1024
-     * - 2: 2048x2048
-     * - 4: 4096x4096
+     * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control#directives
      */
-    tileResolution?: TileResolution;
+    cacheControl?: ('no-cache' | 'no-store')[];
 };
 export type SourceOptions = SourceRequiredOptions & Partial<SourceOptionalOptions>;
 export type AggregationOptions = {
@@ -79,10 +73,6 @@ export type AggregationOptions = {
      * @default 6 for quadbin and 4 for h3 sources
      */
     aggregationResLevel?: number;
-    /**
-     * Original resolution of the spatial index data as stored in the DW
-     */
-    dataResolution?: number;
 };
 export type FilterOptions = {
     /**
@@ -91,8 +81,28 @@ export type FilterOptions = {
     filters?: Filters;
 };
 export type QuerySourceOptions = {
-    /** Full SQL query with query paremeter placeholders (if any). */
+    /**
+     * The column name and the type of geospatial support.
+     *
+     * If not present, defaults to `'geom'` for generic queries, `'quadbin'` for Quadbin sources and `'h3'` for H3 sources.
+     */
+    spatialDataColumn?: string;
+    /** SQL query. */
     sqlQuery: string;
+    /**
+     * Relative resolution of a tile. Higher values increase density and data size. At `tileResolution = 1`, tile geometry is
+     * quantized to a 1024x1024 grid. Increasing or decreasing the resolution will increase or decrease the dimensions of
+     * the quantization grid proportionately.
+     *
+     * Supported `tileResolution` values, with corresponding grid sizes:
+     *
+     * - 0.25: 256x256
+     * - 0.5: 512x512
+     * - 1: 1024x1024
+     * - 2: 2048x2048
+     * - 4: 4096x4096
+     */
+    tileResolution?: TileResolution;
     /**
      * Values for named or positional paramteres in the query.
      *
@@ -124,6 +134,26 @@ export type TableSourceOptions = {
      * Fully qualified name of table.
      */
     tableName: string;
+    /**
+     * The column name and the type of geospatial support.
+     *
+     * If not present, defaults to `'geom'` for generic tables, `'quadbin'` for Quadbin sources and `'h3'` for H3 sources.
+     */
+    spatialDataColumn?: string;
+    /**
+     * Relative resolution of a tile. Higher values increase density and data size. At `tileResolution = 1`, tile geometry is
+     * quantized to a 1024x1024 grid. Increasing or decreasing the resolution will increase or decrease the dimensions of
+     * the quantization grid proportionately.
+     *
+     * Supported `tileResolution` values, with corresponding grid sizes:
+     *
+     * - 0.25: 256x256
+     * - 0.5: 512x512
+     * - 1: 1024x1024
+     * - 2: 2048x2048
+     * - 4: 4096x4096
+     */
+    tileResolution?: TileResolution;
 };
 export type TilesetSourceOptions = {
     /**
@@ -140,13 +170,6 @@ export type ColumnsOption = {
     columns?: string[];
 };
 export type SpatialDataType = 'geo' | 'h3' | 'quadbin';
-/**
- * Strategy used for covering spatial filter geometry with spatial indexes.
- * See https://docs.carto.com/data-and-analysis/analytics-toolbox-for-bigquery/sql-reference/quadbin#quadbin_polyfill_mode
- * or https://docs.carto.com/data-and-analysis/analytics-toolbox-for-bigquery/sql-reference/h3#h3_polyfill_mode for more information.
- * @internalRemarks Source: cloud-native maps-api
- * */
-export type SpatialFilterPolyfillMode = 'center' | 'intersects' | 'contains';
 export type TilejsonMapInstantiation = MapInstantiation & {
     tilejson: {
         url: string[];
@@ -161,16 +184,42 @@ export interface Tilejson {
     attribution: string;
     scheme: string;
     tiles: string[];
-    properties_tiles: string[];
-    minresolution: number;
-    maxresolution: number;
     minzoom: number;
     maxzoom: number;
-    bounds: [number, number, number, number];
-    center: [number, number, number];
+    bounds: [left: number, bottom: number, right: number, top: number];
+    center: [longitute: number, latitude: number, zoom: number];
     vector_layers: VectorLayer[];
+    minresolution: number;
+    maxresolution: number;
+    properties_tiles: string[];
     tilestats: Tilestats;
     tileResolution?: TileResolution;
+    /**
+     * Resolution of data in spatial-index dataset (e.g. H3, Quadbin).
+     *
+     * @internal
+     */
+    dataresolution?: number;
+    /**
+     * Array of ratios of dropped features per zoom level.
+     *
+     * Example: `[0,0,0.5]` - means that 50% of features are dropped at zoom 2 and bigger.
+     *
+     * @internal
+     */
+    fraction_dropped_per_zoom?: number[];
+    /**
+     * Names of bands - rasters only.
+     *
+     * @internal
+     */
+    raster_bands?: string[];
+    /**
+     * Raster metadata - rasters only.
+     *
+     * @internal
+     */
+    raster_metadata?: RasterMetadata;
 }
 export interface Tilestats {
     layerCount: number;
@@ -191,7 +240,99 @@ export interface VectorLayer {
     minzoom: number;
     maxzoom: number;
     fields: Record<string, string>;
+    geometry_type?: string;
 }
+export type RasterMetadataBandStats = {
+    approximated_stats?: boolean;
+    min: number;
+    max: number;
+    mean: number;
+    stddev: number;
+    sum: number;
+    sum_squares: number;
+    count: number;
+    /**
+     * Quantiles by number of buckets.
+     *
+     * Example:
+     * ```ts
+     *   {
+     *     // for 3 buckets, first 1/3 of items lies in range [min, 20], second 1/3 is in [20, 40], and last 1/3 is in [40, max]
+     *     3: [20, 40],
+     *     4: [20, 30, 50], for 4 buckets ...
+     *   }
+     * ```
+     */
+    quantiles?: Record<number, number[]>;
+    /**
+     * Top values by number of values.
+     *
+     * Key of dictionary is value, value is count.
+     * Key order is random.
+     *
+     * Example:
+     * ```
+     *  {
+     *    3: 5, // means there are 5 pixels with value 3
+     *    11: 222,
+     *    12: 333, // means that 12 is most common value with count 333
+     *    ...      // (assuming 333 was largest value in dict)
+     *   }
+     * ```
+     */
+    top_values?: Record<number, number>;
+    /**
+     * Raster loader version.
+     */
+    version?: string;
+};
+export declare enum RasterBandColorinterp {
+    Gray = "gray",
+    Red = "red",
+    Green = "green",
+    Blue = "blue",
+    Alpha = "alpha",
+    Palette = "palette"
+}
+export type RasterMetadataBand = {
+    type: string;
+    name: string;
+    stats: RasterMetadataBandStats;
+    /**
+     * Known values:
+     *  * `palette`: use unique value and `colortable` ad default mapping
+     *  * `red`, `green`, `blue`: use the band as color channel
+     *  * `gray`: use the band as grayscale
+     */
+    colorinterp?: string | RasterBandColorinterp;
+    /**
+     * Default color mapping for unique values (or if coloprinterp is `palette`)
+     */
+    colortable?: Record<string, number[]>;
+    /**
+     * No value representation.
+     * Observed values:
+     *   * `'nan'` for `NaN`
+     *   * `number`: both as string as number, so parsing is needed
+     */
+    nodata: string | number;
+};
+export type RasterMetadata = {
+    block_resolution: number;
+    minresolution: number;
+    maxresolution: number;
+    nodata: number | string;
+    bands: RasterMetadataBand[];
+    bounds: [left: number, bottom: number, right: number, top: number];
+    center: [longitute: number, latitude: number, zoom: number];
+    width: number;
+    height: number;
+    block_width: number;
+    block_height: number;
+    num_blocks: number;
+    num_pixels: number;
+    pixel_resolution: number;
+};
 export type TilejsonResult = Tilejson & {
     accessToken: string;
 };

package/build/utils.d.ts

@@ -14,7 +14,7 @@ type Row<T> = Record<string, T> | Record<string, T>[] | T[] | T;
  */
 export declare function normalizeObjectKeys<T, R extends Row<T>>(el: R): R;
 /** @internalRemarks Source: @carto/react-core */
-export declare function assert(condition: unknown, message: string): asserts condition;
+export declare function assert(condition: unknown, message: string): void;
 /**
  * @internalRemarks Source: @carto/react-core
  * @internal

package/build/widget-sources/types.d.ts

@@ -1,20 +1,13 @@
-import { SpatialFilterPolyfillMode, TileResolution } from '../sources/types';
+import { TileResolution } from '../sources/types';
 import { GroupDateType, SortColumnType, SortDirection, SpatialFilter } from '../types';
 /******************************************************************************
  * WIDGET API REQUESTS
  */
-export interface ViewState {
-    zoom: number;
-    latitude: number;
-    longitude: number;
-}
 /** Common options for {@link WidgetBaseSource} requests. */
 interface BaseRequestOptions {
     spatialFilter?: SpatialFilter;
-    spatialFiltersMode?: SpatialFilterPolyfillMode;
     abortController?: AbortController;
     filterOwner?: string;
-    viewState?: ViewState;
 }
 /** Options for {@link WidgetBaseSource#getCategories}. */
 export interface CategoryRequestOptions extends BaseRequestOptions {

package/build/widget-sources/widget-base-source.d.ts

@@ -5,6 +5,7 @@ import { SourceOptions } from '../sources/index.js';
 import { ApiVersion } from '../constants.js';
 export interface WidgetBaseSourceProps extends Omit<SourceOptions, 'filters'> {
     apiVersion?: ApiVersion;
+    geoColumn?: string;
     filters?: Record<string, Filter>;
     filtersLogicalOperator?: FilterLogicalOperator;
 }

package/package.json

@@ -4,7 +4,7 @@
   "repository": "github:CartoDB/carto-api-client",
   "author": "Don McCurdy <donmccurdy@carto.com>",
   "packageManager": "yarn@4.3.1",
-  "version": "0.4.1-alpha.0",
+  "version": "0.4.1-alpha.1",
   "license": "MIT",
   "publishConfig": {
     "access": "public",

package/src/api/query.ts

@@ -12,7 +12,8 @@ import {buildQueryUrl} from './endpoints';
 import {requestWithParameters} from './request-with-parameters';
 import {APIErrorContext} from './carto-api-error';
 
-export type QueryOptions = SourceOptions & QuerySourceOptions;
+export type QueryOptions = SourceOptions &
+  Omit<QuerySourceOptions, 'spatialDataColumn'>;
 type UrlParameters = {q: string; queryParameters?: string};
 
 export const query = async function (
@@ -22,6 +23,7 @@ export const query = async function (
     apiBaseUrl = SOURCE_DEFAULTS.apiBaseUrl,
     clientId = SOURCE_DEFAULTS.clientId,
     maxLengthURL = SOURCE_DEFAULTS.maxLengthURL,
+    localCache,
     connectionName,
     sqlQuery,
     queryParameters,
@@ -51,5 +53,6 @@ export const query = async function (
     headers,
     errorContext,
     maxLengthURL,
+    localCache,
   });
 };

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

@@ -7,13 +7,14 @@ import {CartoAPIError, APIErrorContext} from './carto-api-error';
 import {V3_MINOR_VERSION} from '../constants-internal';
 import {DEFAULT_MAX_LENGTH_URL} from '../constants-internal';
 import {getClient} from '../client';
+import {LocalCacheOptions} from '../sources/types';
 
 const DEFAULT_HEADERS = {
   Accept: 'application/json',
   'Content-Type': 'application/json',
 };
 
-const REQUEST_CACHE = new Map<string, Promise<unknown>>();
+const DEFAULT_REQUEST_CACHE = new Map<string, Promise<unknown>>();
 
 export async function requestWithParameters<T = any>({
   baseUrl,
@@ -21,12 +22,14 @@ export async function requestWithParameters<T = any>({
   headers: customHeaders = {},
   errorContext,
   maxLengthURL = DEFAULT_MAX_LENGTH_URL,
+  localCache,
 }: {
   baseUrl: string;
   parameters?: Record<string, unknown>;
   headers?: Record<string, string>;
   errorContext: APIErrorContext;
   maxLengthURL?: number;
+  localCache?: LocalCacheOptions;
 }): Promise<T> {
   // Parameters added to all requests issued with `requestWithParameters()`.
   // These parameters override parameters already in the base URL, but not
@@ -41,7 +44,14 @@ export async function requestWithParameters<T = any>({
 
   baseUrl = excludeURLParameters(baseUrl, Object.keys(parameters));
   const key = createCacheKey(baseUrl, parameters, customHeaders);
-  if (REQUEST_CACHE.has(key)) {
+
+  const {
+    cache: REQUEST_CACHE,
+    canReadCache,
+    canStoreInCache,
+  } = getCacheSettings(localCache);
+
+  if (canReadCache && REQUEST_CACHE.has(key)) {
     return REQUEST_CACHE.get(key) as Promise<T>;
   }
 
@@ -73,14 +83,34 @@ export async function requestWithParameters<T = any>({
       return json;
     })
     .catch((error: Error) => {
-      REQUEST_CACHE.delete(key);
+      if (canStoreInCache) {
+        REQUEST_CACHE.delete(key);
+      }
       throw new CartoAPIError(error, errorContext, response, responseJson);
     });
 
-  REQUEST_CACHE.set(key, jsonPromise);
+  if (canStoreInCache) {
+    REQUEST_CACHE.set(key, jsonPromise);
+  }
   return jsonPromise;
 }
 
+function getCacheSettings(localCache: LocalCacheOptions | undefined) {
+  const canReadCache = localCache?.cacheControl?.includes('no-cache')
+    ? false
+    : true;
+  const canStoreInCache = localCache?.cacheControl?.includes('no-store')
+    ? false
+    : true;
+  const cache = localCache?.cache || DEFAULT_REQUEST_CACHE;
+
+  return {
+    cache,
+    canReadCache,
+    canStoreInCache,
+  };
+}
+
 function createCacheKey(
   baseUrl: string,
   parameters: Record<string, unknown>,

package/src/models/model.ts

@@ -7,10 +7,9 @@ import {
   SpatialFilter,
 } from '../types.js';
 import {$TODO} from '../types-internal.js';
-import {assert, isPureObject} from '../utils.js';
+import {assert} from '../utils.js';
 import {ModelRequestOptions, makeCall} from './common.js';
 import {ApiVersion} from '../constants.js';
-import {SpatialDataType, SpatialFilterPolyfillMode} from '../sources/types.js';
 
 /** @internalRemarks Source: @carto/react-api */
 const AVAILABLE_MODELS = [
@@ -36,14 +35,9 @@ export interface ModelSource {
   data: string;
   filters?: Record<string, Filter>;
   filtersLogicalOperator?: FilterLogicalOperator;
+  geoColumn?: string;
   spatialFilter?: SpatialFilter;
   queryParameters?: QueryParameters;
-  spatialDataColumn?: string;
-  spatialDataType?: SpatialDataType;
-  spatialFiltersResolution?: number;
-  spatialFiltersMode?: SpatialFilterPolyfillMode;
-  /** original resolution of the spatial index data as stored in the DW */
-  dataResolution?: number;
 }
 
 const {V3} = ApiVersion;
@@ -85,51 +79,50 @@ export function executeModel(props: {
     data,
     filters,
     filtersLogicalOperator = 'and',
-    spatialDataType = 'geo',
-    spatialFiltersMode = 'intersects',
-    spatialFiltersResolution = 0,
+    geoColumn = DEFAULT_GEO_COLUMN,
   } = source;
 
-  const queryParams: Record<string, unknown> = {
+  const queryParameters = source.queryParameters
+    ? JSON.stringify(source.queryParameters)
+    : '';
+
+  const queryParams: Record<string, string> = {
     type,
     client: clientId,
     source: data,
-    params,
-    queryParameters: source.queryParameters || '',
-    filters,
+    params: JSON.stringify(params),
+    queryParameters,
+    filters: JSON.stringify(filters),
     filtersLogicalOperator,
   };
 
-  const spatialDataColumn = source.spatialDataColumn || DEFAULT_GEO_COLUMN;
-
   // Picking Model API requires 'spatialDataColumn'.
   if (model === 'pick') {
-    queryParams.spatialDataColumn = spatialDataColumn;
+    queryParams.spatialDataColumn = geoColumn;
   }
 
-  // API supports multiple filters, we apply it only to spatialDataColumn
+  // API supports multiple filters, we apply it only to geoColumn
   const spatialFilters = source.spatialFilter
-    ? {[spatialDataColumn]: source.spatialFilter}
+    ? {[geoColumn]: source.spatialFilter}
     : undefined;
 
   if (spatialFilters) {
-    queryParams.spatialFilters = spatialFilters; // JSON.stringify(spatialFilters);
-    queryParams.spatialDataColumn = spatialDataColumn;
-    queryParams.spatialDataType = spatialDataType;
-  }
-
-  if (spatialDataType !== 'geo') {
-    if (spatialFiltersResolution > 0) {
-      queryParams.spatialFiltersResolution = spatialFiltersResolution;
-    }
-    queryParams.spatialFiltersMode = spatialFiltersMode;
+    queryParams.spatialFilters = JSON.stringify(spatialFilters);
   }
 
   const urlWithSearchParams =
-    url + '?' + objectToURLSearchParams(queryParams).toString();
+    url + '?' + new URLSearchParams(queryParams).toString();
   const isGet = urlWithSearchParams.length <= REQUEST_GET_MAX_URL_LENGTH;
   if (isGet) {
     url = urlWithSearchParams;
+  } else {
+    // undo the JSON.stringify, @TODO find a better pattern
+    queryParams.params = params as $TODO;
+    queryParams.filters = filters as $TODO;
+    queryParams.queryParameters = source.queryParameters as $TODO;
+    if (spatialFilters) {
+      queryParams.spatialFilters = spatialFilters as $TODO;
+    }
   }
   return makeCall({
     url,
@@ -141,19 +134,3 @@ export function executeModel(props: {
     },
   });
 }
-
-function objectToURLSearchParams(object: Record<string, unknown>) {
-  const params = new URLSearchParams();
-  for (const key in object) {
-    if (isPureObject(object[key])) {
-      params.append(key, JSON.stringify(object[key]));
-    } else if (Array.isArray(object[key])) {
-      params.append(key, JSON.stringify(object[key]));
-    } else if (object[key] === null) {
-      params.append(key, 'null');
-    } else if (object[key] !== undefined) {
-      params.append(key, String(object[key]));
-    }
-  }
-  return params;
-}

package/src/sources/base-source.ts

@@ -45,7 +45,7 @@ export async function baseSource<UrlParameters extends Record<string, unknown>>(
     }
   }
   const baseUrl = buildSourceUrl(mergedOptions);
-  const {clientId, maxLengthURL, format} = mergedOptions;
+  const {clientId, maxLengthURL, format, localCache} = mergedOptions;
   const headers = {
     Authorization: `Bearer ${options.accessToken}`,
     ...options.headers,
@@ -65,6 +65,7 @@ export async function baseSource<UrlParameters extends Record<string, unknown>>(
       headers,
       errorContext,
       maxLengthURL,
+      localCache,
     });
 
   const dataUrl = mapInstantiation[format].url[0];
@@ -82,6 +83,7 @@ export async function baseSource<UrlParameters extends Record<string, unknown>>(
       headers,
       errorContext,
       maxLengthURL,
+      localCache,
     });
     if (accessToken) {
       json.accessToken = accessToken;
@@ -94,5 +96,6 @@ export async function baseSource<UrlParameters extends Record<string, unknown>>(
     headers,
     errorContext,
     maxLengthURL,
+    localCache,
   });
 }

package/src/sources/h3-query-source.ts

@@ -19,7 +19,6 @@ export type H3QuerySourceOptions = SourceOptions &
   QuerySourceOptions &
   AggregationOptions &
   FilterOptions;
-
 type UrlParameters = {
   aggregationExp: string;
   aggregationResLevel?: string;
@@ -60,12 +59,7 @@ export const h3QuerySource = async function (
   return baseSource<UrlParameters>('query', options, urlParameters).then(
     (result) => ({
       ...(result as TilejsonResult),
-      widgetSource: new WidgetQuerySource({
-        ...options,
-        // NOTE: passing redundant spatialDataColumn here to apply the default value 'h3'
-        spatialDataColumn,
-        spatialDataType: 'h3',
-      }),
+      widgetSource: new WidgetQuerySource(options),
     })
   );
 };

package/src/sources/h3-table-source.ts

@@ -55,12 +55,7 @@ export const h3TableSource = async function (
   return baseSource<UrlParameters>('table', options, urlParameters).then(
     (result) => ({
       ...(result as TilejsonResult),
-      widgetSource: new WidgetTableSource({
-        ...options,
-        // NOTE: passing redundant spatialDataColumn here to apply the default value 'h3'
-        spatialDataColumn,
-        spatialDataType: 'h3',
-      }),
+      widgetSource: new WidgetTableSource(options),
     })
   );
 };

package/src/sources/index.ts

@@ -4,6 +4,11 @@
 
 export {SOURCE_DEFAULTS} from './base-source';
 export type {
+  VectorLayer,
+  RasterMetadataBandStats,
+  RasterBandColorinterp,
+  RasterMetadataBand,
+  RasterMetadata,
   TilejsonResult,
   GeojsonResult,
   JsonResult,

package/src/sources/quadbin-query-source.ts

@@ -60,12 +60,7 @@ export const quadbinQuerySource = async function (
   return baseSource<UrlParameters>('query', options, urlParameters).then(
     (result) => ({
       ...(result as TilejsonResult),
-      widgetSource: new WidgetQuerySource({
-        ...options,
-        // NOTE: passing redundant spatialDataColumn here to apply the default value 'quadbin'
-        spatialDataColumn,
-        spatialDataType: 'quadbin',
-      }),
+      widgetSource: new WidgetQuerySource(options),
     })
   );
 };