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

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

@@ -0,0 +1,162 @@
+import { SpatialFilterPolyfillMode, TileResolution } from '../sources/types.js';
+import { Filters, GroupDateType, SortColumnType, SortDirection, SpatialFilter } from '../types.js';
+/******************************************************************************
+ * WIDGET API REQUESTS
+ */
+export interface ViewState {
+    zoom: number;
+    latitude: number;
+    longitude: number;
+}
+/** Common options for {@link WidgetRemoteSource} requests. */
+interface BaseRequestOptions {
+    /** @deprecated */
+    abortController?: AbortController;
+    signal?: AbortSignal;
+    spatialFilter?: SpatialFilter;
+    spatialFiltersMode?: SpatialFilterPolyfillMode;
+    /** Required for table- and query-based spatial index sources (H3, Quadbin). */
+    spatialIndexReferenceViewState?: ViewState;
+    /** Overrides source filters, if any. */
+    filters?: Filters;
+    filterOwner?: string;
+}
+/** Options for {@link WidgetRemoteSource#getCategories}. */
+export interface CategoryRequestOptions extends BaseRequestOptions {
+    column: string;
+    operation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+    operationColumn?: string;
+    /** Local only. */
+    joinOperation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+}
+/**
+ * Options for {@link WidgetRemoteSource#getFeatures}.
+ * @experimental
+ * @internal
+ */
+export interface FeaturesRequestOptions extends BaseRequestOptions {
+    /**
+     * Feature IDs, as found in `_carto_feature_id`. Feature IDs are a hash
+     * of geometry, and features with identical geometry will have the same
+     * feature ID. Order is important; features in the result set will be
+     * sorted according to the order of IDs in the request.
+     */
+    featureIds: string[];
+    /**
+     * Columns to be returned for each picked object. Note that for datasets
+     * containing features with identical geometry, more than one result per
+     * requested feature ID may be returned. To match results back to the
+     * requested feature ID, include `_carto_feature_id` in the columns list.
+     */
+    columns: string[];
+    /** Topology of objects to be picked. */
+    dataType: 'points' | 'lines' | 'polygons';
+    /** Zoom level, required if using 'points' data type. */
+    z?: number;
+    /**
+     * Maximum number of objects to return in the result set. For datasets
+     * containing features with identical geometry, those features will have
+     * the same feature IDs, and so more results may be returned than feature IDs
+     * given in the request.
+     */
+    limit?: number;
+    /**
+     * Must match `tileResolution` used when obtaining the `_carto_feature_id`
+     * column, typically in a layer's tile requests.
+     */
+    tileResolution?: TileResolution;
+}
+/** Options for {@link WidgetRemoteSource#getFormula}. */
+export interface FormulaRequestOptions extends BaseRequestOptions {
+    column: string;
+    operation?: 'count' | 'avg' | 'min' | 'max' | 'sum' | 'custom';
+    operationExp?: string;
+    joinOperation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+}
+/** Options for {@link WidgetRemoteSource#getHistogram}. */
+export interface HistogramRequestOptions extends BaseRequestOptions {
+    column: string;
+    ticks: number[];
+    operation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+    /** Local only. */
+    joinOperation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+}
+/** Options for {@link WidgetRemoteSource#getRange}. */
+export interface RangeRequestOptions extends BaseRequestOptions {
+    column: string;
+}
+/** Options for {@link WidgetRemoteSource#getScatter}. */
+export interface ScatterRequestOptions extends BaseRequestOptions {
+    xAxisColumn: string;
+    xAxisJoinOperation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+    yAxisColumn: string;
+    yAxisJoinOperation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+}
+/** Options for {@link WidgetRemoteSource#getTable}. */
+export interface TableRequestOptions extends BaseRequestOptions {
+    columns: string[];
+    sortBy?: string;
+    sortDirection?: SortDirection;
+    sortByColumnType?: SortColumnType;
+    offset?: number;
+    limit?: number;
+    /** Local only. */
+    searchFilterColumn?: string;
+    /** Local only. */
+    searchFilterText?: string;
+}
+/** Options for {@link WidgetRemoteSource#getTimeSeries}. */
+export interface TimeSeriesRequestOptions extends BaseRequestOptions {
+    column: string;
+    stepSize: GroupDateType;
+    stepMultiplier?: number;
+    operation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+    operationColumn?: string;
+    joinOperation?: 'count' | 'avg' | 'min' | 'max' | 'sum';
+    splitByCategory?: string;
+    splitByCategoryLimit?: number;
+    splitByCategoryValues?: string[];
+}
+/******************************************************************************
+ * WIDGET API RESPONSES
+ */
+/**
+ * Response from {@link WidgetRemoteSource#getFeatures}.
+ * @experimental
+ * @internal
+ */
+export type FeaturesResponse = {
+    rows: Record<string, unknown>[];
+};
+/** Response from {@link WidgetRemoteSource#getFormula}. */
+export type FormulaResponse = {
+    value: number | null;
+};
+/** Response from {@link WidgetRemoteSource#getCategories}. */
+export type CategoryResponse = {
+    name: string;
+    value: number;
+}[];
+/** Response from {@link WidgetRemoteSource#getRange}. */
+export type RangeResponse = {
+    min: number;
+    max: number;
+} | null;
+/** Response from {@link WidgetRemoteSource#getTable}. */
+export type TableResponse = {
+    totalCount: number;
+    rows: Record<string, number | string>[];
+};
+/** Response from {@link WidgetRemoteSource#getScatter}. */
+export type ScatterResponse = [number, number][];
+/** Response from {@link WidgetRemoteSource#getTimeSeries}. */
+export type TimeSeriesResponse = {
+    rows: {
+        name: string;
+        value: number;
+    }[];
+    categories?: string[];
+};
+/** Response from {@link WidgetRemoteSource#getHistogram}. */
+export type HistogramResponse = number[];
+export {};

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

@@ -0,0 +1,34 @@
+import { H3QuerySourceOptions, QuadbinQuerySourceOptions, VectorQuerySourceOptions } from '../sources/index.js';
+import { WidgetRemoteSource, WidgetRemoteSourceProps } from './widget-remote-source.js';
+import { ModelSource } from '../models/model.js';
+import { Filters } from '../types.js';
+type LayerQuerySourceOptions = Omit<VectorQuerySourceOptions, 'filters'> | Omit<H3QuerySourceOptions, 'filters'> | Omit<QuadbinQuerySourceOptions, 'filters'>;
+export type WidgetQuerySourceResult = {
+    widgetSource: WidgetQuerySource;
+};
+/**
+ * Source for Widget API requests on a data source defined by a SQL query.
+ *
+ * Generally not intended to be constructed directly. Instead, call
+ * {@link vectorQuerySource}, {@link h3QuerySource}, or {@link quadbinQuerySource},
+ * which can be shared with map layers. Sources contain a `widgetSource` property,
+ * for use by widget implementations.
+ *
+ * Example:
+ *
+ * ```javascript
+ * import { vectorQuerySource } from '@carto/api-client';
+ *
+ * const data = vectorQuerySource({
+ *   accessToken: '••••',
+ *   connectionName: 'carto_dw',
+ *   sqlQuery: 'SELECT * FROM carto-demo-data.demo_tables.retail_stores'
+ * });
+ *
+ * const { widgetSource } = await data;
+ * ```
+ */
+export declare class WidgetQuerySource extends WidgetRemoteSource<LayerQuerySourceOptions & WidgetRemoteSourceProps> {
+    protected getModelSource(filters: Filters | undefined, filterOwner?: string): ModelSource;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import { CategoryRequestOptions, CategoryResponse, FeaturesRequestOptions, FeaturesResponse, FormulaRequestOptions, FormulaResponse, HistogramRequestOptions, HistogramResponse, RangeRequestOptions, RangeResponse, ScatterRequestOptions, ScatterResponse, TableRequestOptions, TableResponse, TimeSeriesRequestOptions, TimeSeriesResponse } from './types.js';
+import { WidgetSource, WidgetSourceProps } from './widget-source.js';
+export type WidgetRemoteSourceProps = WidgetSourceProps;
+/**
+ * Source for Widget API requests.
+ *
+ * Abstract class. Use {@link WidgetQuerySource} or {@link WidgetTableSource}.
+ */
+export declare abstract class WidgetRemoteSource<Props extends WidgetRemoteSourceProps> extends WidgetSource<Props> {
+    getCategories(options: CategoryRequestOptions): Promise<CategoryResponse>;
+    getFeatures(options: FeaturesRequestOptions): Promise<FeaturesResponse>;
+    getFormula(options: FormulaRequestOptions): Promise<FormulaResponse>;
+    getHistogram(options: HistogramRequestOptions): Promise<HistogramResponse>;
+    getRange(options: RangeRequestOptions): Promise<RangeResponse>;
+    getScatter(options: ScatterRequestOptions): Promise<ScatterResponse>;
+    getTable(options: TableRequestOptions): Promise<TableResponse>;
+    getTimeSeries(options: TimeSeriesRequestOptions): Promise<TimeSeriesResponse>;
+}

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

@@ -0,0 +1,84 @@
+import { CategoryRequestOptions, CategoryResponse, FeaturesRequestOptions, FeaturesResponse, FormulaRequestOptions, FormulaResponse, HistogramRequestOptions, HistogramResponse, RangeRequestOptions, RangeResponse, ScatterRequestOptions, ScatterResponse, TableRequestOptions, TableResponse, TimeSeriesRequestOptions, TimeSeriesResponse, ViewState } from './types.js';
+import { FilterLogicalOperator, Filter, SpatialFilter, Filters } from '../types.js';
+import { ModelSource } from '../models/model.js';
+import { SourceOptions } from '../sources/index.js';
+import { ApiVersion } from '../constants.js';
+export interface WidgetSourceProps extends Omit<SourceOptions, 'filters'> {
+    apiVersion?: ApiVersion;
+    filters?: Record<string, Filter>;
+    filtersLogicalOperator?: FilterLogicalOperator;
+}
+/**
+ * Source for Widget API requests on a data source defined by a SQL query.
+ *
+ * Abstract class. Use {@link WidgetQuerySource} or {@link WidgetTableSource}.
+ */
+export declare abstract class WidgetSource<Props extends WidgetSourceProps> {
+    readonly props: Props;
+    static defaultProps: Partial<WidgetSourceProps>;
+    constructor(props: Props);
+    /**
+     * Subclasses of {@link WidgetRemoteSource} must implement this method, calling
+     * {@link WidgetRemoteSource.prototype._getModelSource} for common source
+     * properties, and adding additional required properties including 'type' and
+     * 'data'.
+     */
+    protected abstract getModelSource(filters: Filters | undefined, filterOwner?: string): ModelSource;
+    protected _getModelSource(filters: Filters | undefined, filterOwner?: string): Omit<ModelSource, 'type' | 'data'>;
+    protected _getSpatialFiltersResolution(source: Omit<ModelSource, 'type' | 'data'>, spatialFilter?: SpatialFilter, referenceViewState?: ViewState): number | undefined;
+    /**
+     * Returns a list of labeled datapoints for categorical data. Suitable for
+     * charts including grouped bar charts, pie charts, and tree charts.
+     */
+    abstract getCategories(options: CategoryRequestOptions): Promise<CategoryResponse>;
+    /**
+     * Given a list of feature IDs (as found in `_carto_feature_id`) returns all
+     * matching features. In datasets containing features with duplicate geometries,
+     * feature IDs may be duplicated (IDs are a hash of geometry) and so more
+     * results may be returned than IDs in the request.
+     * @internal
+     * @experimental
+     */
+    abstract getFeatures(options: FeaturesRequestOptions): Promise<FeaturesResponse>;
+    /**
+     * Returns a scalar numerical statistic over all matching data. Suitable
+     * for 'headline' or 'scorecard' figures such as counts and sums.
+     */
+    abstract getFormula(options: FormulaRequestOptions): Promise<FormulaResponse>;
+    /**
+     * Returns a list of labeled datapoints for 'bins' of data defined as ticks
+     * over a numerical range. Suitable for histogram charts.
+     */
+    abstract getHistogram(options: HistogramRequestOptions): Promise<HistogramResponse>;
+    /**
+     * Returns a range (min and max) for a numerical column of matching rows.
+     * Suitable for displaying certain 'headline' or 'scorecard' statistics,
+     * or rendering a range slider UI for filtering.
+     */
+    abstract getRange(options: RangeRequestOptions): Promise<RangeResponse>;
+    /**
+     * Returns a list of bivariate datapoints defined as numerical 'x' and 'y'
+     * values. Suitable for rendering scatter plots.
+     */
+    abstract getScatter(options: ScatterRequestOptions): Promise<ScatterResponse>;
+    /**
+     * Returns a list of arbitrary data rows, with support for pagination and
+     * sorting. Suitable for displaying tables and lists.
+     */
+    abstract getTable(options: TableRequestOptions): Promise<TableResponse>;
+    /**
+     * Returns a series of labeled numerical values, grouped into equally-sized
+     * time intervals. Suitable for rendering time series charts.
+     */
+    abstract getTimeSeries(options: TimeSeriesRequestOptions): Promise<TimeSeriesResponse>;
+}
+/**
+ * @todo TODO(v0.5): Remove WidgetBaseSourceProps alias
+ * @deprecated Use WidgetSourceProps.
+ */
+export type WidgetBaseSourceProps = WidgetSourceProps;
+/**
+ * @todo TODO(v0.5): Remove WidgetBaseSource alias.
+ * @deprecated Use WidgetSourceP.
+ */
+export declare const WidgetBaseSource: typeof WidgetSource;

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

@@ -0,0 +1,34 @@
+import { H3TableSourceOptions, QuadbinTableSourceOptions, VectorTableSourceOptions } from '../sources/index.js';
+import { WidgetRemoteSource, WidgetRemoteSourceProps } from './widget-remote-source.js';
+import { ModelSource } from '../models/model.js';
+import { Filters } from '../types.js';
+type LayerTableSourceOptions = Omit<VectorTableSourceOptions, 'filters'> | Omit<H3TableSourceOptions, 'filters'> | Omit<QuadbinTableSourceOptions, 'filters'>;
+export type WidgetTableSourceResult = {
+    widgetSource: WidgetTableSource;
+};
+/**
+ * Source for Widget API requests on a data source defined as a table.
+ *
+ * Generally not intended to be constructed directly. Instead, call
+ * {@link vectorTableSource}, {@link h3TableSource}, or {@link quadbinTableSource},
+ * which can be shared with map layers. Sources contain a `widgetSource` property,
+ * for use by widget implementations.
+ *
+ * Example:
+ *
+ * ```javascript
+ * import { vectorTableSource } from '@carto/api-client';
+ *
+ * const data = vectorTableSource({
+ *   accessToken: '••••',
+ *   connectionName: 'carto_dw',
+ *   tableName: 'carto-demo-data.demo_tables.retail_stores'
+ * });
+ *
+ * const { widgetSource } = await data;
+ * ```
+ */
+export declare class WidgetTableSource extends WidgetRemoteSource<LayerTableSourceOptions & WidgetRemoteSourceProps> {
+    protected getModelSource(filters: Filters | undefined, filterOwner?: string): ModelSource;
+}
+export {};

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

@@ -0,0 +1,75 @@
+import { TilesetSourceOptions } from '../sources/index.js';
+import type { ModelSource } from '../models/index.js';
+import { CategoryRequestOptions, CategoryResponse, FeaturesResponse, FormulaRequestOptions, FormulaResponse, HistogramRequestOptions, HistogramResponse, RangeRequestOptions, RangeResponse, ScatterRequestOptions, ScatterResponse, TableRequestOptions, TableResponse, TimeSeriesRequestOptions, TimeSeriesResponse } from './types.js';
+import { TileFormat } from '../constants.js';
+import { Filters, SpatialFilter } from '../types.js';
+import { TileFeatureExtractOptions } from '../filters/index.js';
+import { FeatureCollection } from 'geojson';
+import { SpatialDataType } from '../sources/types.js';
+import { WidgetSource, WidgetSourceProps } from './widget-source.js';
+export type WidgetTilesetSourceProps = WidgetSourceProps & Omit<TilesetSourceOptions, 'filters'> & {
+    tileFormat: TileFormat;
+    spatialDataType: SpatialDataType;
+};
+export type WidgetTilesetSourceResult = {
+    widgetSource: WidgetTilesetSource;
+};
+/**
+ * Source for Widget API requests on a data source defined by a tileset.
+ *
+ * Generally not intended to be constructed directly. Instead, call
+ * {@link vectorTilesetSource}, {@link h3TilesetSource}, or {@link quadbinTilesetSource},
+ * which can be shared with map layers. Sources contain a `widgetSource`
+ * property, for use by widget implementations.
+ *
+ * Example:
+ *
+ * ```javascript
+ * import { vectorTilesetSource } from '@carto/api-client';
+ *
+ * const data = vectorTilesetSource({
+ *   accessToken: '••••',
+ *   connectionName: 'carto_dw',
+ *   tableName: 'carto-demo-data.demo_rasters.my_tileset_source'
+ * });
+ *
+ * const { widgetSource } = await data;
+ * ```
+ */
+export declare class WidgetTilesetSource extends WidgetSource<WidgetTilesetSourceProps> {
+    private _tiles;
+    private _features;
+    private _tileFeatureExtractOptions;
+    private _tileFeatureExtractPreviousInputs;
+    protected getModelSource(filters: Filters | undefined, filterOwner: string): ModelSource;
+    /**
+     * Loads features as a list of tiles (typically provided by deck.gl).
+     * After tiles are loaded, {@link extractTileFeatures} must be called
+     * before computing statistics on the tiles.
+     */
+    loadTiles(tiles: unknown[]): void;
+    /** Configures options used to extract features from tiles. */
+    setTileFeatureExtractOptions(options: TileFeatureExtractOptions): void;
+    protected _extractTileFeatures(spatialFilter: SpatialFilter): void;
+    /**
+     * Loads features as GeoJSON (used for testing).
+     * @experimental
+     * @internal Not for public use. Spatial filters in other method calls will be ignored.
+     */
+    loadGeoJSON({ geojson, spatialFilter, }: {
+        geojson: FeatureCollection;
+        spatialFilter: SpatialFilter;
+    }): void;
+    getFeatures(): Promise<FeaturesResponse>;
+    getFormula({ column, operation, joinOperation, filters, filterOwner, spatialFilter, }: FormulaRequestOptions): Promise<FormulaResponse>;
+    getHistogram({ operation, ticks, column, joinOperation, filters, filterOwner, spatialFilter, }: HistogramRequestOptions): Promise<HistogramResponse>;
+    getCategories({ column, operation, operationColumn, joinOperation, filters, filterOwner, spatialFilter, }: CategoryRequestOptions): Promise<CategoryResponse>;
+    getScatter({ xAxisColumn, yAxisColumn, xAxisJoinOperation, yAxisJoinOperation, filters, filterOwner, spatialFilter, }: ScatterRequestOptions): Promise<ScatterResponse>;
+    getTable({ columns, searchFilterColumn, searchFilterText, sortBy, sortDirection, sortByColumnType, offset, limit, filters, filterOwner, spatialFilter, }: TableRequestOptions): Promise<TableResponse>;
+    getTimeSeries({ column, stepSize, operation, operationColumn, joinOperation, filters, filterOwner, spatialFilter, }: TimeSeriesRequestOptions): Promise<TimeSeriesResponse>;
+    getRange({ column, filters, filterOwner, spatialFilter, }: RangeRequestOptions): Promise<RangeResponse>;
+    /****************************************************************************
+     * INTERNAL
+     */
+    private _getFilteredFeatures;
+}

package/package.json

@@ -8,27 +8,22 @@
   "homepage": "https://github.com/CartoDB/carto-api-client#readme",
   "author": "Don McCurdy <donmccurdy@carto.com>",
   "packageManager": "yarn@4.3.1",
-  "version": "0.4.7-0",
+  "version": "0.4.7-alpha.1",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
   "type": "module",
   "sideEffects": false,
+  "source": "src/index.ts",
+  "types": "./build/index.d.ts",
+  "main": "./build/api-client.cjs",
+  "module": "./build/api-client.modern.js",
   "exports": {
     ".": {
-      "require": {
-        "types": "./build/api-client.d.cts",
-        "default": "./build/api-client.cjs"
-      },
-      "default": {
-        "types": "./build/api-client.d.ts",
-        "default": "./build/api-client.js"
-      }
-    },
-    "./worker": {
-      "types": "./build/worker.d.ts",
-      "default": "./build/worker.js"
+      "types": "./build/index.d.ts",
+      "require": "./build/api-client.cjs",
+      "default": "./build/api-client.modern.js"
     }
   },
   "browserslist": [
@@ -37,8 +32,8 @@
     "node >= 18"
   ],
   "scripts": {
-    "build": "tsup",
-    "build:watch": "tsup --watch",
+    "build": "microbundle --format cjs,modern --no-compress --define __CARTO_API_CLIENT_VERSION=$npm_package_version",
+    "build:watch": "microbundle watch --format cjs,modern --no-compress --define __CARTO_API_CLIENT_VERSION=$npm_package_version",
     "dev": "concurrently \"yarn build:watch\" \"vite --config examples/vite.config.ts --open\"",
     "test": "vitest run --typecheck",
     "test:watch": "vitest watch --typecheck",
@@ -103,16 +98,20 @@
     "lit": "^3.2.1",
     "lit-analyzer": "^2.0.3",
     "maplibre-gl": "^5.1.0",
+    "microbundle": "^0.15.1",
     "prettier": "^3.4.2",
     "rimraf": "^6.0.1",
     "semver": "^7.7.1",
     "thenby": "^1.3.4",
     "tinybench": "^3.1.1",
-    "tsup": "^8.3.6",
-    "typescript": "~5.7.3",
+    "typescript": "~5.8.2",
     "typescript-eslint": "^8.24.0",
     "vite": "^6.1.0",
-    "vitest": "3.0.5"
+    "vitest": "3.0.7"
   },
-  "stableVersion": "0.4.6"
+  "resolutions": {
+    "@carto/api-client": "portal:./",
+    "rollup": "^4.20.0"
+  },
+  "stableVersion": "0.4.7"
 }

package/src/constants-internal.ts

@@ -1,3 +1,9 @@
+/**
+ * Current version of @carto/api-client.
+ * @internal
+ */
+export const API_CLIENT_VERSION = __CARTO_API_CLIENT_VERSION;
+
 /** @internal */
 export const V3_MINOR_VERSION = '3.4';
 

package/src/deck/get-data-filter-extension-props.ts

@@ -8,6 +8,16 @@ type TimeFilter = Filters['string'][FilterType.TIME] & {
   params?: {offsetBy?: number};
 };
 
+/**
+ * deck.gl's DataFilterExtension supports GPU filtering with 1–4 values. We
+ * allocate filters[0] to generic filters and filters[1] to time filters.
+ *
+ * getFilterValue() _must_ return an array of the same size as the filterSize
+ * used to initialize the DataFilterExtension. We document that users must use
+ * filterSize=4 for compatibility with @link {getDataFilterExtensionProps}.
+ */
+const DEFAULT_FILTER_SIZE = 4;
+
 /** @experimental Prefer type definition from deck.gl. */
 export type _DataFilterExtensionProps = {
   filterRange: number[][];
@@ -17,22 +27,30 @@ export type _DataFilterExtensionProps = {
 
 /**
  * Creates props for DataFilterExtension, from `@deck.gl/extensions`, given
- * a set of filters.
+ * a set of filters. Requires that DataFilterExtension is initialized with
+ * filterSize=4, where the CARTO filters will occupy the first two slots.
+ *
+ * @example To create a deck.gl layer with GPU data filtering:
+ * ```typescript
+ * import {DataFilterExtension} from '@deck.gl/extensions';
+ * import {VectorTileLayer} from '@deck.gl/layers';
+ * import {getDataFilterExtensionProps} from '@carto/api-client';
  *
- * @privateRemarks DataFilterExtension accepts up to 4 values to filter. This
- *  implementation uses the 1st for all filters except the time filter, and the
- *  2nd for the time filter.
+ * const layer = new VectorTileLayer({
+ *  data: data,
+ *  extensions: [new DataFilterExtension({filterSize: 4})],
+ *  ...getDataFilterExtensionProps(filters),
+ * });
+ * ```
  */
 export function getDataFilterExtensionProps(
   filters: Filters,
-  filtersLogicalOperator?: FilterLogicalOperator,
-  filterSize?: 0 | 1 | 2 | 3 | 4
+  filtersLogicalOperator?: FilterLogicalOperator
 ): _DataFilterExtensionProps {
-  filterSize ??= 4;
   const {filtersWithoutTimeType, timeColumn, timeFilter} =
     getFiltersByType(filters);
   return {
-    filterRange: getFilterRange(timeFilter, filterSize),
+    filterRange: getFilterRange(timeFilter, DEFAULT_FILTER_SIZE),
     updateTriggers: getUpdateTriggers(
       filtersWithoutTimeType,
       timeColumn,
@@ -42,7 +60,7 @@ export function getDataFilterExtensionProps(
       filtersWithoutTimeType,
       timeColumn,
       timeFilter,
-      filterSize,
+      DEFAULT_FILTER_SIZE,
       filtersLogicalOperator
     ),
   };

package/src/filters/tileFeatures.ts

@@ -20,7 +20,6 @@ export type TileFeatures = {
 /** @privateRemarks Source: @carto/react-core */
 export type TileFeatureExtractOptions = {
   storeGeometry?: boolean;
-  uniqueIdProperty?: string;
 };
 
 /** @privateRemarks Source: @carto/react-core */

package/src/global.d.ts

@@ -1,5 +1,10 @@
+/**
+ * Injected by microbundle, with:
+ * ```
+ * --define __CARTO_API_CLIENT_VERSION=$npm_package_version
+ * ```
+ */
+declare const __CARTO_API_CLIENT_VERSION: string;
+
 /** Defined by @deck.gl/core. */
 declare const deck: {VERSION: string | undefined} | undefined;
-
-/** Defined by tsup. */
-declare const TSUP_FORMAT: 'esm' | 'cjs';

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

@@ -2,11 +2,6 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {getTileFormat} from '../utils/getTileFormat.js';
-import {
-  WidgetTilesetSource,
-  WidgetTilesetSourceResult,
-} from '../widget-sources/index.js';
 import {baseSource} from './base-source.js';
 import type {
   SourceOptions,
@@ -17,24 +12,17 @@ import type {
 export type H3TilesetSourceOptions = SourceOptions & TilesetSourceOptions;
 type UrlParameters = {name: string};
 
-export type H3TilesetSourceResponse = TilejsonResult &
-  WidgetTilesetSourceResult;
+export type H3TilesetSourceResponse = TilejsonResult;
 
 export const h3TilesetSource = async function (
   options: H3TilesetSourceOptions
 ): Promise<H3TilesetSourceResponse> {
-  const {tableName, spatialDataColumn = 'h3'} = options;
+  const {tableName} = options;
   const urlParameters: UrlParameters = {name: tableName};
 
-  return baseSource<UrlParameters>('tileset', options, urlParameters).then(
-    (result) => ({
-      ...(result as TilejsonResult),
-      widgetSource: new WidgetTilesetSource({
-        ...options,
-        tileFormat: getTileFormat(result as TilejsonResult),
-        spatialDataColumn,
-        spatialDataType: 'h3',
-      }),
-    })
+  return baseSource<UrlParameters>(
+    'tileset',
+    options,
+    urlParameters
   ) as Promise<H3TilesetSourceResponse>;
 };

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

@@ -2,11 +2,6 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {getTileFormat} from '../utils/getTileFormat.js';
-import {
-  WidgetTilesetSource,
-  WidgetTilesetSourceResult,
-} from '../widget-sources/index.js';
 import {baseSource} from './base-source.js';
 import type {
   SourceOptions,
@@ -17,24 +12,17 @@ import type {
 export type QuadbinTilesetSourceOptions = SourceOptions & TilesetSourceOptions;
 type UrlParameters = {name: string};
 
-export type QuadbinTilesetSourceResponse = TilejsonResult &
-  WidgetTilesetSourceResult;
+export type QuadbinTilesetSourceResponse = TilejsonResult;
 
 export const quadbinTilesetSource = async function (
   options: QuadbinTilesetSourceOptions
 ): Promise<QuadbinTilesetSourceResponse> {
-  const {tableName, spatialDataColumn = 'quadbin'} = options;
+  const {tableName} = options;
   const urlParameters: UrlParameters = {name: tableName};
 
-  return baseSource<UrlParameters>('tileset', options, urlParameters).then(
-    (result) => ({
-      ...(result as TilejsonResult),
-      widgetSource: new WidgetTilesetSource({
-        ...options,
-        tileFormat: getTileFormat(result as TilejsonResult),
-        spatialDataColumn,
-        spatialDataType: 'quadbin',
-      }),
-    })
+  return baseSource<UrlParameters>(
+    'tileset',
+    options,
+    urlParameters
   ) as Promise<QuadbinTilesetSourceResponse>;
 };