@carto/api-client 0.4.5 → 0.4.6-0

package/build/widget-sources/{widget-base-source.d.ts → widget-source.d.ts}

@@ -3,41 +3,34 @@ import { FilterLogicalOperator, Filter, SpatialFilter } from '../types.js';
 import { ModelSource } from '../models/model.js';
 import { SourceOptions } from '../sources/index.js';
 import { ApiVersion } from '../constants.js';
-export interface WidgetBaseSourceProps extends Omit<SourceOptions, 'filters'> {
+export interface WidgetSourceProps extends Omit<SourceOptions, 'filters'> {
     apiVersion?: ApiVersion;
     filters?: Record<string, Filter>;
     filtersLogicalOperator?: FilterLogicalOperator;
 }
-export type WidgetSource = WidgetBaseSource<WidgetBaseSourceProps>;
 /**
  * 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 WidgetBaseSource<Props extends WidgetBaseSourceProps> {
+export declare abstract class WidgetSource<Props extends WidgetSourceProps> {
     readonly props: Props;
-    static defaultProps: Partial<WidgetBaseSourceProps>;
+    static defaultProps: Partial<WidgetSourceProps>;
     constructor(props: Props);
     /**
-     * Subclasses of {@link WidgetBaseSource} must implement this method, calling
-     * {@link WidgetBaseSource.prototype._getModelSource} for common source
+     * 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(owner: string | undefined): ModelSource;
     protected _getModelSource(owner?: string): Omit<ModelSource, 'type' | 'data'>;
     protected _getSpatialFiltersResolution(source: Omit<ModelSource, 'type' | 'data'>, spatialFilter?: SpatialFilter, referenceViewState?: ViewState): number | undefined;
-    /****************************************************************************
-     * CATEGORIES
-     */
     /**
      * Returns a list of labeled datapoints for categorical data. Suitable for
      * charts including grouped bar charts, pie charts, and tree charts.
      */
-    getCategories(options: CategoryRequestOptions): Promise<CategoryResponse>;
-    /****************************************************************************
-     * FEATURES
-     */
+    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,
@@ -46,54 +39,36 @@ export declare abstract class WidgetBaseSource<Props extends WidgetBaseSourcePro
      * @internal
      * @experimental
      */
-    getFeatures(options: FeaturesRequestOptions): Promise<FeaturesResponse>;
-    /****************************************************************************
-     * FORMULA
-     */
+    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.
      */
-    getFormula(options: FormulaRequestOptions): Promise<FormulaResponse>;
-    /****************************************************************************
-     * HISTOGRAM
-     */
+    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.
      */
-    getHistogram(options: HistogramRequestOptions): Promise<HistogramResponse>;
-    /****************************************************************************
-     * RANGE
-     */
+    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.
      */
-    getRange(options: RangeRequestOptions): Promise<RangeResponse>;
-    /****************************************************************************
-     * SCATTER
-     */
+    abstract getRange(options: RangeRequestOptions): Promise<RangeResponse>;
     /**
      * Returns a list of bivariate datapoints defined as numerical 'x' and 'y'
      * values. Suitable for rendering scatter plots.
      */
-    getScatter(options: ScatterRequestOptions): Promise<ScatterResponse>;
-    /****************************************************************************
-     * TABLE
-     */
+    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.
      */
-    getTable(options: TableRequestOptions): Promise<TableResponse>;
-    /****************************************************************************
-     * TIME SERIES
-     */
+    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.
      */
-    getTimeSeries(options: TimeSeriesRequestOptions): Promise<TimeSeriesResponse>;
+    abstract getTimeSeries(options: TimeSeriesRequestOptions): Promise<TimeSeriesResponse>;
 }

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

@@ -1,5 +1,5 @@
 import { H3TableSourceOptions, QuadbinTableSourceOptions, VectorTableSourceOptions } from '../sources/index.js';
-import { WidgetBaseSource, WidgetBaseSourceProps } from './widget-base-source.js';
+import { WidgetRemoteSource, WidgetRemoteSourceProps } from './widget-remote-source.js';
 import { ModelSource } from '../models/model.js';
 type LayerTableSourceOptions = Omit<VectorTableSourceOptions, 'filters'> | Omit<H3TableSourceOptions, 'filters'> | Omit<QuadbinTableSourceOptions, 'filters'>;
 export type WidgetTableSourceResult = {
@@ -27,7 +27,7 @@ export type WidgetTableSourceResult = {
  * const { widgetSource } = await data;
  * ```
  */
-export declare class WidgetTableSource extends WidgetBaseSource<LayerTableSourceOptions & WidgetBaseSourceProps> {
+export declare class WidgetTableSource extends WidgetRemoteSource<LayerTableSourceOptions & WidgetRemoteSourceProps> {
     protected getModelSource(owner: string): ModelSource;
 }
 export {};

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

@@ -0,0 +1,76 @@
+import { TilesetSourceOptions } from '../sources/index.js';
+import type { ModelSource } from '../models/index.js';
+import { CategoryRequestOptions, CategoryResponse, FeaturesRequestOptions, FeaturesResponse, FormulaRequestOptions, FormulaResponse, HistogramRequestOptions, HistogramResponse, RangeRequestOptions, RangeResponse, ScatterRequestOptions, ScatterResponse, TableRequestOptions, TableResponse, TimeSeriesRequestOptions, TimeSeriesResponse } from './types.js';
+import { TileFormat } from '../constants.js';
+import { 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;
+    protected getModelSource(owner: 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;
+    /**
+     * Extracts feature data from tiles previously loaded with {@link loadTiles}.
+     * Must be called before computing statistics on tiles.
+     */
+    extractTileFeatures({ spatialFilter, uniqueIdProperty, options, }: {
+        spatialFilter: SpatialFilter;
+        uniqueIdProperty?: string;
+        options?: TileFeatureExtractOptions;
+    }): void;
+    /** Loads features as GeoJSON (used for testing). */
+    loadGeoJSON({ geojson, spatialFilter, uniqueIdProperty, }: {
+        geojson: FeatureCollection;
+        spatialFilter: SpatialFilter;
+        uniqueIdProperty?: string;
+    }): void;
+    getFeatures(options: FeaturesRequestOptions): Promise<FeaturesResponse>;
+    getFormula({ column, operation, joinOperation, filterOwner, }: FormulaRequestOptions): Promise<FormulaResponse>;
+    getHistogram({ operation, ticks, column, joinOperation, filterOwner, }: HistogramRequestOptions): Promise<HistogramResponse>;
+    getCategories({ column, operation, operationColumn, joinOperation, filterOwner, }: CategoryRequestOptions): Promise<CategoryResponse>;
+    getScatter({ xAxisColumn, yAxisColumn, xAxisJoinOperation, yAxisJoinOperation, filterOwner, }: ScatterRequestOptions): Promise<ScatterResponse>;
+    getTable(options: TableRequestOptions): Promise<TableResponse>;
+    getTimeSeries({ column, stepSize, operation, operationColumn, joinOperation, filterOwner, }: TimeSeriesRequestOptions): Promise<TimeSeriesResponse>;
+    getRange({ column, filterOwner, }: RangeRequestOptions): Promise<RangeResponse>;
+    /****************************************************************************
+     * INTERNAL
+     */
+    private _getFilteredFeatures;
+}

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.5",
+  "version": "0.4.6-0",
   "license": "MIT",
   "publishConfig": {
     "access": "public",
@@ -52,12 +52,17 @@
     "LICENSE.md"
   ],
   "dependencies": {
+    "@loaders.gl/schema": "^4.3.3",
     "@turf/bbox-clip": "^7.1.0",
     "@turf/bbox-polygon": "^7.1.0",
+    "@turf/boolean-intersects": "^7.1.0",
+    "@turf/boolean-within": "^7.1.0",
     "@turf/helpers": "^7.1.0",
+    "@turf/intersect": "^7.1.0",
     "@turf/invariant": "^7.1.0",
     "@turf/union": "^7.1.0",
-    "@types/geojson": "^7946.0.15"
+    "@types/geojson": "^7946.0.15",
+    "h3-js": "4.1.0"
   },
   "devDependencies": {
     "@deck.gl/aggregation-layers": "^9.0.38",
@@ -86,11 +91,13 @@
     "prettier": "^3.4.2",
     "rimraf": "^6.0.1",
     "semver": "^7.6.3",
+    "thenby": "^1.3.4",
     "typescript": "~5.7.3",
     "vite": "^6.0.7",
     "vitest": "2.1.8"
   },
   "resolutions": {
     "rollup": "^4.20.0"
-  }
+  },
+  "stableVersion": "0.4.5"
 }

package/src/constants.ts

@@ -31,3 +31,28 @@ export enum ApiVersion {
 
 /** @internalRemarks Source: @carto/constants, @deck.gl/carto */
 export const DEFAULT_API_BASE_URL = 'https://gcp-us-east1.api.carto.com';
+
+/** @internalRemarks Source: @carto/react-core */
+export enum TileFormat {
+  MVT = 'mvt',
+  JSON = 'json',
+  GEOJSON = 'geojson',
+  BINARY = 'binary',
+}
+
+/** @internalRemarks Source: @carto/react-core */
+export enum SpatialIndex {
+  H3 = 'h3',
+  S2 = 's2',
+  QUADBIN = 'quadbin',
+}
+
+/** @internalRemarks Source: @carto/react-core */
+export enum Provider {
+  BIGQUERY = 'bigquery',
+  REDSHIFT = 'redshift',
+  POSTGRES = 'postgres',
+  SNOWFLAKE = 'snowflake',
+  DATABRICKS = 'databricks',
+  DATABRICKS_REST = 'databricksRest',
+}

package/src/filters/Filter.ts

@@ -0,0 +1,169 @@
+import {filterFunctions} from './FilterTypes';
+import {Filter, FilterLogicalOperator, Filters} from '../types';
+import {Feature} from 'geojson';
+import {FilterType} from '../constants';
+import {FeatureData} from '../types-internal';
+import {BinaryFeature} from '@loaders.gl/schema';
+
+const LOGICAL_OPERATOR_METHODS: Record<
+  FilterLogicalOperator,
+  'every' | 'some'
+> = {
+  and: 'every',
+  or: 'some',
+};
+
+function passesFilter(
+  columns: string[],
+  filters: Filters,
+  feature: FeatureData,
+  filtersLogicalOperator: FilterLogicalOperator
+): boolean {
+  const method = LOGICAL_OPERATOR_METHODS[filtersLogicalOperator];
+  return columns[method]((column) => {
+    const columnFilters = filters[column];
+    const columnFilterTypes = Object.keys(columnFilters) as FilterType[];
+
+    if (!feature || feature[column] === null || feature[column] === undefined) {
+      return false;
+    }
+
+    return columnFilterTypes.every((filter) => {
+      const filterFunction = filterFunctions[filter];
+
+      if (!filterFunction) {
+        throw new Error(`"${filter}" filter is not implemented.`);
+      }
+
+      return filterFunction(
+        columnFilters[filter]!.values,
+        feature[column],
+        (columnFilters[filter] as Filter[FilterType.STRING_SEARCH])!.params
+      );
+    });
+  });
+}
+
+export function buildFeatureFilter({
+  filters = {},
+  type = 'boolean',
+  filtersLogicalOperator = 'and',
+}: {
+  filters?: Filters;
+  type?: 'number' | 'boolean';
+  filtersLogicalOperator?: FilterLogicalOperator;
+}) {
+  const columns = Object.keys(filters);
+
+  if (!columns.length) {
+    return () => (type === 'number' ? 1 : true);
+  }
+
+  return (feature: Feature | FeatureData) => {
+    const f = feature.properties || feature;
+    const featurePassesFilter = passesFilter(
+      columns,
+      filters,
+      f as FeatureData,
+      filtersLogicalOperator
+    );
+
+    return type === 'number'
+      ? Number(featurePassesFilter)
+      : featurePassesFilter;
+  };
+}
+
+// Apply certain filters to a collection of features
+export function applyFilters(
+  features: FeatureData[],
+  filters: Filters,
+  filtersLogicalOperator: FilterLogicalOperator
+) {
+  return Object.keys(filters).length
+    ? features.filter(buildFeatureFilter({filters, filtersLogicalOperator}))
+    : features;
+}
+
+// Binary
+export function buildBinaryFeatureFilter({filters = {}}: {filters: Filters}) {
+  const columns = Object.keys(filters);
+
+  if (!columns.length) {
+    return () => 1;
+  }
+
+  return (featureIdIdx: number, binaryData: BinaryFeature) =>
+    passesFilterUsingBinary(columns, filters, featureIdIdx, binaryData);
+}
+
+function getValueFromNumericProps(
+  featureIdIdx: number,
+  binaryData: BinaryFeature,
+  {column}: {column: string}
+) {
+  return binaryData.numericProps?.[column]?.value[featureIdIdx];
+}
+
+function getValueFromProperties(
+  featureIdIdx: number,
+  binaryData: BinaryFeature,
+  {column}: {column: string}
+) {
+  const propertyIdx = binaryData.featureIds.value[featureIdIdx];
+  return (binaryData.properties[propertyIdx] as Record<string, unknown>)?.[
+    column
+  ];
+}
+
+const GET_VALUE_BY_BINARY_PROP = {
+  properties: getValueFromProperties,
+  numericProps: getValueFromNumericProps,
+};
+
+function getBinaryPropertyByFilterValues(filterValues: unknown[]) {
+  return typeof filterValues.flat()[0] === 'string'
+    ? 'properties'
+    : 'numericProps';
+}
+
+function getFeatureValue(
+  featureIdIdx: number,
+  binaryData: any,
+  filter: {type: FilterType; column: string; values: unknown[]}
+) {
+  const {column, values} = filter;
+  const binaryProp = getBinaryPropertyByFilterValues(values);
+  const getFeatureValueFn = GET_VALUE_BY_BINARY_PROP[binaryProp];
+  return getFeatureValueFn(featureIdIdx, binaryData, {column});
+}
+
+function passesFilterUsingBinary(
+  columns: string[],
+  filters: Filters,
+  featureIdIdx: number,
+  binaryData: BinaryFeature
+) {
+  return columns.every((column) => {
+    const columnFilters = filters[column];
+
+    return Object.entries(columnFilters).every(([type, {values}]) => {
+      const filterFn = filterFunctions[type as FilterType];
+      if (!filterFn) {
+        throw new Error(`"${type}" filter is not implemented.`);
+      }
+
+      if (!values) return 0;
+
+      const featureValue = getFeatureValue(featureIdIdx, binaryData, {
+        type: type as FilterType,
+        column,
+        values,
+      });
+
+      if (featureValue === undefined || featureValue === null) return 0;
+
+      return filterFn(values, featureValue);
+    });
+  });
+}

package/src/filters/FilterTypes.ts

@@ -0,0 +1,109 @@
+import {FilterType} from '../constants';
+import {FilterInterval, StringSearchOptions} from '../types';
+import {makeIntervalComplete} from '../utils/makeIntervalComplete.js';
+
+export type FilterFunction = (
+  filterValues: unknown[],
+  featureValue: unknown,
+  params?: Record<string, unknown>
+) => boolean;
+
+export const filterFunctions: Record<FilterType, FilterFunction> = {
+  [FilterType.IN]: filterIn,
+  [FilterType.BETWEEN]: filterBetween,
+  [FilterType.TIME]: filterTime,
+  [FilterType.CLOSED_OPEN]: filterClosedOpen,
+  [FilterType.STRING_SEARCH]: filterStringSearch,
+};
+
+function filterIn(filterValues: unknown[], featureValue: unknown): boolean {
+  return filterValues.includes(featureValue);
+}
+
+// FilterTypes.BETWEEN
+function filterBetween(
+  filterValues: unknown[],
+  featureValue: unknown
+): boolean {
+  const checkRange = (range: [number, number]) => {
+    const [lowerBound, upperBound] = range;
+    return (
+      (featureValue as number) >= lowerBound &&
+      (featureValue as number) <= upperBound
+    );
+  };
+
+  return makeIntervalComplete(filterValues as FilterInterval[]).some(
+    checkRange
+  );
+}
+
+function filterTime(filterValues: unknown[], featureValue: unknown) {
+  const featureValueAsTimestamp = new Date(featureValue as number).getTime();
+  if (isFinite(featureValueAsTimestamp)) {
+    return filterBetween(filterValues, featureValueAsTimestamp);
+  } else {
+    throw new Error(`Column used to filter by time isn't well formatted.`);
+  }
+}
+
+// FilterTypes.CLOSED_OPEN
+function filterClosedOpen(
+  filterValues: unknown[],
+  featureValue: unknown
+): boolean {
+  const checkRange = (range: [number, number]) => {
+    const [lowerBound, upperBound] = range;
+    return (
+      (featureValue as number) >= lowerBound &&
+      (featureValue as number) < upperBound
+    );
+  };
+
+  return makeIntervalComplete(filterValues as [number, number][]).some(
+    checkRange
+  );
+}
+
+// FilterTypes.STRING_SEARCH
+function filterStringSearch(
+  filterValues: unknown[],
+  featureValue: unknown,
+  params: StringSearchOptions = {}
+): boolean {
+  const normalizedFeatureValue = normalize(featureValue, params);
+  const stringRegExp = params.useRegExp
+    ? filterValues
+    : filterValues.map((filterValue) => {
+        let stringRegExp = escapeRegExp(normalize(filterValue, params));
+
+        if (params.mustStart) stringRegExp = `^${stringRegExp}`;
+        if (params.mustEnd) stringRegExp = `${stringRegExp}$`;
+
+        return stringRegExp;
+      });
+
+  const regex = new RegExp(
+    stringRegExp.join('|'),
+    params.caseSensitive ? 'g' : 'gi'
+  );
+  return !!normalizedFeatureValue.match(regex);
+}
+
+// Aux
+const specialCharRegExp = /[.*+?^${}()|[\]\\]/g;
+const normalizeRegExp = /\p{Diacritic}/gu;
+
+function escapeRegExp(value: string) {
+  return value.replace(specialCharRegExp, '\\$&');
+}
+
+function normalize(data: unknown, params: StringSearchOptions) {
+  let normalizedData = String(data);
+  if (!params.keepSpecialCharacters)
+    normalizedData = normalizedData
+      .normalize('NFD')
+      .replace(normalizeRegExp, '');
+
+  return normalizedData;
+}

package/src/filters/geosjonFeatures.ts

@@ -0,0 +1,32 @@
+import intersects from '@turf/boolean-intersects';
+import {FeatureCollection} from 'geojson';
+import {SpatialFilter} from '..';
+import {FeatureData} from '../types-internal';
+
+export function geojsonFeatures({
+  geojson,
+  spatialFilter,
+  uniqueIdProperty,
+}: {
+  geojson: FeatureCollection;
+  spatialFilter: SpatialFilter;
+  uniqueIdProperty?: string;
+}): FeatureData[] {
+  let uniqueIdx = 0;
+  const map = new Map();
+
+  if (!spatialFilter) {
+    return [];
+  }
+
+  for (const feature of geojson.features) {
+    const uniqueId = uniqueIdProperty
+      ? feature.properties![uniqueIdProperty]
+      : ++uniqueIdx;
+    if (!map.has(uniqueId) && intersects(spatialFilter, feature)) {
+      map.set(uniqueId, feature.properties);
+    }
+  }
+
+  return Array.from(map.values());
+}

package/src/filters/index.ts

@@ -0,0 +1,6 @@
+export * from './Filter.js';
+export * from './FilterTypes.js';
+export * from './geosjonFeatures.js';
+export * from './tileFeatures.js';
+export * from './tileFeaturesGeometries.js';
+export * from './tileFeaturesSpatialIndex.js';

package/src/filters/tileFeatures.ts

@@ -0,0 +1,56 @@
+import {SpatialFilter, SpatialIndexTile, Tile} from '../types';
+import {tileFeaturesGeometries} from './tileFeaturesGeometries';
+import {tileFeaturesSpatialIndex} from './tileFeaturesSpatialIndex';
+import {SpatialIndex, TileFormat} from '../constants';
+import {DEFAULT_GEO_COLUMN} from '../constants-internal';
+import {FeatureData} from '../types-internal';
+import {SpatialDataType} from '../sources/types';
+
+/** @internalRemarks Source: @carto/react-core */
+export type TileFeatures = {
+  tiles: Tile[];
+  tileFormat: TileFormat;
+  spatialDataType: SpatialDataType;
+  spatialDataColumn?: string;
+  spatialFilter?: SpatialFilter;
+  uniqueIdProperty?: string;
+  options?: TileFeatureExtractOptions;
+};
+
+/** @internalRemarks Source: @carto/react-core */
+export type TileFeatureExtractOptions = {
+  storeGeometry?: boolean;
+};
+
+/** @internalRemarks Source: @carto/react-core */
+export function tileFeatures({
+  tiles,
+  spatialFilter,
+  uniqueIdProperty,
+  tileFormat,
+  spatialDataColumn = DEFAULT_GEO_COLUMN,
+  spatialDataType,
+  options = {},
+}: TileFeatures): FeatureData[] {
+  // TODO(cleanup): Is an empty response the expected result when spatialFilter
+  // is omitted? Why not make the parameter required, or return the full input?
+  if (!spatialFilter) {
+    return [];
+  }
+
+  if (spatialDataType !== 'geo') {
+    return tileFeaturesSpatialIndex({
+      tiles: tiles as SpatialIndexTile[],
+      spatialFilter,
+      spatialDataColumn,
+      spatialDataType,
+    });
+  }
+  return tileFeaturesGeometries({
+    tiles,
+    tileFormat,
+    spatialFilter,
+    uniqueIdProperty,
+    options,
+  });
+}