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

package/build/api-client.cjs

@@ -1,67 +1,1424 @@
-var bboxClip = require('@turf/bbox-clip');
+var intersects = require('@turf/boolean-intersects');
 var bboxPolygon = require('@turf/bbox-polygon');
+var booleanWithin = require('@turf/boolean-within');
+var intersect = require('@turf/intersect');
+var helpers = require('@turf/helpers');
+var bboxClip = require('@turf/bbox-clip');
+var h3Js = require('h3-js');
 var union = require('@turf/union');
 var invariant = require('@turf/invariant');
-var helpers = require('@turf/helpers');
+var booleanEqual = require('@turf/boolean-equal');
 
 /**
  * @internal
- * @internalRemarks Source: @carto/react-core, @carto/constants, @deck.gl/carto
+ * @privateRemarks Source: @carto/react-core, @carto/constants, @deck.gl/carto
  */
 let client = 'deck-gl-carto';
 /**
  * Returns current client ID, used to categorize API requests. For internal use only.
  *
  * @internal
- * @internalRemarks Source: @carto/react-core
+ * @privateRemarks Source: @carto/react-core
  */
 function getClient() {
   return client;
 }
-/**
- * Sets current client ID, used to categorize API requests. For internal use only.
- *
- * @internal
- * @internalRemarks Source: @carto/react-core
- */
-function setClient(c) {
-  client = c;
+/**
+ * Sets current client ID, used to categorize API requests. For internal use only.
+ *
+ * @internal
+ * @privateRemarks Source: @carto/react-core
+ */
+function setClient(c) {
+  client = c;
+}
+
+/**
+ * Defines a comparator used when matching a column's values against given filter values.
+ *
+ * Example:
+ *
+ * ```javascript
+ * import { FilterType } from '@carto/api-client';
+ * const filters = {
+ *   column_name: { [FilterType.IN]: { values: ['a', 'b', 'c'] } }
+ * };
+ * ```
+ *
+ * @privateRemarks Source: @carto/react-api, @deck.gl/carto
+ */
+exports.FilterType = void 0;
+(function (FilterType) {
+  FilterType["IN"] = "in";
+  /** [a, b] both are included. */
+  FilterType["BETWEEN"] = "between";
+  /** [a, b) a is included, b is not. */
+  FilterType["CLOSED_OPEN"] = "closed_open";
+  FilterType["TIME"] = "time";
+  FilterType["STRING_SEARCH"] = "stringSearch";
+})(exports.FilterType || (exports.FilterType = {}));
+/** @privateRemarks Source: @carto/constants */
+exports.ApiVersion = void 0;
+(function (ApiVersion) {
+  ApiVersion["V1"] = "v1";
+  ApiVersion["V2"] = "v2";
+  ApiVersion["V3"] = "v3";
+})(exports.ApiVersion || (exports.ApiVersion = {}));
+/** @privateRemarks Source: @carto/constants, @deck.gl/carto */
+const DEFAULT_API_BASE_URL = 'https://gcp-us-east1.api.carto.com';
+/** @privateRemarks Source: @carto/react-core */
+exports.TileFormat = void 0;
+(function (TileFormat) {
+  TileFormat["MVT"] = "mvt";
+  TileFormat["JSON"] = "json";
+  TileFormat["GEOJSON"] = "geojson";
+  TileFormat["BINARY"] = "binary";
+})(exports.TileFormat || (exports.TileFormat = {}));
+/** @privateRemarks Source: @carto/react-core */
+exports.SpatialIndex = void 0;
+(function (SpatialIndex) {
+  SpatialIndex["H3"] = "h3";
+  SpatialIndex["S2"] = "s2";
+  SpatialIndex["QUADBIN"] = "quadbin";
+})(exports.SpatialIndex || (exports.SpatialIndex = {}));
+/** @privateRemarks Source: @carto/react-core */
+exports.Provider = void 0;
+(function (Provider) {
+  Provider["BIGQUERY"] = "bigquery";
+  Provider["REDSHIFT"] = "redshift";
+  Provider["POSTGRES"] = "postgres";
+  Provider["SNOWFLAKE"] = "snowflake";
+  Provider["DATABRICKS"] = "databricks";
+  Provider["DATABRICKS_REST"] = "databricksRest";
+})(exports.Provider || (exports.Provider = {}));
+
+function makeIntervalComplete(intervals) {
+  return intervals.map(val => {
+    if (val[0] === undefined || val[0] === null) {
+      return [Number.MIN_SAFE_INTEGER, val[1]];
+    }
+    if (val[1] === undefined || val[1] === null) {
+      return [val[0], Number.MAX_SAFE_INTEGER];
+    }
+    return val;
+  });
+}
+
+const filterFunctions = {
+  [exports.FilterType.IN]: filterIn,
+  [exports.FilterType.BETWEEN]: filterBetween,
+  [exports.FilterType.TIME]: filterTime,
+  [exports.FilterType.CLOSED_OPEN]: filterClosedOpen,
+  [exports.FilterType.STRING_SEARCH]: filterStringSearch
+};
+function filterIn(filterValues, featureValue) {
+  return filterValues.includes(featureValue);
+}
+// FilterTypes.BETWEEN
+function filterBetween(filterValues, featureValue) {
+  const checkRange = range => {
+    const [lowerBound, upperBound] = range;
+    return featureValue >= lowerBound && featureValue <= upperBound;
+  };
+  return makeIntervalComplete(filterValues).some(checkRange);
+}
+function filterTime(filterValues, featureValue) {
+  const featureValueAsTimestamp = new Date(featureValue).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, featureValue) {
+  const checkRange = range => {
+    const [lowerBound, upperBound] = range;
+    return featureValue >= lowerBound && featureValue < upperBound;
+  };
+  return makeIntervalComplete(filterValues).some(checkRange);
+}
+// FilterTypes.STRING_SEARCH
+function filterStringSearch(filterValues, featureValue, params) {
+  if (params === void 0) {
+    params = {};
+  }
+  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) {
+  return value.replace(specialCharRegExp, '\\$&');
+}
+function normalize(data, params) {
+  let normalizedData = String(data);
+  if (!params.keepSpecialCharacters) normalizedData = normalizedData.normalize('NFD').replace(normalizeRegExp, '');
+  return normalizedData;
+}
+
+const LOGICAL_OPERATOR_METHODS = {
+  and: 'every',
+  or: 'some'
+};
+function passesFilter(columns, filters, feature, filtersLogicalOperator) {
+  const method = LOGICAL_OPERATOR_METHODS[filtersLogicalOperator];
+  return columns[method](column => {
+    const columnFilters = filters[column];
+    const columnFilterTypes = Object.keys(columnFilters);
+    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].params);
+    });
+  });
+}
+/**
+ * @internal
+ * @privateRemarks Exported for use in @deck.gl/carto's getDataFilterExtensionProps.
+ */
+function _buildFeatureFilter(_ref) {
+  let {
+    filters = {},
+    type = 'boolean',
+    filtersLogicalOperator = 'and'
+  } = _ref;
+  const columns = Object.keys(filters);
+  if (!columns.length) {
+    return () => type === 'number' ? 1 : true;
+  }
+  return feature => {
+    const f = feature.properties || feature;
+    const featurePassesFilter = passesFilter(columns, filters, f, filtersLogicalOperator);
+    return type === 'number' ? Number(featurePassesFilter) : featurePassesFilter;
+  };
+}
+/**
+ * Apply certain filters to a collection of features.
+ * @internal
+ */
+function applyFilters(features, filters, filtersLogicalOperator) {
+  return Object.keys(filters).length ? features.filter(_buildFeatureFilter({
+    filters,
+    filtersLogicalOperator
+  })) : features;
+}
+/**
+ * Binary.
+ * @internal
+ */
+function buildBinaryFeatureFilter(_ref2) {
+  let {
+    filters = {}
+  } = _ref2;
+  const columns = Object.keys(filters);
+  if (!columns.length) {
+    return () => 1;
+  }
+  return (featureIdIdx, binaryData) => passesFilterUsingBinary(columns, filters, featureIdIdx, binaryData);
+}
+function getValueFromNumericProps(featureIdIdx, binaryData, _ref3) {
+  let {
+    column
+  } = _ref3;
+  return binaryData.numericProps?.[column]?.value[featureIdIdx];
+}
+function getValueFromProperties(featureIdIdx, binaryData, _ref4) {
+  let {
+    column
+  } = _ref4;
+  const propertyIdx = binaryData.featureIds.value[featureIdIdx];
+  return binaryData.properties[propertyIdx]?.[column];
+}
+const GET_VALUE_BY_BINARY_PROP = {
+  properties: getValueFromProperties,
+  numericProps: getValueFromNumericProps
+};
+function getBinaryPropertyByFilterValues(filterValues) {
+  return typeof filterValues.flat()[0] === 'string' ? 'properties' : 'numericProps';
+}
+function getFeatureValue(featureIdIdx, binaryData, filter) {
+  const {
+    column,
+    values
+  } = filter;
+  const binaryProp = getBinaryPropertyByFilterValues(values);
+  const getFeatureValueFn = GET_VALUE_BY_BINARY_PROP[binaryProp];
+  return getFeatureValueFn(featureIdIdx, binaryData, {
+    column
+  });
+}
+function passesFilterUsingBinary(columns, filters, featureIdIdx, binaryData) {
+  return columns.every(column => {
+    const columnFilters = filters[column];
+    return Object.entries(columnFilters).every(_ref5 => {
+      let [type, {
+        values
+      }] = _ref5;
+      const filterFn = filterFunctions[type];
+      if (!filterFn) {
+        throw new Error(`"${type}" filter is not implemented.`);
+      }
+      if (!values) return 0;
+      const featureValue = getFeatureValue(featureIdIdx, binaryData, {
+        type: type,
+        column,
+        values
+      });
+      if (featureValue === undefined || featureValue === null) return 0;
+      return filterFn(values, featureValue);
+    });
+  });
+}
+
+function geojsonFeatures(_ref) {
+  let {
+    geojson,
+    spatialFilter,
+    uniqueIdProperty
+  } = _ref;
+  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());
+}
+
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const DEFAULT_CONFIG = {
+  EPSILON: 1e-12,
+  debug: false,
+  precision: 4,
+  printTypes: false,
+  printDegrees: false,
+  printRowMajor: true,
+  _cartographicRadians: false
+};
+// Configuration is truly global as of v3.6 to ensure single config even if multiple copies of math.gl
+// Multiple copies of config can be quite tricky to debug...
+globalThis.mathgl = globalThis.mathgl || {
+  config: {
+    ...DEFAULT_CONFIG
+  }
+};
+/**
+ * Check if value is an "array"
+ * Returns `true` if value is either an array or a typed array
+ * Note: returns `false` for `ArrayBuffer` and `DataView` instances
+ * @note isTypedArray and isNumericArray are often more useful in TypeScript
+ */
+function isArray(value) {
+  return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+function lerp(a, b, t) {
+  if (isArray(a)) {
+    return a.map((ai, i) => lerp(ai, b[i], t));
+  }
+  return t * b + (1 - t) * a;
+}
+
+// Replacement for the external assert method to reduce bundle size
+// Note: We don't use the second "message" argument in calling code,
+// so no need to support it here
+function assert$1(condition, message) {
+  if (!condition) {
+    throw new Error(message || '@math.gl/web-mercator: assertion failed.');
+  }
+}
+
+// TODO - THE UTILITIES IN THIS FILE SHOULD BE IMPORTED FROM WEB-MERCATOR-VIEWPORT MODULE
+// CONSTANTS
+const PI = Math.PI;
+const PI_4 = PI / 4;
+const DEGREES_TO_RADIANS = PI / 180;
+const RADIANS_TO_DEGREES = 180 / PI;
+const TILE_SIZE = 512;
+/**
+ * Project [lng,lat] on sphere onto [x,y] on 512*512 Mercator Zoom 0 tile.
+ * Performs the nonlinear part of the web mercator projection.
+ * Remaining projection is done with 4x4 matrices which also handles
+ * perspective.
+ *
+ * @param lngLat - [lng, lat] coordinates
+ *   Specifies a point on the sphere to project onto the map.
+ * @return [x,y] coordinates.
+ */
+function lngLatToWorld(lngLat) {
+  const [lng, lat] = lngLat;
+  assert$1(Number.isFinite(lng));
+  assert$1(Number.isFinite(lat) && lat >= -90 && lat <= 90, 'invalid latitude');
+  const lambda2 = lng * DEGREES_TO_RADIANS;
+  const phi2 = lat * DEGREES_TO_RADIANS;
+  const x = TILE_SIZE * (lambda2 + PI) / (2 * PI);
+  const y = TILE_SIZE * (PI + Math.log(Math.tan(PI_4 + phi2 * 0.5))) / (2 * PI);
+  return [x, y];
+}
+/**
+ * Unproject world point [x,y] on map onto {lat, lon} on sphere
+ *
+ * @param xy - array with [x,y] members
+ *  representing point on projected map plane
+ * @return - array with [x,y] of point on sphere.
+ *   Has toArray method if you need a GeoJSON Array.
+ *   Per cartographic tradition, lat and lon are specified as degrees.
+ */
+function worldToLngLat(xy) {
+  const [x, y] = xy;
+  const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
+  const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
+  return [lambda2 * RADIANS_TO_DEGREES, phi2 * RADIANS_TO_DEGREES];
+}
+
+const TRANSFORM_FN$1 = {
+  Point: transformPoint$1,
+  MultiPoint: transformMultiPoint$1,
+  LineString: transformLineString$1,
+  MultiLineString: transformMultiLineString$1,
+  Polygon: transformPolygon$1,
+  MultiPolygon: transformMultiPolygon$1
+};
+/**
+ * Transform WGS84 coordinates to tile coords.
+ * It's the inverse of deck.gl coordinate-transform (https://github.com/visgl/deck.gl/blob/master/modules/geo-layers/src/mvt-layer/coordinate-transform.js)
+ *
+ * @param geometry - any valid geojson geometry
+ * @param bbox - geojson bbox
+ */
+function transformToTileCoords(geometry, bbox) {
+  const [west, south, east, north] = bbox;
+  const nw = projectFlat([west, north]);
+  const se = projectFlat([east, south]);
+  const projectedBbox = [nw, se];
+  if (geometry.type === 'GeometryCollection') {
+    throw new Error('Unsupported geometry type GeometryCollection');
+  }
+  const transformFn = TRANSFORM_FN$1[geometry.type];
+  const coordinates = transformFn(geometry.coordinates, projectedBbox);
+  return {
+    ...geometry,
+    coordinates
+  };
+}
+function transformPoint$1(_ref, _ref2) {
+  let [pointX, pointY] = _ref;
+  let [nw, se] = _ref2;
+  const x = inverseLerp(nw[0], se[0], pointX);
+  const y = inverseLerp(nw[1], se[1], pointY);
+  return [x, y];
+}
+function getPoints$1(geometry, bbox) {
+  return geometry.map(g => transformPoint$1(projectFlat(g), bbox));
+}
+function transformMultiPoint$1(multiPoint, bbox) {
+  return getPoints$1(multiPoint, bbox);
+}
+function transformLineString$1(line, bbox) {
+  return getPoints$1(line, bbox);
+}
+function transformMultiLineString$1(multiLineString, bbox) {
+  return multiLineString.map(lineString => transformLineString$1(lineString, bbox));
+}
+function transformPolygon$1(polygon, bbox) {
+  return polygon.map(polygonRing => getPoints$1(polygonRing, bbox));
+}
+function transformMultiPolygon$1(multiPolygon, bbox) {
+  return multiPolygon.map(polygon => transformPolygon$1(polygon, bbox));
+}
+function projectFlat(xyz) {
+  return lngLatToWorld(xyz);
+}
+function inverseLerp(a, b, x) {
+  return (x - a) / (b - a);
+}
+
+const TRANSFORM_FN = {
+  Point: transformPoint,
+  MultiPoint: transformMultiPoint,
+  LineString: transformLineString,
+  MultiLineString: transformMultiLineString,
+  Polygon: transformPolygon,
+  MultiPolygon: transformMultiPolygon
+};
+/**
+ * Transform tile coords to WGS84 coordinates.
+ *
+ * @param geometry - any valid geojson geometry
+ * @param bbox - geojson bbox
+ */
+function transformTileCoordsToWGS84(geometry, bbox) {
+  const [west, south, east, north] = bbox;
+  const nw = lngLatToWorld([west, north]);
+  const se = lngLatToWorld([east, south]);
+  const projectedBbox = [nw, se];
+  if (geometry.type === 'GeometryCollection') {
+    throw new Error('Unsupported geometry type GeometryCollection');
+  }
+  const transformFn = TRANSFORM_FN[geometry.type];
+  const coordinates = transformFn(geometry.coordinates, projectedBbox);
+  return {
+    ...geometry,
+    coordinates
+  };
+}
+function transformPoint(_ref, _ref2) {
+  let [pointX, pointY] = _ref;
+  let [nw, se] = _ref2;
+  const x = lerp(nw[0], se[0], pointX);
+  const y = lerp(nw[1], se[1], pointY);
+  return worldToLngLat([x, y]);
+}
+function getPoints(geometry, bbox) {
+  return geometry.map(g => transformPoint(g, bbox));
+}
+function transformMultiPoint(multiPoint, bbox) {
+  return getPoints(multiPoint, bbox);
+}
+function transformLineString(line, bbox) {
+  return getPoints(line, bbox);
+}
+function transformMultiLineString(multiLineString, bbox) {
+  return multiLineString.map(lineString => transformLineString(lineString, bbox));
+}
+function transformPolygon(polygon, bbox) {
+  return polygon.map(polygonRing => getPoints(polygonRing, bbox));
+}
+function transformMultiPolygon(multiPolygon, bbox) {
+  return multiPolygon.map(polygon => transformPolygon(polygon, bbox));
+}
+
+const FEATURE_GEOM_PROPERTY = '__geomValue';
+function tileFeaturesGeometries(_ref) {
+  let {
+    tiles,
+    tileFormat,
+    spatialFilter,
+    uniqueIdProperty,
+    options
+  } = _ref;
+  const map = new Map();
+  for (const tile of tiles) {
+    // Discard if it's not a visible tile (only check false value, not undefined)
+    // or tile has not data
+    if (tile.isVisible === false || !tile.data) {
+      continue;
+    }
+    const bbox = [tile.bbox.west, tile.bbox.south, tile.bbox.east, tile.bbox.north];
+    const bboxToGeom = bboxPolygon(bbox);
+    const tileIsFullyVisible = booleanWithin(bboxToGeom, spatialFilter);
+    // Clip the geometry to intersect with the tile
+    const spatialFilterFeature = {
+      type: 'Feature',
+      geometry: spatialFilter,
+      properties: {}
+    };
+    const clippedGeometryToIntersect = intersect(helpers.featureCollection([bboxToGeom, spatialFilterFeature]));
+    if (!clippedGeometryToIntersect) {
+      continue;
+    }
+    // We assume that MVT tileFormat uses local coordinates so we transform the geometry to intersect to tile coordinates [0..1],
+    // while in the case of 'geojson' or binary, the geometries are already in WGS84
+    const transformedGeometryToIntersect = tileFormat === exports.TileFormat.MVT ? transformToTileCoords(clippedGeometryToIntersect.geometry, bbox) : clippedGeometryToIntersect.geometry;
+    createIndicesForPoints(tile.data.points);
+    calculateFeatures({
+      map,
+      tileIsFullyVisible,
+      geometryIntersection: transformedGeometryToIntersect,
+      data: tile.data.points,
+      type: 'Point',
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      options
+    });
+    calculateFeatures({
+      map,
+      tileIsFullyVisible,
+      geometryIntersection: transformedGeometryToIntersect,
+      data: tile.data.lines,
+      type: 'LineString',
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      options
+    });
+    calculateFeatures({
+      map,
+      tileIsFullyVisible,
+      geometryIntersection: transformedGeometryToIntersect,
+      data: tile.data.polygons,
+      type: 'Polygon',
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      options
+    });
+  }
+  return Array.from(map.values());
+}
+function processTileFeatureProperties(_ref2) {
+  let {
+    map,
+    data,
+    startIndex,
+    endIndex,
+    type,
+    bbox,
+    tileFormat,
+    uniqueIdProperty,
+    storeGeometry,
+    geometryIntersection
+  } = _ref2;
+  const tileProps = getPropertiesFromTile(data, startIndex);
+  const uniquePropertyValue = getUniquePropertyValue(tileProps, uniqueIdProperty, map);
+  if (!uniquePropertyValue || map.has(uniquePropertyValue)) {
+    return;
+  }
+  let geometry = null;
+  // Only calculate geometry if necessary
+  if (storeGeometry || geometryIntersection) {
+    const {
+      positions
+    } = data;
+    const ringCoordinates = getRingCoordinatesFor(startIndex, endIndex, positions);
+    geometry = getFeatureByType(ringCoordinates, type);
+  }
+  // If intersection is required, check before proceeding
+  if (geometry && geometryIntersection && !intersects(geometry, geometryIntersection)) {
+    return;
+  }
+  const properties = parseProperties(tileProps);
+  // Only save geometry if necessary
+  if (storeGeometry && geometry) {
+    properties[FEATURE_GEOM_PROPERTY] = tileFormat === exports.TileFormat.MVT ? transformTileCoordsToWGS84(geometry, bbox) : geometry;
+  }
+  map.set(uniquePropertyValue, properties);
+}
+function addIntersectedFeaturesInTile(_ref3) {
+  let {
+    map,
+    data,
+    geometryIntersection,
+    type,
+    bbox,
+    tileFormat,
+    uniqueIdProperty,
+    options
+  } = _ref3;
+  const indices = getIndices(data);
+  const storeGeometry = options?.storeGeometry || false;
+  for (let i = 0; i < indices.length - 1; i++) {
+    const startIndex = indices[i];
+    const endIndex = indices[i + 1];
+    processTileFeatureProperties({
+      map,
+      data,
+      startIndex,
+      endIndex,
+      type,
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      storeGeometry,
+      geometryIntersection
+    });
+  }
+}
+function getIndices(data) {
+  let indices;
+  switch (data.type) {
+    case 'Point':
+      // @ts-expect-error Missing or changed types?
+      indices = data.pointIndices;
+      break;
+    case 'LineString':
+      indices = data.pathIndices;
+      break;
+    case 'Polygon':
+      indices = data.primitivePolygonIndices;
+      break;
+    default:
+      throw new Error(`Unexpected type, "${data.type}"`);
+  }
+  return indices.value;
+}
+function getFeatureId(data, startIndex) {
+  return data.featureIds.value[startIndex];
+}
+function getPropertiesFromTile(data, startIndex) {
+  const featureId = getFeatureId(data, startIndex);
+  const {
+    properties,
+    numericProps,
+    fields
+  } = data;
+  const result = {
+    uniqueId: fields?.[featureId]?.id,
+    properties: properties[featureId],
+    numericProps: {}
+  };
+  for (const key in numericProps) {
+    result.numericProps[key] = numericProps[key].value[startIndex];
+  }
+  return result;
+}
+function parseProperties(tileProps) {
+  const {
+    properties,
+    numericProps
+  } = tileProps;
+  return Object.assign({}, properties, numericProps);
+}
+function getUniquePropertyValue(tileProps, uniqueIdProperty, map) {
+  if (uniqueIdProperty) {
+    return getValueFromTileProps(tileProps, uniqueIdProperty);
+  }
+  if (tileProps.uniqueId) {
+    return tileProps.uniqueId;
+  }
+  const artificialId = map.size + 1; // a counter, assumed as a valid new id
+  return getValueFromTileProps(tileProps, 'cartodb_id') || getValueFromTileProps(tileProps, 'geoid') || artificialId;
+}
+function getValueFromTileProps(tileProps, propertyName) {
+  const {
+    properties,
+    numericProps
+  } = tileProps;
+  return numericProps[propertyName] || properties[propertyName];
+}
+function getFeatureByType(coordinates, type) {
+  switch (type) {
+    case 'Polygon':
+      return {
+        type: 'Polygon',
+        coordinates: [coordinates]
+      };
+    case 'LineString':
+      return {
+        type: 'LineString',
+        coordinates
+      };
+    case 'Point':
+      return {
+        type: 'Point',
+        coordinates: coordinates[0]
+      };
+    default:
+      throw new Error('Invalid geometry type');
+  }
+}
+function getRingCoordinatesFor(startIndex, endIndex, positions) {
+  const ringCoordinates = [];
+  for (let j = startIndex; j < endIndex; j++) {
+    ringCoordinates.push(Array.from(positions.value.subarray(j * positions.size, (j + 1) * positions.size)));
+  }
+  return ringCoordinates;
+}
+function calculateFeatures(_ref4) {
+  let {
+    map,
+    tileIsFullyVisible,
+    geometryIntersection,
+    data,
+    type,
+    bbox,
+    tileFormat,
+    uniqueIdProperty,
+    options
+  } = _ref4;
+  if (!data?.properties.length) {
+    return;
+  }
+  if (tileIsFullyVisible) {
+    addAllFeaturesInTile({
+      map,
+      data,
+      type,
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      options
+    });
+  } else {
+    addIntersectedFeaturesInTile({
+      map,
+      data,
+      geometryIntersection,
+      type,
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      options
+    });
+  }
+}
+function addAllFeaturesInTile(_ref5) {
+  let {
+    map,
+    data,
+    type,
+    bbox,
+    tileFormat,
+    uniqueIdProperty,
+    options
+  } = _ref5;
+  const indices = getIndices(data);
+  const storeGeometry = options?.storeGeometry || false;
+  for (let i = 0; i < indices.length - 1; i++) {
+    const startIndex = indices[i];
+    const endIndex = indices[i + 1];
+    processTileFeatureProperties({
+      map,
+      data,
+      startIndex,
+      endIndex,
+      type,
+      bbox,
+      tileFormat,
+      uniqueIdProperty,
+      storeGeometry
+    });
+  }
+}
+function createIndicesForPoints(data) {
+  const featureIds = data.featureIds.value;
+  const lastFeatureId = featureIds[featureIds.length - 1];
+  const PointIndicesArray = featureIds.constructor;
+  const pointIndices = {
+    value: new PointIndicesArray(featureIds.length + 1),
+    size: 1
+  };
+  pointIndices.value.set(featureIds);
+  pointIndices.value.set([lastFeatureId + 1], featureIds.length);
+  // @ts-expect-error Missing or changed types?
+  data.pointIndices = pointIndices;
+}
+
+// a tile is an array [x,y,z]
+var d2r = Math.PI / 180,
+  r2d = 180 / Math.PI;
+function tileToBBOX(tile) {
+  var e = tile2lon(tile[0] + 1, tile[2]);
+  var w = tile2lon(tile[0], tile[2]);
+  var s = tile2lat(tile[1] + 1, tile[2]);
+  var n = tile2lat(tile[1], tile[2]);
+  return [w, s, e, n];
+}
+function tileToGeoJSON(tile) {
+  var bbox = tileToBBOX(tile);
+  var poly = {
+    type: 'Polygon',
+    coordinates: [[[bbox[0], bbox[1]], [bbox[0], bbox[3]], [bbox[2], bbox[3]], [bbox[2], bbox[1]], [bbox[0], bbox[1]]]]
+  };
+  return poly;
+}
+function tile2lon(x, z) {
+  return x / Math.pow(2, z) * 360 - 180;
+}
+function tile2lat(y, z) {
+  var n = Math.PI - 2 * Math.PI * y / Math.pow(2, z);
+  return r2d * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
+}
+function pointToTile(lon, lat, z) {
+  var tile = pointToTileFraction(lon, lat, z);
+  tile[0] = Math.floor(tile[0]);
+  tile[1] = Math.floor(tile[1]);
+  return tile;
+}
+function getChildren(tile) {
+  return [[tile[0] * 2, tile[1] * 2, tile[2] + 1], [tile[0] * 2 + 1, tile[1] * 2, tile[2] + 1], [tile[0] * 2 + 1, tile[1] * 2 + 1, tile[2] + 1], [tile[0] * 2, tile[1] * 2 + 1, tile[2] + 1]];
+}
+function getParent(tile) {
+  // top left
+  if (tile[0] % 2 === 0 && tile[1] % 2 === 0) {
+    return [tile[0] / 2, tile[1] / 2, tile[2] - 1];
+  }
+  // bottom left
+  else if (tile[0] % 2 === 0 && !tile[1] % 2 === 0) {
+    return [tile[0] / 2, (tile[1] - 1) / 2, tile[2] - 1];
+  }
+  // top right
+  else if (!tile[0] % 2 === 0 && tile[1] % 2 === 0) {
+    return [(tile[0] - 1) / 2, tile[1] / 2, tile[2] - 1];
+  }
+  // bottom right
+  else {
+    return [(tile[0] - 1) / 2, (tile[1] - 1) / 2, tile[2] - 1];
+  }
+}
+function getSiblings(tile) {
+  return getChildren(getParent(tile));
+}
+function hasSiblings(tile, tiles) {
+  var siblings = getSiblings(tile);
+  for (var i = 0; i < siblings.length; i++) {
+    if (!hasTile(tiles, siblings[i])) return false;
+  }
+  return true;
+}
+function hasTile(tiles, tile) {
+  for (var i = 0; i < tiles.length; i++) {
+    if (tilesEqual(tiles[i], tile)) return true;
+  }
+  return false;
+}
+function tilesEqual(tile1, tile2) {
+  return tile1[0] === tile2[0] && tile1[1] === tile2[1] && tile1[2] === tile2[2];
+}
+function tileToQuadkey(tile) {
+  var index = '';
+  for (var z = tile[2]; z > 0; z--) {
+    var b = 0;
+    var mask = 1 << z - 1;
+    if ((tile[0] & mask) !== 0) b++;
+    if ((tile[1] & mask) !== 0) b += 2;
+    index += b.toString();
+  }
+  return index;
+}
+function quadkeyToTile(quadkey) {
+  var x = 0;
+  var y = 0;
+  var z = quadkey.length;
+  for (var i = z; i > 0; i--) {
+    var mask = 1 << i - 1;
+    switch (quadkey[z - i]) {
+      case '0':
+        break;
+      case '1':
+        x |= mask;
+        break;
+      case '2':
+        y |= mask;
+        break;
+      case '3':
+        x |= mask;
+        y |= mask;
+        break;
+    }
+  }
+  return [x, y, z];
+}
+function bboxToTile(bboxCoords) {
+  var min = pointToTile(bboxCoords[0], bboxCoords[1], 32);
+  var max = pointToTile(bboxCoords[2], bboxCoords[3], 32);
+  var bbox = [min[0], min[1], max[0], max[1]];
+  var z = getBboxZoom(bbox);
+  if (z === 0) return [0, 0, 0];
+  var x = bbox[0] >>> 32 - z;
+  var y = bbox[1] >>> 32 - z;
+  return [x, y, z];
+}
+function getBboxZoom(bbox) {
+  var MAX_ZOOM = 28;
+  for (var z = 0; z < MAX_ZOOM; z++) {
+    var mask = 1 << 32 - (z + 1);
+    if ((bbox[0] & mask) != (bbox[2] & mask) || (bbox[1] & mask) != (bbox[3] & mask)) {
+      return z;
+    }
+  }
+  return MAX_ZOOM;
+}
+function pointToTileFraction(lon, lat, z) {
+  var sin = Math.sin(lat * d2r),
+    z2 = Math.pow(2, z),
+    x = z2 * (lon / 360 + 0.5),
+    y = z2 * (0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI);
+  return [x, y, z];
+}
+var tilebelt = {
+  tileToGeoJSON: tileToGeoJSON,
+  tileToBBOX: tileToBBOX,
+  getChildren: getChildren,
+  getParent: getParent,
+  getSiblings: getSiblings,
+  hasTile: hasTile,
+  hasSiblings: hasSiblings,
+  tilesEqual: tilesEqual,
+  tileToQuadkey: tileToQuadkey,
+  quadkeyToTile: quadkeyToTile,
+  pointToTile: pointToTile,
+  bboxToTile: bboxToTile,
+  pointToTileFraction: pointToTileFraction
+};
+
+/**
+ * Given a geometry, create cells and return them in their raw form,
+ * as an array of cell identifiers.
+ *
+ * @alias tiles
+ * @param {Object} geom GeoJSON geometry
+ * @param {Object} limits an object with min_zoom and max_zoom properties
+ * specifying the minimum and maximum level to be tiled.
+ * @returns {Array<Array<number>>} An array of tiles given as [x, y, z] arrays
+ */
+var tiles = getTiles;
+function getTiles(geom, limits) {
+  var i,
+    tile,
+    coords = geom.coordinates,
+    maxZoom = limits.max_zoom,
+    tileHash = {},
+    tiles = [];
+  if (geom.type === 'Point') {
+    return [tilebelt.pointToTile(coords[0], coords[1], maxZoom)];
+  } else if (geom.type === 'MultiPoint') {
+    for (i = 0; i < coords.length; i++) {
+      tile = tilebelt.pointToTile(coords[i][0], coords[i][1], maxZoom);
+      tileHash[toID(tile[0], tile[1], tile[2])] = true;
+    }
+  } else if (geom.type === 'LineString') {
+    lineCover(tileHash, coords, maxZoom);
+  } else if (geom.type === 'MultiLineString') {
+    for (i = 0; i < coords.length; i++) {
+      lineCover(tileHash, coords[i], maxZoom);
+    }
+  } else if (geom.type === 'Polygon') {
+    polygonCover(tileHash, tiles, coords, maxZoom);
+  } else if (geom.type === 'MultiPolygon') {
+    for (i = 0; i < coords.length; i++) {
+      polygonCover(tileHash, tiles, coords[i], maxZoom);
+    }
+  } else {
+    throw new Error('Geometry type not implemented');
+  }
+  if (limits.min_zoom !== maxZoom) {
+    // sync tile hash and tile array so that both contain the same tiles
+    var len = tiles.length;
+    appendHashTiles(tileHash, tiles);
+    for (i = 0; i < len; i++) {
+      var t = tiles[i];
+      tileHash[toID(t[0], t[1], t[2])] = true;
+    }
+    return mergeTiles(tileHash, tiles, limits);
+  }
+  appendHashTiles(tileHash, tiles);
+  return tiles;
+}
+function mergeTiles(tileHash, tiles, limits) {
+  var mergedTiles = [];
+  for (var z = limits.max_zoom; z > limits.min_zoom; z--) {
+    var parentTileHash = {};
+    var parentTiles = [];
+    for (var i = 0; i < tiles.length; i++) {
+      var t = tiles[i];
+      if (t[0] % 2 === 0 && t[1] % 2 === 0) {
+        var id2 = toID(t[0] + 1, t[1], z),
+          id3 = toID(t[0], t[1] + 1, z),
+          id4 = toID(t[0] + 1, t[1] + 1, z);
+        if (tileHash[id2] && tileHash[id3] && tileHash[id4]) {
+          tileHash[toID(t[0], t[1], t[2])] = false;
+          tileHash[id2] = false;
+          tileHash[id3] = false;
+          tileHash[id4] = false;
+          var parentTile = [t[0] / 2, t[1] / 2, z - 1];
+          if (z - 1 === limits.min_zoom) mergedTiles.push(parentTile);else {
+            parentTileHash[toID(t[0] / 2, t[1] / 2, z - 1)] = true;
+            parentTiles.push(parentTile);
+          }
+        }
+      }
+    }
+    for (i = 0; i < tiles.length; i++) {
+      t = tiles[i];
+      if (tileHash[toID(t[0], t[1], t[2])]) mergedTiles.push(t);
+    }
+    tileHash = parentTileHash;
+    tiles = parentTiles;
+  }
+  return mergedTiles;
+}
+function polygonCover(tileHash, tileArray, geom, zoom) {
+  var intersections = [];
+  for (var i = 0; i < geom.length; i++) {
+    var ring = [];
+    lineCover(tileHash, geom[i], zoom, ring);
+    for (var j = 0, len = ring.length, k = len - 1; j < len; k = j++) {
+      var m = (j + 1) % len;
+      var y = ring[j][1];
+
+      // add interesction if it's not local extremum or duplicate
+      if ((y > ring[k][1] || y > ring[m][1]) && (
+      // not local minimum
+      y < ring[k][1] || y < ring[m][1]) &&
+      // not local maximum
+      y !== ring[m][1]) intersections.push(ring[j]);
+    }
+  }
+  intersections.sort(compareTiles); // sort by y, then x
+
+  for (i = 0; i < intersections.length; i += 2) {
+    // fill tiles between pairs of intersections
+    y = intersections[i][1];
+    for (var x = intersections[i][0] + 1; x < intersections[i + 1][0]; x++) {
+      var id = toID(x, y, zoom);
+      if (!tileHash[id]) {
+        tileArray.push([x, y, zoom]);
+      }
+    }
+  }
+}
+function compareTiles(a, b) {
+  return a[1] - b[1] || a[0] - b[0];
+}
+function lineCover(tileHash, coords, maxZoom, ring) {
+  var prevX, prevY;
+  for (var i = 0; i < coords.length - 1; i++) {
+    var start = tilebelt.pointToTileFraction(coords[i][0], coords[i][1], maxZoom),
+      stop = tilebelt.pointToTileFraction(coords[i + 1][0], coords[i + 1][1], maxZoom),
+      x0 = start[0],
+      y0 = start[1],
+      x1 = stop[0],
+      y1 = stop[1],
+      dx = x1 - x0,
+      dy = y1 - y0;
+    if (dy === 0 && dx === 0) continue;
+    var sx = dx > 0 ? 1 : -1,
+      sy = dy > 0 ? 1 : -1,
+      x = Math.floor(x0),
+      y = Math.floor(y0),
+      tMaxX = dx === 0 ? Infinity : Math.abs(((dx > 0 ? 1 : 0) + x - x0) / dx),
+      tMaxY = dy === 0 ? Infinity : Math.abs(((dy > 0 ? 1 : 0) + y - y0) / dy),
+      tdx = Math.abs(sx / dx),
+      tdy = Math.abs(sy / dy);
+    if (x !== prevX || y !== prevY) {
+      tileHash[toID(x, y, maxZoom)] = true;
+      if (ring && y !== prevY) ring.push([x, y]);
+      prevX = x;
+      prevY = y;
+    }
+    while (tMaxX < 1 || tMaxY < 1) {
+      if (tMaxX < tMaxY) {
+        tMaxX += tdx;
+        x += sx;
+      } else {
+        tMaxY += tdy;
+        y += sy;
+      }
+      tileHash[toID(x, y, maxZoom)] = true;
+      if (ring && y !== prevY) ring.push([x, y]);
+      prevX = x;
+      prevY = y;
+    }
+  }
+  if (ring && y === ring[0][1]) ring.pop();
+}
+function appendHashTiles(hash, tiles) {
+  var keys = Object.keys(hash);
+  for (var i = 0; i < keys.length; i++) {
+    tiles.push(fromID(+keys[i]));
+  }
+}
+function toID(x, y, z) {
+  var dim = 2 * (1 << z);
+  return (dim * y + x) * 32 + z;
+}
+function fromID(id) {
+  var z = id % 32,
+    dim = 2 * (1 << z),
+    xy = (id - z) / 32,
+    x = xy % dim,
+    y = (xy - x) / dim % dim;
+  return [x, y, z];
+}
+
+const B = [0x5555555555555555n, 0x3333333333333333n, 0x0f0f0f0f0f0f0f0fn, 0x00ff00ff00ff00ffn, 0x0000ffff0000ffffn, 0x00000000ffffffffn];
+const S = [0n, 1n, 2n, 4n, 8n, 16n];
+function tileToCell(tile) {
+  if (tile.z < 0 || tile.z > 26) {
+    throw new Error('Wrong zoom');
+  }
+  const z = BigInt(tile.z);
+  let x = BigInt(tile.x) << 32n - z;
+  let y = BigInt(tile.y) << 32n - z;
+  for (let i = 0; i < 5; i++) {
+    const s = S[5 - i];
+    const b = B[4 - i];
+    x = (x | x << s) & b;
+    y = (y | y << s) & b;
+  }
+  const quadbin = 0x4000000000000000n | 1n << 59n |
+  // | (mode << 59) | (mode_dep << 57)
+  z << 52n | (x | y << 1n) >> 12n | 0xfffffffffffffn >> z * 2n;
+  return quadbin;
+}
+function getResolution$1(quadbin) {
+  return quadbin >> 52n & 0x1fn;
+}
+function geometryToCells(geometry, resolution) {
+  const zoom = Number(resolution);
+  return tiles(geometry, {
+    min_zoom: zoom,
+    max_zoom: zoom
+  }).map(([x, y, z]) => tileToCell({
+    x,
+    y,
+    z
+  }));
+}
+
+function tileFeaturesSpatialIndex(_ref) {
+  let {
+    tiles,
+    spatialFilter,
+    spatialDataColumn,
+    spatialDataType
+  } = _ref;
+  const map = new Map();
+  const spatialIndex = getSpatialIndex(spatialDataType);
+  const resolution = getResolution(tiles, spatialIndex);
+  const spatialIndexIDName = spatialDataColumn ? spatialDataColumn : spatialIndex;
+  if (!resolution) {
+    return [];
+  }
+  const cells = getCellsCoverGeometry(spatialFilter, spatialIndex, resolution);
+  if (!cells?.length) {
+    return [];
+  }
+  // We transform cells to Set to improve the performace
+  const cellsSet = new Set(cells);
+  for (const tile of tiles) {
+    if (tile.isVisible === false || !tile.data) {
+      continue;
+    }
+    tile.data.forEach(d => {
+      if (cellsSet.has(d.id)) {
+        map.set(d.id, {
+          ...d.properties,
+          [spatialIndexIDName]: d.id
+        });
+      }
+    });
+  }
+  return Array.from(map.values());
+}
+function getResolution(tiles, spatialIndex) {
+  const data = tiles.find(tile => tile.data?.length)?.data;
+  if (!data) {
+    return;
+  }
+  if (spatialIndex === exports.SpatialIndex.QUADBIN) {
+    return Number(getResolution$1(data[0].id));
+  }
+  if (spatialIndex === exports.SpatialIndex.H3) {
+    return h3Js.getResolution(data[0].id);
+  }
+}
+const bboxWest = [-180, -90, 0, 90];
+const bboxEast = [0, -90, 180, 90];
+function getCellsCoverGeometry(geometry, spatialIndex, resolution) {
+  if (spatialIndex === exports.SpatialIndex.QUADBIN) {
+    // @ts-expect-error TODO: Probably ought to be stricter about number vs. bigint types in this file.
+    return geometryToCells(geometry, resolution);
+  }
+  if (spatialIndex === exports.SpatialIndex.H3) {
+    // The current H3 polyfill algorithm can't deal with polygon segments of greater than 180 degrees longitude
+    // so we clip the geometry to be sure that none of them is greater than 180 degrees
+    // https://github.com/uber/h3-js/issues/24#issuecomment-431893796
+    return h3Js.polygonToCells(bboxClip(geometry, bboxWest).geometry.coordinates, resolution, true).concat(h3Js.polygonToCells(bboxClip(geometry, bboxEast).geometry.coordinates, resolution, true));
+  }
+}
+function getSpatialIndex(spatialDataType) {
+  switch (spatialDataType) {
+    case 'h3':
+      return exports.SpatialIndex.H3;
+    case 'quadbin':
+      return exports.SpatialIndex.QUADBIN;
+    default:
+      throw new Error('Unexpected spatial data type');
+  }
+}
+
+/**
+ * Current version of @carto/api-client.
+ * @internal
+ */
+/** @internal */
+const V3_MINOR_VERSION = '3.4';
+/** @privateRemarks Source: @carto/constants, @deck.gl/carto */
+const DEFAULT_GEO_COLUMN = 'geom';
+/**
+ * Fastly default limit is 8192; leave some padding.
+ * @privateRemarks Source: @deck.gl/carto
+ */
+const DEFAULT_MAX_LENGTH_URL = 7000;
+/** @privateRemarks Source: @deck.gl/carto */
+const DEFAULT_TILE_RESOLUTION = 0.5;
+/**
+ * @privateRemarks Source: @deck.gl/carto
+ * @internal
+ */
+const DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
+/**
+ * @privateRemarks Source: @deck.gl/carto
+ * @internal
+ */
+const DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
+
+/** @privateRemarks Source: @carto/react-core */
+function tileFeatures(_ref) {
+  let {
+    tiles,
+    spatialFilter,
+    uniqueIdProperty,
+    tileFormat,
+    spatialDataColumn = DEFAULT_GEO_COLUMN,
+    spatialDataType,
+    options = {}
+  } = _ref;
+  if (spatialDataType !== 'geo') {
+    return tileFeaturesSpatialIndex({
+      tiles: tiles,
+      spatialFilter,
+      spatialDataColumn,
+      spatialDataType
+    });
+  }
+  return tileFeaturesGeometries({
+    tiles,
+    tileFormat,
+    spatialFilter,
+    uniqueIdProperty,
+    options
+  });
+}
+
+/**
+ * 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;
+/**
+ * Creates props for DataFilterExtension, from `@deck.gl/extensions`, given
+ * 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';
+ *
+ * const layer = new VectorTileLayer({
+ *  data: data,
+ *  extensions: [new DataFilterExtension({filterSize: 4})],
+ *  ...getDataFilterExtensionProps(filters),
+ * });
+ * ```
+ */
+function getDataFilterExtensionProps(filters, filtersLogicalOperator) {
+  const {
+    filtersWithoutTimeType,
+    timeColumn,
+    timeFilter
+  } = getFiltersByType(filters);
+  return {
+    filterRange: getFilterRange(timeFilter, DEFAULT_FILTER_SIZE),
+    updateTriggers: getUpdateTriggers(filtersWithoutTimeType, timeColumn, timeFilter),
+    getFilterValue: getFilterValue(filtersWithoutTimeType, timeColumn, timeFilter, DEFAULT_FILTER_SIZE, filtersLogicalOperator)
+  };
+}
+/** @internal */
+function getFiltersByType(filters) {
+  const filtersWithoutTimeType = {};
+  let timeColumn = null;
+  let timeFilter = null;
+  for (const [column, columnData] of Object.entries(filters)) {
+    for (const [type, typeData] of Object.entries(columnData)) {
+      if (type === exports.FilterType.TIME) {
+        timeColumn = column;
+        timeFilter = typeData;
+      } else {
+        filtersWithoutTimeType[column] = {
+          [type]: typeData
+        };
+      }
+    }
+  }
+  return {
+    filtersWithoutTimeType,
+    timeColumn,
+    timeFilter
+  };
+}
+/** @internal */
+function getFilterRange(timeFilter, filterSize) {
+  const result = Array(filterSize).fill([0, 0]);
+  // According to getFilterValue all filters are resolved as 0 or 1 in the first position of the array
+  // except the time filter value that is resolved with the real value of the feature in the second position of the array
+  result[0] = [1, 1];
+  if (timeFilter) {
+    const offsetBy = timeFilter.params?.offsetBy || 0;
+    result[1] = timeFilter.values[0].map(v => v - offsetBy);
+  }
+  return result;
+}
+/** @internal */
+function getUpdateTriggers(filtersWithoutTimeType, timeColumn, timeFilter) {
+  const result = {
+    ...filtersWithoutTimeType
+  };
+  // We don't want to change the layer UpdateTriggers every time that the time filter changes
+  // because this filter is changed by the time series widget during its animation
+  // so we remove the time filter value from the `updateTriggers`
+  if (timeColumn && timeFilter) {
+    result[timeColumn] = {
+      ...result[timeColumn],
+      offsetBy: timeFilter.params?.offsetBy,
+      [exports.FilterType.TIME]: {} // Allows working with other filters, without an impact on performance.
+    };
+  }
+  return {
+    getFilterValue: JSON.stringify(result)
+  };
+}
+/** @internal */
+function getFilterValue(filtersWithoutTimeType, timeColumn, timeFilter, filterSize, filtersLogicalOperator) {
+  const result = Array(filterSize).fill(0);
+  const featureFilter = _buildFeatureFilter({
+    filters: filtersWithoutTimeType,
+    type: 'number',
+    filtersLogicalOperator
+  });
+  // We evaluate all filters except the time filter using _buildFeatureFilter function.
+  // For the time filter, we return the value of the feature and we will change the getFilterRange result
+  // every time this filter changes
+  return feature => {
+    result[0] = featureFilter(feature);
+    if (timeColumn && timeFilter) {
+      const offsetBy = timeFilter.params?.offsetBy || 0;
+      const f = feature.properties || feature;
+      result[1] = f[timeColumn] - offsetBy;
+    }
+    return result;
+  };
 }
 
-/**
- * Defines a comparator used when matching a column's values against given filter values.
- *
- * Example:
- *
- * ```javascript
- * import { FilterType } from '@carto/api-client';
- * const filters = {
- *   column_name: { [FilterType.IN]: { values: ['a', 'b', 'c'] } }
- * };
- * ```
- *
- * @internalRemarks Source: @carto/react-api, @deck.gl/carto
- */
-exports.FilterType = void 0;
-(function (FilterType) {
-  FilterType["IN"] = "in";
-  /** [a, b] both are included. */
-  FilterType["BETWEEN"] = "between";
-  /** [a, b) a is included, b is not. */
-  FilterType["CLOSED_OPEN"] = "closed_open";
-  FilterType["TIME"] = "time";
-  FilterType["STRING_SEARCH"] = "stringSearch";
-})(exports.FilterType || (exports.FilterType = {}));
-/** @internalRemarks Source: @carto/constants */
-exports.ApiVersion = void 0;
-(function (ApiVersion) {
-  ApiVersion["V1"] = "v1";
-  ApiVersion["V2"] = "v2";
-  ApiVersion["V3"] = "v3";
-})(exports.ApiVersion || (exports.ApiVersion = {}));
-/** @internalRemarks Source: @carto/constants, @deck.gl/carto */
-const DEFAULT_API_BASE_URL = 'https://gcp-us-east1.api.carto.com';
-
 const FILTER_TYPES = new Set(Object.values(exports.FilterType));
 const isFilterType = type => FILTER_TYPES.has(type);
 /**
@@ -88,7 +1445,7 @@ function getApplicableFilters(owner, filters) {
  * Due to each data warehouse having its own behavior with columns,
  * we need to normalize them and transform every key to lowercase.
  *
- * @internalRemarks Source: @carto/react-widgets
+ * @privateRemarks Source: @carto/react-widgets
  * @internal
  */
 function normalizeObjectKeys(el) {
@@ -103,14 +1460,14 @@ function normalizeObjectKeys(el) {
     return acc;
   }, {});
 }
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function assert(condition, message) {
   if (!condition) {
     throw new Error(message);
   }
 }
 /**
- * @internalRemarks Source: @carto/react-core
+ * @privateRemarks Source: @carto/react-core
  * @internal
  */
 class InvalidColumnError extends Error {
@@ -254,7 +1611,7 @@ function createPolygonSpatialFilter(spatialFilter) {
  * Check if a viewport is large enough to represent a global coverage.
  * In this case the spatial filter parameter for widget calculation is removed.
  *
- * @internalRemarks Source: @carto/react-core
+ * @privateRemarks Source: @carto/react-core
  */
 function _isGlobalViewport(viewport) {
   const [minx, miny, maxx, maxy] = viewport;
@@ -267,7 +1624,7 @@ function _isGlobalViewport(viewport) {
  *
  * It results in a Polygon or MultiPolygon strictly inside the validity range.
  *
- * @internalRemarks Source: @carto/react-core
+ * @privateRemarks Source: @carto/react-core
  */
 function _normalizeGeometry(geometry) {
   const WORLD = [-180, -90, +180, +90];
@@ -293,17 +1650,17 @@ function _normalizeGeometry(geometry) {
   }
   return result;
 }
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function _cleanPolygonCoords(cc) {
   const coords = cc.filter(c => c.length > 0);
   return coords.length > 0 ? coords : null;
 }
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function _cleanMultiPolygonCoords(ccc) {
   const coords = ccc.map(_cleanPolygonCoords).filter(cc => cc);
   return coords.length > 0 ? coords : null;
 }
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function _clean(geometry) {
   if (!geometry) {
     return null;
@@ -318,19 +1675,19 @@ function _clean(geometry) {
   }
   return null;
 }
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function _txContourCoords(cc, distance) {
   return cc.map(c => [c[0] + distance, c[1]]);
 }
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function _txPolygonCoords(ccc, distance) {
   return ccc.map(cc => _txContourCoords(cc, distance));
 }
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function _txMultiPolygonCoords(cccc, distance) {
   return cccc.map(ccc => _txPolygonCoords(ccc, distance));
 }
-/** @internalRemarks Source: @carto/react-core */
+/** @privateRemarks Source: @carto/react-core */
 function _tx(geometry, distance) {
   if (geometry && invariant.getType(geometry) === 'Polygon') {
     const coords = _txPolygonCoords(geometry.coordinates, distance);
@@ -349,32 +1706,6 @@ function _isMultiPolygon(geometry) {
   return invariant.getType(geometry) === 'MultiPolygon';
 }
 
-/**
- * Current version of @carto/api-client.
- * @internal
- */
-/** @internal */
-const V3_MINOR_VERSION = '3.4';
-/** @internalRemarks Source: @carto/constants, @deck.gl/carto */
-const DEFAULT_GEO_COLUMN = 'geom';
-/**
- * Fastly default limit is 8192; leave some padding.
- * @internalRemarks Source: @deck.gl/carto
- */
-const DEFAULT_MAX_LENGTH_URL = 7000;
-/** @internalRemarks Source: @deck.gl/carto */
-const DEFAULT_TILE_RESOLUTION = 0.5;
-/**
- * @internalRemarks Source: @deck.gl/carto
- * @internal
- */
-const DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
-/**
- * @internalRemarks Source: @deck.gl/carto
- * @internal
- */
-const DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
-
 // deck.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
@@ -767,12 +2098,106 @@ const boundaryTableSource = function (options) {
   }
 };
 
+const DEFAULT_TILE_SIZE = 512;
+const QUADBIN_ZOOM_MAX_OFFSET = 4;
+function getSpatialFiltersResolution(source, viewState) {
+  const dataResolution = source.dataResolution ?? Number.MAX_VALUE;
+  const aggregationResLevel = source.aggregationResLevel ?? (source.spatialDataType === 'h3' ? DEFAULT_AGGREGATION_RES_LEVEL_H3 : DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN);
+  const aggregationResLevelOffset = Math.max(0, Math.floor(aggregationResLevel));
+  const currentZoomInt = Math.ceil(viewState.zoom);
+  if (source.spatialDataType === 'h3') {
+    const tileSize = DEFAULT_TILE_SIZE;
+    const maxResolutionForZoom = maxH3SpatialFiltersResolutions.find(_ref => {
+      let [zoom] = _ref;
+      return zoom === currentZoomInt;
+    })?.[1] ?? Math.max(0, currentZoomInt - 3);
+    const maxSpatialFiltersResolution = maxResolutionForZoom ? Math.min(dataResolution, maxResolutionForZoom) : dataResolution;
+    const hexagonResolution = _getHexagonResolution(viewState, tileSize) + aggregationResLevelOffset;
+    return Math.min(hexagonResolution, maxSpatialFiltersResolution);
+  }
+  if (source.spatialDataType === 'quadbin') {
+    const maxResolutionForZoom = currentZoomInt + QUADBIN_ZOOM_MAX_OFFSET;
+    const maxSpatialFiltersResolution = Math.min(dataResolution, maxResolutionForZoom);
+    const quadsResolution = Math.floor(viewState.zoom) + aggregationResLevelOffset;
+    return Math.min(quadsResolution, maxSpatialFiltersResolution);
+  }
+  return undefined;
+}
+const maxH3SpatialFiltersResolutions = [[20, 14], [19, 13], [18, 12], [17, 11], [16, 10], [15, 9], [14, 8], [13, 7], [12, 7], [11, 7], [10, 6], [9, 6], [8, 5], [7, 4], [6, 4], [5, 3], [4, 2], [3, 1], [2, 1], [1, 0]];
+// stolen from https://github.com/visgl/deck.gl/blob/master/modules/carto/src/layers/h3-tileset-2d.ts
+// Relative scale factor (0 = no biasing, 2 = a few hexagons cover view)
+const BIAS = 2;
+/**
+ * Resolution conversion function. Takes a WebMercatorViewport and returns
+ * a H3 resolution such that the screen space size of the hexagons is
+ * "similar" to the given tileSize on screen. Intended for use with deck.gl.
+ * @internal
+ */
+function _getHexagonResolution(viewport, tileSize) {
+  // Difference in given tile size compared to deck's internal 512px tile size,
+  // expressed as an offset to the viewport zoom.
+  const zoomOffset = Math.log2(tileSize / DEFAULT_TILE_SIZE);
+  const hexagonScaleFactor = 2 / 3 * (viewport.zoom - zoomOffset);
+  const latitudeScaleFactor = Math.log(1 / Math.cos(Math.PI * viewport.latitude / 180));
+  // Clip and bias
+  return Math.max(0, Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS));
+}
+
+/**
+ * Source for Widget API requests on a data source defined by a SQL query.
+ *
+ * Abstract class. Use {@link WidgetQuerySource} or {@link WidgetTableSource}.
+ */
+class WidgetSource {
+  constructor(props) {
+    this.props = void 0;
+    this.props = {
+      ...WidgetSource.defaultProps,
+      clientId: getClient(),
+      // Refresh clientId, default may have changed.
+      ...props
+    };
+  }
+  _getModelSource(filters, filterOwner) {
+    const props = this.props;
+    return {
+      apiVersion: props.apiVersion,
+      apiBaseUrl: props.apiBaseUrl,
+      clientId: props.clientId,
+      accessToken: props.accessToken,
+      connectionName: props.connectionName,
+      filters: getApplicableFilters(filterOwner, filters || props.filters),
+      filtersLogicalOperator: props.filtersLogicalOperator,
+      spatialDataType: props.spatialDataType,
+      spatialDataColumn: props.spatialDataColumn,
+      dataResolution: props.dataResolution
+    };
+  }
+  _getSpatialFiltersResolution(source, spatialFilter, referenceViewState) {
+    // spatialFiltersResolution applies only to spatial index sources.
+    if (!spatialFilter || source.spatialDataType === 'geo') {
+      return;
+    }
+    if (!referenceViewState) {
+      throw new Error('Missing required option, "spatialIndexReferenceViewState".');
+    }
+    return getSpatialFiltersResolution(source, referenceViewState);
+  }
+}
+WidgetSource.defaultProps = {
+  apiVersion: exports.ApiVersion.V3,
+  apiBaseUrl: DEFAULT_API_BASE_URL,
+  clientId: getClient(),
+  filters: {},
+  filtersLogicalOperator: 'and'
+};
+
 /**
  * Return more descriptive error from API
- * @internalRemarks Source: @carto/react-api
+ * @privateRemarks Source: @carto/react-api
  */
 
-/** @internalRemarks Source: @carto/react-api */
+/** @privateRemarks Source: @carto/react-api */
 
 function _catch(body, recover) {
   try {
@@ -812,13 +2237,14 @@ const makeCall = function (_ref2) {
           Authorization: `Bearer ${accessToken}`,
           ...(isPost && {
             'Content-Type': 'application/json'
-          })
+          }),
+          ...opts.headers
         },
         ...(isPost && {
           method: opts?.method,
           body: opts?.body
         }),
-        signal: opts?.abortController?.signal,
+        signal: opts?.signal,
         ...opts?.otherOptions
       })).then(function (_fetch) {
         response = _fetch;
@@ -852,12 +2278,11 @@ function dealWithApiError(_ref) {
     case 403:
       throw new Error('Forbidden access to the requested data');
     default:
-      const msg = data && data.error && typeof data.error === 'string' ? data.error : JSON.stringify(data?.hint || data.error?.[0]);
-      throw new Error(msg);
+      throw new Error(data && data.error && typeof data.error === 'string' ? data.error : JSON.stringify(data?.hint || data.error?.[0]));
   }
 }
 
-/** @internalRemarks Source: @carto/react-api */
+/** @privateRemarks Source: @carto/react-api */
 const AVAILABLE_MODELS = ['category', 'histogram', 'formula', 'pick', 'timeseries', 'range', 'scatterplot', 'table'];
 const {
   V3
@@ -865,7 +2290,7 @@ const {
 const REQUEST_GET_MAX_URL_LENGTH = 2048;
 /**
  * Execute a SQL model request.
- * @internalRemarks Source: @carto/react-api
+ * @privateRemarks Source: @carto/react-api
  */
 function executeModel(props) {
   assert(props.source, 'executeModel: missing source');
@@ -961,105 +2386,22 @@ function objectToURLSearchParams(object) {
   return params;
 }
 
-const DEFAULT_TILE_SIZE = 512;
-const QUADBIN_ZOOM_MAX_OFFSET = 4;
-function getSpatialFiltersResolution(source, viewState) {
-  const dataResolution = source.dataResolution ?? Number.MAX_VALUE;
-  const aggregationResLevel = source.aggregationResLevel ?? (source.spatialDataType === 'h3' ? DEFAULT_AGGREGATION_RES_LEVEL_H3 : DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN);
-  const aggregationResLevelOffset = Math.max(0, Math.floor(aggregationResLevel));
-  const currentZoomInt = Math.ceil(viewState.zoom);
-  if (source.spatialDataType === 'h3') {
-    const tileSize = DEFAULT_TILE_SIZE;
-    const maxResolutionForZoom = maxH3SpatialFiltersResolutions.find(_ref => {
-      let [zoom] = _ref;
-      return zoom === currentZoomInt;
-    })?.[1] ?? Math.max(0, currentZoomInt - 3);
-    const maxSpatialFiltersResolution = maxResolutionForZoom ? Math.min(dataResolution, maxResolutionForZoom) : dataResolution;
-    const hexagonResolution = _getHexagonResolution(viewState, tileSize) + aggregationResLevelOffset;
-    return Math.min(hexagonResolution, maxSpatialFiltersResolution);
-  }
-  if (source.spatialDataType === 'quadbin') {
-    const maxResolutionForZoom = currentZoomInt + QUADBIN_ZOOM_MAX_OFFSET;
-    const maxSpatialFiltersResolution = Math.min(dataResolution, maxResolutionForZoom);
-    const quadsResolution = Math.floor(viewState.zoom) + aggregationResLevelOffset;
-    return Math.min(quadsResolution, maxSpatialFiltersResolution);
-  }
-  return undefined;
-}
-const maxH3SpatialFiltersResolutions = [[20, 14], [19, 13], [18, 12], [17, 11], [16, 10], [15, 9], [14, 8], [13, 7], [12, 7], [11, 7], [10, 6], [9, 6], [8, 5], [7, 4], [6, 4], [5, 3], [4, 2], [3, 1], [2, 1], [1, 0]];
-// stolen from https://github.com/visgl/deck.gl/blob/master/modules/carto/src/layers/h3-tileset-2d.ts
-// Relative scale factor (0 = no biasing, 2 = a few hexagons cover view)
-const BIAS = 2;
-/**
- * Resolution conversion function. Takes a WebMercatorViewport and returns
- * a H3 resolution such that the screen space size of the hexagons is
- * "similar" to the given tileSize on screen. Intended for use with deck.gl.
- * @internal
- */
-function _getHexagonResolution(viewport, tileSize) {
-  // Difference in given tile size compared to deck's internal 512px tile size,
-  // expressed as an offset to the viewport zoom.
-  const zoomOffset = Math.log2(tileSize / DEFAULT_TILE_SIZE);
-  const hexagonScaleFactor = 2 / 3 * (viewport.zoom - zoomOffset);
-  const latitudeScaleFactor = Math.log(1 / Math.cos(Math.PI * viewport.latitude / 180));
-  // Clip and bias
-  return Math.max(0, Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS));
-}
-
 /**
- * Source for Widget API requests on a data source defined by a SQL query.
+ * Source for Widget API requests.
  *
  * Abstract class. Use {@link WidgetQuerySource} or {@link WidgetTableSource}.
  */
-class WidgetBaseSource {
-  constructor(props) {
-    this.props = void 0;
-    this.props = {
-      ...WidgetBaseSource.defaultProps,
-      ...props
-    };
-  }
-  _getModelSource(owner) {
-    const props = this.props;
-    return {
-      apiVersion: props.apiVersion,
-      apiBaseUrl: props.apiBaseUrl,
-      clientId: props.clientId,
-      accessToken: props.accessToken,
-      connectionName: props.connectionName,
-      filters: getApplicableFilters(owner, props.filters),
-      filtersLogicalOperator: props.filtersLogicalOperator,
-      spatialDataType: props.spatialDataType,
-      spatialDataColumn: props.spatialDataColumn,
-      dataResolution: props.dataResolution
-    };
-  }
-  _getSpatialFiltersResolution(source, spatialFilter, referenceViewState) {
-    // spatialFiltersResolution applies only to spatial index sources.
-    if (!spatialFilter || source.spatialDataType === 'geo') {
-      return;
-    }
-    if (!referenceViewState) {
-      throw new Error('Missing required option, "spatialIndexReferenceViewState".');
-    }
-    return getSpatialFiltersResolution(source, referenceViewState);
-  }
-  /****************************************************************************
-   * CATEGORIES
-   */
-  /**
-   * Returns a list of labeled datapoints for categorical data. Suitable for
-   * charts including grouped bar charts, pie charts, and tree charts.
-   */
+class WidgetRemoteSource extends WidgetSource {
   getCategories(options) {
     try {
       const _this = this;
       const {
+        signal,
+        filters = _this.props.filters,
         filterOwner,
         spatialFilter,
         spatialFiltersMode,
         spatialIndexReferenceViewState,
-        abortController,
         ...params
       } = options;
       const {
@@ -1067,7 +2409,7 @@ class WidgetBaseSource {
         operation,
         operationColumn
       } = params;
-      const source = _this.getModelSource(filterOwner);
+      const source = _this.getModelSource(filters, filterOwner);
       const spatialFiltersResolution = _this._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
       return Promise.resolve(executeModel({
         model: 'category',
@@ -1083,33 +2425,25 @@ class WidgetBaseSource {
           operationColumn: operationColumn || column
         },
         opts: {
-          abortController
+          signal,
+          headers: _this.props.headers
         }
       }).then(res => normalizeObjectKeys(res.rows)));
     } catch (e) {
       return Promise.reject(e);
     }
   }
-  /****************************************************************************
-   * FEATURES
-   */
-  /**
-   * 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
-   */
   getFeatures(options) {
     try {
       const _this2 = this;
       const {
+        abortController,
+        signal = abortController?.signal,
+        filters = _this2.props.filters,
         filterOwner,
         spatialFilter,
         spatialFiltersMode,
         spatialIndexReferenceViewState,
-        abortController,
         ...params
       } = options;
       const {
@@ -1120,7 +2454,7 @@ class WidgetBaseSource {
         limit,
         tileResolution
       } = params;
-      const source = _this2.getModelSource(filterOwner);
+      const source = _this2.getModelSource(filters, filterOwner);
       const spatialFiltersResolution = _this2._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
       return Promise.resolve(executeModel({
         model: 'pick',
@@ -1139,7 +2473,8 @@ class WidgetBaseSource {
           tileResolution: tileResolution || DEFAULT_TILE_RESOLUTION
         },
         opts: {
-          abortController
+          signal,
+          headers: _this2.props.headers
         }
         // Avoid `normalizeObjectKeys()`, which changes column names.
       }).then(_ref => {
@@ -1154,22 +2489,17 @@ class WidgetBaseSource {
       return Promise.reject(e);
     }
   }
-  /****************************************************************************
-   * FORMULA
-   */
-  /**
-   * Returns a scalar numerical statistic over all matching data. Suitable
-   * for 'headline' or 'scorecard' figures such as counts and sums.
-   */
   getFormula(options) {
     try {
       const _this3 = this;
       const {
+        abortController,
+        signal = abortController?.signal,
+        filters = _this3.props.filters,
         filterOwner,
         spatialFilter,
         spatialFiltersMode,
         spatialIndexReferenceViewState,
-        abortController,
         operationExp,
         ...params
       } = options;
@@ -1177,7 +2507,7 @@ class WidgetBaseSource {
         column,
         operation
       } = params;
-      const source = _this3.getModelSource(filterOwner);
+      const source = _this3.getModelSource(filters, filterOwner);
       const spatialFiltersResolution = _this3._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
       return Promise.resolve(executeModel({
         model: 'formula',
@@ -1189,33 +2519,29 @@ class WidgetBaseSource {
         },
         params: {
           column: column ?? '*',
-          operation,
+          operation: operation ?? 'count',
           operationExp
         },
         opts: {
-          abortController
+          signal,
+          headers: _this3.props.headers
         }
       }).then(res => normalizeObjectKeys(res.rows[0])));
     } catch (e) {
       return Promise.reject(e);
     }
   }
-  /****************************************************************************
-   * HISTOGRAM
-   */
-  /**
-   * Returns a list of labeled datapoints for 'bins' of data defined as ticks
-   * over a numerical range. Suitable for histogram charts.
-   */
   getHistogram(options) {
     try {
       const _this4 = this;
       const {
+        abortController,
+        signal = abortController?.signal,
+        filters = _this4.props.filters,
         filterOwner,
         spatialFilter,
         spatialFiltersMode,
         spatialIndexReferenceViewState,
-        abortController,
         ...params
       } = options;
       const {
@@ -1223,7 +2549,7 @@ class WidgetBaseSource {
         operation,
         ticks
       } = params;
-      const source = _this4.getModelSource(filterOwner);
+      const source = _this4.getModelSource(filters, filterOwner);
       const spatialFiltersResolution = _this4._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
       return Promise.resolve(executeModel({
         model: 'histogram',
@@ -1239,7 +2565,8 @@ class WidgetBaseSource {
           ticks
         },
         opts: {
-          abortController
+          signal,
+          headers: _this4.props.headers
         }
       }).then(res => normalizeObjectKeys(res.rows))).then(function (data) {
         if (data.length) {
@@ -1261,29 +2588,23 @@ class WidgetBaseSource {
       return Promise.reject(e);
     }
   }
-  /****************************************************************************
-   * RANGE
-   */
-  /**
-   * 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) {
     try {
       const _this5 = this;
       const {
+        abortController,
+        signal = abortController?.signal,
+        filters = _this5.props.filters,
         filterOwner,
         spatialFilter,
         spatialFiltersMode,
         spatialIndexReferenceViewState,
-        abortController,
         ...params
       } = options;
       const {
         column
       } = params;
-      const source = _this5.getModelSource(filterOwner);
+      const source = _this5.getModelSource(filters, filterOwner);
       const spatialFiltersResolution = _this5._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
       return Promise.resolve(executeModel({
         model: 'range',
@@ -1297,29 +2618,25 @@ class WidgetBaseSource {
           column
         },
         opts: {
-          abortController
+          signal,
+          headers: _this5.props.headers
         }
       }).then(res => normalizeObjectKeys(res.rows[0])));
     } catch (e) {
       return Promise.reject(e);
     }
   }
-  /****************************************************************************
-   * SCATTER
-   */
-  /**
-   * Returns a list of bivariate datapoints defined as numerical 'x' and 'y'
-   * values. Suitable for rendering scatter plots.
-   */
   getScatter(options) {
     try {
       const _this6 = this;
       const {
+        abortController,
+        signal = abortController?.signal,
+        filters = _this6.props.filters,
         filterOwner,
         spatialFilter,
         spatialFiltersMode,
         spatialIndexReferenceViewState,
-        abortController,
         ...params
       } = options;
       const {
@@ -1328,7 +2645,7 @@ class WidgetBaseSource {
         yAxisColumn,
         yAxisJoinOperation
       } = params;
-      const source = _this6.getModelSource(filterOwner);
+      const source = _this6.getModelSource(filters, filterOwner);
       const spatialFiltersResolution = _this6._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
       // Make sure this is sync with the same constant in cloud-native/maps-api
       const HARD_LIMIT = 500;
@@ -1348,7 +2665,8 @@ class WidgetBaseSource {
           limit: HARD_LIMIT
         },
         opts: {
-          abortController
+          signal,
+          headers: _this6.props.headers
         }
       }).then(res => normalizeObjectKeys(res.rows)).then(res => res.map(_ref3 => {
         let {
@@ -1361,22 +2679,17 @@ class WidgetBaseSource {
       return Promise.reject(e);
     }
   }
-  /****************************************************************************
-   * TABLE
-   */
-  /**
-   * Returns a list of arbitrary data rows, with support for pagination and
-   * sorting. Suitable for displaying tables and lists.
-   */
   getTable(options) {
     try {
       const _this7 = this;
       const {
+        abortController,
+        signal = abortController?.signal,
+        filters = _this7.props.filters,
         filterOwner,
         spatialFilter,
         spatialFiltersMode,
         spatialIndexReferenceViewState,
-        abortController,
         ...params
       } = options;
       const {
@@ -1386,7 +2699,7 @@ class WidgetBaseSource {
         offset = 0,
         limit = 10
       } = params;
-      const source = _this7.getModelSource(filterOwner);
+      const source = _this7.getModelSource(filters, filterOwner);
       const spatialFiltersResolution = _this7._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
       return Promise.resolve(executeModel({
         model: 'table',
@@ -1404,7 +2717,8 @@ class WidgetBaseSource {
           offset
         },
         opts: {
-          abortController
+          signal,
+          headers: _this7.props.headers
         }
       }).then(res => ({
         // Avoid `normalizeObjectKeys()`, which changes column names.
@@ -1415,19 +2729,14 @@ class WidgetBaseSource {
       return Promise.reject(e);
     }
   }
-  /****************************************************************************
-   * TIME SERIES
-   */
-  /**
-   * Returns a series of labeled numerical values, grouped into equally-sized
-   * time intervals. Suitable for rendering time series charts.
-   */
   getTimeSeries(options) {
     try {
       const _this8 = this;
       const {
-        filterOwner,
         abortController,
+        signal = abortController?.signal,
+        filters = _this8.props.filters,
+        filterOwner,
         spatialFilter,
         spatialFiltersMode,
         spatialIndexReferenceViewState,
@@ -1444,7 +2753,7 @@ class WidgetBaseSource {
         splitByCategoryLimit,
         splitByCategoryValues
       } = params;
-      const source = _this8.getModelSource(filterOwner);
+      const source = _this8.getModelSource(filters, filterOwner);
       const spatialFiltersResolution = _this8._getSpatialFiltersResolution(source, spatialFilter, spatialIndexReferenceViewState);
       return Promise.resolve(executeModel({
         model: 'timeseries',
@@ -1466,7 +2775,8 @@ class WidgetBaseSource {
           splitByCategoryValues
         },
         opts: {
-          abortController
+          signal,
+          headers: _this8.props.headers
         }
       }).then(res => ({
         rows: normalizeObjectKeys(res.rows),
@@ -1477,13 +2787,6 @@ class WidgetBaseSource {
     }
   }
 }
-WidgetBaseSource.defaultProps = {
-  apiVersion: exports.ApiVersion.V3,
-  apiBaseUrl: DEFAULT_API_BASE_URL,
-  clientId: getClient(),
-  filters: {},
-  filtersLogicalOperator: 'and'
-};
 
 /**
  * Source for Widget API requests on a data source defined by a SQL query.
@@ -1507,10 +2810,10 @@ WidgetBaseSource.defaultProps = {
  * const { widgetSource } = await data;
  * ```
  */
-class WidgetQuerySource extends WidgetBaseSource {
-  getModelSource(owner) {
+class WidgetQuerySource extends WidgetRemoteSource {
+  getModelSource(filters, filterOwner) {
     return {
-      ...super._getModelSource(owner),
+      ...super._getModelSource(filters, filterOwner),
       type: 'query',
       data: this.props.sqlQuery,
       queryParameters: this.props.queryParameters
@@ -1540,20 +2843,787 @@ class WidgetQuerySource extends WidgetBaseSource {
  * const { widgetSource } = await data;
  * ```
  */
-class WidgetTableSource extends WidgetBaseSource {
-  getModelSource(owner) {
+class WidgetTableSource extends WidgetRemoteSource {
+  getModelSource(filters, filterOwner) {
     return {
-      ...super._getModelSource(owner),
+      ...super._getModelSource(filters, filterOwner),
       type: 'table',
       data: this.props.tableName
     };
   }
 }
 
+/** @privateRemarks Source: @carto/react-core */
+const aggregationFunctions = {
+  count: values => values.length,
+  min: function () {
+    return applyAggregationFunction(min, ...[].slice.call(arguments));
+  },
+  max: function () {
+    return applyAggregationFunction(max, ...[].slice.call(arguments));
+  },
+  sum: function () {
+    return applyAggregationFunction(sum, ...[].slice.call(arguments));
+  },
+  avg: function () {
+    return applyAggregationFunction(avg, ...[].slice.call(arguments));
+  }
+};
+/** @privateRemarks Source: @carto/react-core */
+function aggregate(feature, keys, operation) {
+  if (!keys?.length) {
+    throw new Error('Cannot aggregate a feature without having keys');
+  } else if (keys.length === 1) {
+    const value = feature[keys[0]];
+    return isPotentiallyValidNumber(value) ? Number(value) : value;
+  }
+  const aggregationFn = aggregationFunctions[operation];
+  if (!aggregationFn) {
+    throw new Error(`${operation} isn't a valid aggregation function`);
+  }
+  return aggregationFn(keys.map(column => {
+    const value = feature[column];
+    return isPotentiallyValidNumber(value) ? Number(value) : value;
+  }));
+}
+/*
+ * Forced casting to Number (just of non empty strings) allows to work-around
+ * some specific situations, where a big numeric field is transformed into a string when generating the tileset(eg.PG)
+ */
+function isPotentiallyValidNumber(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+const applyAggregationFunction = (aggFn, values, keys, operation) => {
+  const normalizedKeys = normalizeKeys(keys);
+  const elements = (normalizedKeys?.length || 0) <= 1 ? filterFalsyElements(values, normalizedKeys || []) : values;
+  return aggFn(elements, keys, operation);
+};
+function filterFalsyElements(values, keys) {
+  const filterFn = value => value !== null && value !== undefined;
+  if (!keys?.length) {
+    return values.filter(filterFn);
+  }
+  return values.filter(v => filterFn(v[keys[0]]));
+}
+// Aggregation functions
+function avg(values, keys, joinOperation) {
+  return sum(values, keys, joinOperation) / (values.length || 1);
+}
+function sum(values, keys, joinOperation) {
+  const normalizedKeys = normalizeKeys(keys);
+  if (normalizedKeys) {
+    return values.reduce((a, b) => a + aggregate(b, normalizedKeys, joinOperation), 0);
+  }
+  return values.reduce((a, b) => a + b, 0);
+}
+function min(values, keys, joinOperation) {
+  const normalizedKeys = normalizeKeys(keys);
+  if (normalizedKeys) {
+    return values.reduce((a, b) => Math.min(a, aggregate(b, normalizedKeys, joinOperation)), Infinity);
+  }
+  return Math.min(...values);
+}
+function max(values, keys, joinOperation) {
+  const normalizedKeys = normalizeKeys(keys);
+  if (normalizedKeys) {
+    return values.reduce((a, b) => Math.max(a, aggregate(b, normalizedKeys, joinOperation)), -Infinity);
+  }
+  return Math.max(...values);
+}
+// Aux
+// Keys can come as a string (one column) or a strings array (multiple column)
+// Use always an array to make the code easier
+function normalizeKeys(keys) {
+  return Array.isArray(keys) ? keys : typeof keys === 'string' ? [keys] : undefined;
+}
+
+/***
+   Copyright 2013 Teun Duynstee
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*/
+var thenBy_module = function () {
+  function identity(v) {
+    return v;
+  }
+  function ignoreCase(v) {
+    return typeof v === "string" ? v.toLowerCase() : v;
+  }
+  function makeCompareFunction(f, opt) {
+    opt = typeof opt === "object" ? opt : {
+      direction: opt
+    };
+    if (typeof f != "function") {
+      var prop = f;
+      // make unary function
+      f = function (v1) {
+        return !!v1[prop] ? v1[prop] : "";
+      };
+    }
+    if (f.length === 1) {
+      // f is a unary function mapping a single item to its sort score
+      var uf = f;
+      var preprocess = opt.ignoreCase ? ignoreCase : identity;
+      var cmp = opt.cmp || function (v1, v2) {
+        return v1 < v2 ? -1 : v1 > v2 ? 1 : 0;
+      };
+      f = function (v1, v2) {
+        return cmp(preprocess(uf(v1)), preprocess(uf(v2)));
+      };
+    }
+    const descTokens = {
+      "-1": '',
+      desc: ''
+    };
+    if (opt.direction in descTokens) return function (v1, v2) {
+      return -f(v1, v2);
+    };
+    return f;
+  }
+
+  /* adds a secondary compare function to the target function (`this` context)
+     which is applied in case the first one returns 0 (equal)
+     returns a new compare function, which has a `thenBy` method as well */
+  function tb(func, opt) {
+    /* should get value false for the first call. This can be done by calling the 
+    exported function, or the firstBy property on it (for es6 module compatibility)
+    */
+    var x = typeof this == "function" && !this.firstBy ? this : false;
+    var y = makeCompareFunction(func, opt);
+    var f = x ? function (a, b) {
+      return x(a, b) || y(a, b);
+    } : y;
+    f.thenBy = tb;
+    return f;
+  }
+  tb.firstBy = tb;
+  return tb;
+}();
+
+/**
+ * Apply sort structure to a collection of features
+ * @param features
+ * @param [sortOptions]
+ * @param [sortOptions.sortBy] - One or more columns to sort by
+ * @param [sortOptions.sortByDirection] - Direction by the columns will be sorted
+ * @param [sortOptions.sortByColumnType] - Column type
+ * @internal
+ * @privateRemarks Source: @carto/react-core
+ */
+function applySorting(features, _temp) {
+  let {
+    sortBy,
+    sortByDirection = 'asc',
+    sortByColumnType = 'string'
+  } = _temp === void 0 ? {} : _temp;
+  // If sortBy is undefined, pass all features
+  if (sortBy === undefined) {
+    return features;
+  }
+  // sortOptions exists, but are bad formatted
+  const isValidSortBy = Array.isArray(sortBy) && sortBy.length ||
+  // sortBy can be an array of columns
+  typeof sortBy === 'string'; // or just one column
+  if (!isValidSortBy) {
+    throw new Error('Sorting options are bad formatted');
+  }
+  const sortFn = createSortFn({
+    sortBy,
+    sortByDirection,
+    sortByColumnType: sortByColumnType || 'string'
+  });
+  return features.sort(sortFn);
+}
+// Aux
+function createSortFn(_ref) {
+  let {
+    sortBy,
+    sortByDirection,
+    sortByColumnType
+  } = _ref;
+  const [firstSortOption, ...othersSortOptions] = normalizeSortByOptions({
+    sortBy,
+    sortByDirection,
+    sortByColumnType
+  });
+  let sortFn = thenBy_module.firstBy(...firstSortOption);
+  for (const sortOptions of othersSortOptions) {
+    sortFn = sortFn.thenBy(...sortOptions);
+  }
+  return sortFn;
+}
+function normalizeSortByOptions(_ref2) {
+  let {
+    sortBy,
+    sortByDirection,
+    sortByColumnType
+  } = _ref2;
+  const numberFormat = sortByColumnType === 'number' && {
+    cmp: (a, b) => a - b
+  };
+  if (!Array.isArray(sortBy)) {
+    sortBy = [sortBy];
+  }
+  return sortBy.map(sortByEl => {
+    // sortByEl is 'column'
+    if (typeof sortByEl === 'string') {
+      return [sortByEl, {
+        direction: sortByDirection,
+        ...numberFormat
+      }];
+    }
+    if (Array.isArray(sortByEl)) {
+      // sortBy is ['column']
+      if (sortByEl[1] === undefined) {
+        return [sortByEl, {
+          direction: sortByDirection,
+          ...numberFormat
+        }];
+      }
+      // sortBy is ['column', { ... }]
+      if (typeof sortByEl[1] === 'object') {
+        const othersSortOptions = numberFormat ? {
+          ...numberFormat,
+          ...sortByEl[1]
+        } : sortByEl[1];
+        return [sortByEl[0], {
+          direction: sortByDirection,
+          ...othersSortOptions
+        }];
+      }
+    }
+    return sortByEl;
+  });
+}
+
+/** @privateRemarks Source: @carto/react-core */
+function groupValuesByColumn(_ref) {
+  let {
+    data,
+    valuesColumns,
+    joinOperation,
+    keysColumn,
+    operation
+  } = _ref;
+  if (Array.isArray(data) && data.length === 0) {
+    return null;
+  }
+  const groups = data.reduce((accumulator, item) => {
+    const group = item[keysColumn];
+    const values = accumulator.get(group) || [];
+    accumulator.set(group, values);
+    const aggregatedValue = aggregate(item, valuesColumns, joinOperation);
+    const isValid = (operation === 'count' ? true : aggregatedValue !== null) && aggregatedValue !== undefined;
+    if (isValid) {
+      values.push(aggregatedValue);
+      accumulator.set(group, values);
+    }
+    return accumulator;
+  }, new Map()); // We use a map to be able to maintain the type in the key value
+  const targetOperation = aggregationFunctions[operation];
+  if (targetOperation) {
+    return Array.from(groups).map(_ref2 => {
+      let [name, value] = _ref2;
+      return {
+        name,
+        value: targetOperation(value)
+      };
+    });
+  }
+  return [];
+}
+
+/**
+ * Returns midnight (local time) on the Monday preceeding a given date, in
+ * milliseconds since the UNIX epoch.
+ */
+/**
+ * Returns midnight (UTC) on the Monday preceeding a given date, in
+ * milliseconds since the UNIX epoch.
+ */
+function getUTCMonday(date) {
+  const dateCp = new Date(date);
+  const day = dateCp.getUTCDay();
+  const diff = dateCp.getUTCDate() - day + (day ? 1 : -6); // adjust when day is sunday
+  dateCp.setUTCDate(diff);
+  return Date.UTC(dateCp.getUTCFullYear(), dateCp.getUTCMonth(), dateCp.getUTCDate());
+}
+
+const GROUP_KEY_FN_MAPPING = {
+  year: date => Date.UTC(date.getUTCFullYear()),
+  month: date => Date.UTC(date.getUTCFullYear(), date.getUTCMonth()),
+  week: date => getUTCMonday(date),
+  day: date => Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()),
+  hour: date => Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours()),
+  minute: date => Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes()),
+  second: date => Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds())
+};
+/** @privateRemarks Source: @carto/react-core */
+function groupValuesByDateColumn(_ref) {
+  let {
+    data,
+    valuesColumns,
+    joinOperation,
+    keysColumn,
+    groupType,
+    operation
+  } = _ref;
+  if (Array.isArray(data) && data.length === 0) {
+    return null;
+  }
+  const groupKeyFn = GROUP_KEY_FN_MAPPING[groupType];
+  if (!groupKeyFn) {
+    return null;
+  }
+  const groups = data.reduce((acc, item) => {
+    const value = item[keysColumn];
+    const formattedValue = new Date(value);
+    const groupKey = groupKeyFn(formattedValue);
+    if (!isNaN(groupKey)) {
+      let groupedValues = acc.get(groupKey);
+      if (!groupedValues) {
+        groupedValues = [];
+        acc.set(groupKey, groupedValues);
+      }
+      const aggregatedValue = aggregate(item, valuesColumns, joinOperation);
+      const isValid = aggregatedValue !== null && aggregatedValue !== undefined;
+      if (isValid) {
+        groupedValues.push(aggregatedValue);
+        acc.set(groupKey, groupedValues);
+      }
+    }
+    return acc;
+  }, new Map());
+  const targetOperation = aggregationFunctions[operation];
+  return [...groups.entries()].map(_ref2 => {
+    let [name, value] = _ref2;
+    return {
+      name,
+      value: targetOperation(value)
+    };
+  }).sort((a, b) => a.name - b.name);
+}
+
+/**
+ * Histogram computation.
+ * @privateRemarks Source: @carto/react-core
+ */
+function histogram(_ref) {
+  let {
+    data,
+    valuesColumns,
+    joinOperation,
+    ticks,
+    operation
+  } = _ref;
+  if (Array.isArray(data) && data.length === 0) {
+    return [];
+  }
+  const binsContainer = [Number.MIN_SAFE_INTEGER, ...ticks].map((tick, index, arr) => ({
+    bin: index,
+    start: tick,
+    end: index === arr.length - 1 ? Number.MAX_SAFE_INTEGER : arr[index + 1],
+    values: []
+  }));
+  data.forEach(feature => {
+    const featureValue = aggregate(feature, valuesColumns, joinOperation);
+    const isValid = featureValue !== null && featureValue !== undefined;
+    if (!isValid) {
+      return;
+    }
+    const binContainer = binsContainer.find(bin => bin.start <= featureValue && bin.end > featureValue);
+    if (!binContainer) {
+      return;
+    }
+    binContainer.values.push(featureValue);
+  });
+  const targetOperation = aggregationFunctions[operation];
+  const transformedBins = binsContainer.map(binContainer => binContainer.values);
+  return transformedBins.map(values => values.length ? targetOperation(values) : 0);
+}
+
+/**
+ * Filters invalid features and formats  data.
+ * @privateRemarks Source: @carto/react-core
+ */
+function scatterPlot(_ref) {
+  let {
+    data,
+    xAxisColumns,
+    xAxisJoinOperation,
+    yAxisColumns,
+    yAxisJoinOperation
+  } = _ref;
+  return data.reduce((acc, feature) => {
+    const xValue = aggregate(feature, xAxisColumns, xAxisJoinOperation);
+    const xIsValid = xValue !== null && xValue !== undefined;
+    const yValue = aggregate(feature, yAxisColumns, yAxisJoinOperation);
+    const yIsValid = yValue !== null && yValue !== undefined;
+    if (xIsValid && yIsValid) {
+      acc.push([xValue, yValue]);
+    }
+    return acc;
+  }, []);
+}
+
+/**
+ * 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;
+ * ```
+ */
+class WidgetTilesetSource extends WidgetSource {
+  constructor() {
+    super(...arguments);
+    this._tiles = [];
+    this._features = [];
+    this._tileFeatureExtractOptions = {};
+    this._tileFeatureExtractPreviousInputs = {};
+  }
+  getModelSource(filters, filterOwner) {
+    return {
+      ...super._getModelSource(filters, filterOwner),
+      type: 'tileset',
+      data: this.props.tableName
+    };
+  }
+  /**
+   * 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) {
+    this._tiles = tiles;
+    this._features.length = 0;
+  }
+  /** Configures options used to extract features from tiles. */
+  setTileFeatureExtractOptions(options) {
+    this._tileFeatureExtractOptions = options;
+    this._features.length = 0;
+  }
+  _extractTileFeatures(spatialFilter) {
+    // When spatial filter has not changed, don't redo extraction. If tiles or
+    // tile extract options change, features will have been cleared already.
+    const prevInputs = this._tileFeatureExtractPreviousInputs;
+    if (this._features.length && prevInputs.spatialFilter && booleanEqual.booleanEqual(prevInputs.spatialFilter, spatialFilter)) {
+      return;
+    }
+    this._features = tileFeatures({
+      tiles: this._tiles,
+      tileFormat: this.props.tileFormat,
+      ...this._tileFeatureExtractOptions,
+      spatialFilter,
+      spatialDataColumn: this.props.spatialDataColumn,
+      spatialDataType: this.props.spatialDataType
+    });
+    prevInputs.spatialFilter = spatialFilter;
+  }
+  /**
+   * Loads features as GeoJSON (used for testing).
+   * @experimental
+   * @internal Not for public use. Spatial filters in other method calls will be ignored.
+   */
+  loadGeoJSON(_ref) {
+    let {
+      geojson,
+      spatialFilter
+    } = _ref;
+    this._features = geojsonFeatures({
+      geojson,
+      spatialFilter,
+      ...this._tileFeatureExtractOptions
+    });
+    this._tileFeatureExtractPreviousInputs.spatialFilter = spatialFilter;
+  }
+  getFeatures() {
+    try {
+      throw new Error('getFeatures not supported for tilesets');
+      return Promise.resolve();
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  getFormula(_ref2) {
+    let {
+      column = '*',
+      operation = 'count',
+      joinOperation,
+      filters,
+      filterOwner,
+      spatialFilter
+    } = _ref2;
+    try {
+      const _this = this;
+      if (operation === 'custom') {
+        throw new Error('Custom aggregation not supported for tilesets');
+      }
+      // Column is required except when operation is 'count'.
+      if (column && column !== '*' || operation !== 'count') {
+        assertColumn(_this._features, column);
+      }
+      const filteredFeatures = _this._getFilteredFeatures(spatialFilter, filters, filterOwner);
+      if (filteredFeatures.length === 0 && operation !== 'count') {
+        return Promise.resolve({
+          value: null
+        });
+      }
+      const targetOperation = aggregationFunctions[operation];
+      return Promise.resolve({
+        value: targetOperation(filteredFeatures, column, joinOperation)
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  getHistogram(_ref3) {
+    let {
+      operation = 'count',
+      ticks,
+      column,
+      joinOperation,
+      filters,
+      filterOwner,
+      spatialFilter
+    } = _ref3;
+    try {
+      const _this2 = this;
+      const filteredFeatures = _this2._getFilteredFeatures(spatialFilter, filters, filterOwner);
+      assertColumn(_this2._features, column);
+      if (!_this2._features.length) {
+        return Promise.resolve([]);
+      }
+      return Promise.resolve(histogram({
+        data: filteredFeatures,
+        valuesColumns: normalizeColumns(column),
+        joinOperation,
+        ticks,
+        operation
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  getCategories(_ref4) {
+    let {
+      column,
+      operation = 'count',
+      operationColumn,
+      joinOperation,
+      filters,
+      filterOwner,
+      spatialFilter
+    } = _ref4;
+    try {
+      const _this3 = this;
+      const filteredFeatures = _this3._getFilteredFeatures(spatialFilter, filters, filterOwner);
+      if (!filteredFeatures.length) {
+        return Promise.resolve([]);
+      }
+      assertColumn(_this3._features, column, operationColumn);
+      const groups = groupValuesByColumn({
+        data: filteredFeatures,
+        valuesColumns: normalizeColumns(operationColumn || column),
+        joinOperation,
+        keysColumn: column,
+        operation
+      });
+      return Promise.resolve(groups || []);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  getScatter(_ref5) {
+    let {
+      xAxisColumn,
+      yAxisColumn,
+      xAxisJoinOperation,
+      yAxisJoinOperation,
+      filters,
+      filterOwner,
+      spatialFilter
+    } = _ref5;
+    try {
+      const _this4 = this;
+      const filteredFeatures = _this4._getFilteredFeatures(spatialFilter, filters, filterOwner);
+      if (!filteredFeatures.length) {
+        return Promise.resolve([]);
+      }
+      assertColumn(_this4._features, xAxisColumn, yAxisColumn);
+      return Promise.resolve(scatterPlot({
+        data: filteredFeatures,
+        xAxisColumns: normalizeColumns(xAxisColumn),
+        xAxisJoinOperation,
+        yAxisColumns: normalizeColumns(yAxisColumn),
+        yAxisJoinOperation
+      }));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  getTable(_ref6) {
+    let {
+      columns,
+      searchFilterColumn,
+      searchFilterText,
+      sortBy,
+      sortDirection,
+      sortByColumnType,
+      offset = 0,
+      limit = 10,
+      filters,
+      filterOwner,
+      spatialFilter
+    } = _ref6;
+    try {
+      const _this5 = this;
+      // Filter.
+      let filteredFeatures = _this5._getFilteredFeatures(spatialFilter, filters, filterOwner);
+      if (!filteredFeatures.length) {
+        return Promise.resolve({
+          rows: [],
+          totalCount: 0
+        });
+      }
+      // Search.
+      if (searchFilterColumn && searchFilterText) {
+        filteredFeatures = filteredFeatures.filter(row => row[searchFilterColumn] && String(row[searchFilterColumn]).toLowerCase().includes(String(searchFilterText).toLowerCase()));
+      }
+      // Sort.
+      let rows = applySorting(filteredFeatures, {
+        sortBy,
+        sortByDirection: sortDirection,
+        sortByColumnType
+      });
+      const totalCount = rows.length;
+      // Offset and limit.
+      rows = rows.slice(Math.min(offset, totalCount), Math.min(offset + limit, totalCount));
+      // Select columns.
+      rows = rows.map(srcRow => {
+        const dstRow = {};
+        for (const column of columns) {
+          dstRow[column] = srcRow[column];
+        }
+        return dstRow;
+      });
+      return Promise.resolve({
+        rows,
+        totalCount
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  getTimeSeries(_ref7) {
+    let {
+      column,
+      stepSize,
+      operation,
+      operationColumn,
+      joinOperation,
+      filters,
+      filterOwner,
+      spatialFilter
+    } = _ref7;
+    try {
+      const _this6 = this;
+      const filteredFeatures = _this6._getFilteredFeatures(spatialFilter, filters, filterOwner);
+      if (!filteredFeatures.length) {
+        return Promise.resolve({
+          rows: []
+        });
+      }
+      assertColumn(_this6._features, column, operationColumn);
+      const rows = groupValuesByDateColumn({
+        data: filteredFeatures,
+        valuesColumns: normalizeColumns(operationColumn || column),
+        keysColumn: column,
+        groupType: stepSize,
+        operation,
+        joinOperation
+      }) || [];
+      return Promise.resolve({
+        rows
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  getRange(_ref8) {
+    let {
+      column,
+      filters,
+      filterOwner,
+      spatialFilter
+    } = _ref8;
+    try {
+      const _this7 = this;
+      assertColumn(_this7._features, column);
+      const filteredFeatures = _this7._getFilteredFeatures(spatialFilter, filters, filterOwner);
+      if (!_this7._features.length) {
+        // TODO: Is this the only nullable response in the Widgets API? If so,
+        // can we do something more consistent?
+        return Promise.resolve(null);
+      }
+      return Promise.resolve({
+        min: aggregationFunctions.min(filteredFeatures, column),
+        max: aggregationFunctions.max(filteredFeatures, column)
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }
+  /****************************************************************************
+   * INTERNAL
+   */
+  _getFilteredFeatures(spatialFilter, filters, filterOwner) {
+    assert(spatialFilter, 'spatialFilter required for tilesets');
+    this._extractTileFeatures(spatialFilter);
+    return applyFilters(this._features, getApplicableFilters(filterOwner, filters || this.props.filters), this.props.filtersLogicalOperator || 'and');
+  }
+}
+function assertColumn(features) {
+  // TODO(cleanup): Can drop support for multiple column shapes here?
+  // Due to the multiple column shape, we normalise it as an array with normalizeColumns
+  const columns = Array.from(new Set([].slice.call(arguments, 1).map(normalizeColumns).flat()));
+  const featureKeys = Object.keys(features[0]);
+  const invalidColumns = columns.filter(column => !featureKeys.includes(column));
+  if (invalidColumns.length) {
+    throw new InvalidColumnError(`Missing column(s): ${invalidColumns.join(', ')}`);
+  }
+}
+function normalizeColumns(columns) {
+  return Array.isArray(columns) ? columns : typeof columns === 'string' ? [columns] : [];
+}
+
 // deck.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-/* eslint-disable camelcase */
 const h3QuerySource = function (options) {
   try {
     const {
@@ -1597,7 +3667,6 @@ const h3QuerySource = function (options) {
 // deck.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-/* eslint-disable camelcase */
 const h3TableSource = function (options) {
   try {
     const {
@@ -1675,7 +3744,6 @@ const rasterSource = function (options) {
 // deck.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-/* eslint-disable camelcase */
 const quadbinQuerySource = function (options) {
   try {
     const {
@@ -1719,7 +3787,6 @@ const quadbinQuerySource = function (options) {
 // deck.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-/* eslint-disable camelcase */
 const quadbinTableSource = function (options) {
   try {
     const {
@@ -1776,13 +3843,12 @@ const quadbinTilesetSource = function (options) {
 // deck.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-/* eslint-disable camelcase */
 const vectorQuerySource = function (options) {
   try {
     const {
       columns,
       filters,
-      spatialDataColumn = 'geom',
+      spatialDataColumn = DEFAULT_GEO_COLUMN,
       sqlQuery,
       tileResolution = DEFAULT_TILE_RESOLUTION,
       queryParameters,
@@ -1825,13 +3891,12 @@ const vectorQuerySource = function (options) {
 // deck.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-/* eslint-disable camelcase */
 const vectorTableSource = function (options) {
   try {
     const {
       columns,
       filters,
-      spatialDataColumn = 'geom',
+      spatialDataColumn = DEFAULT_GEO_COLUMN,
       tableName,
       tileResolution = DEFAULT_TILE_RESOLUTION,
       aggregationExp
@@ -1937,25 +4002,41 @@ const query = function (options) {
 
 exports.CartoAPIError = CartoAPIError;
 exports.DEFAULT_API_BASE_URL = DEFAULT_API_BASE_URL;
+exports.FEATURE_GEOM_PROPERTY = FEATURE_GEOM_PROPERTY;
 exports.SOURCE_DEFAULTS = SOURCE_DEFAULTS;
-exports.WidgetBaseSource = WidgetBaseSource;
 exports.WidgetQuerySource = WidgetQuerySource;
+exports.WidgetRemoteSource = WidgetRemoteSource;
+exports.WidgetSource = WidgetSource;
 exports.WidgetTableSource = WidgetTableSource;
+exports.WidgetTilesetSource = WidgetTilesetSource;
+exports._buildFeatureFilter = _buildFeatureFilter;
 exports._getHexagonResolution = _getHexagonResolution;
 exports.addFilter = addFilter;
+exports.aggregate = aggregate;
+exports.aggregationFunctions = aggregationFunctions;
+exports.applyFilters = applyFilters;
+exports.applySorting = applySorting;
 exports.boundaryQuerySource = boundaryQuerySource;
 exports.boundaryTableSource = boundaryTableSource;
+exports.buildBinaryFeatureFilter = buildBinaryFeatureFilter;
 exports.buildPublicMapUrl = buildPublicMapUrl;
 exports.buildStatsUrl = buildStatsUrl;
 exports.clearFilters = clearFilters;
 exports.createPolygonSpatialFilter = createPolygonSpatialFilter;
 exports.createViewportSpatialFilter = createViewportSpatialFilter;
+exports.filterFunctions = filterFunctions;
+exports.geojsonFeatures = geojsonFeatures;
 exports.getClient = getClient;
+exports.getDataFilterExtensionProps = getDataFilterExtensionProps;
 exports.getFilter = getFilter;
+exports.groupValuesByColumn = groupValuesByColumn;
+exports.groupValuesByDateColumn = groupValuesByDateColumn;
 exports.h3QuerySource = h3QuerySource;
 exports.h3TableSource = h3TableSource;
 exports.h3TilesetSource = h3TilesetSource;
 exports.hasFilter = hasFilter;
+exports.histogram = histogram;
+exports.makeIntervalComplete = makeIntervalComplete;
 exports.quadbinQuerySource = quadbinQuerySource;
 exports.quadbinTableSource = quadbinTableSource;
 exports.quadbinTilesetSource = quadbinTilesetSource;
@@ -1963,7 +4044,12 @@ exports.query = query;
 exports.rasterSource = rasterSource;
 exports.removeFilter = removeFilter;
 exports.requestWithParameters = requestWithParameters;
+exports.scatterPlot = scatterPlot;
 exports.setClient = setClient;
+exports.tileFeatures = tileFeatures;
+exports.tileFeaturesGeometries = tileFeaturesGeometries;
+exports.tileFeaturesSpatialIndex = tileFeaturesSpatialIndex;
+exports.transformToTileCoords = transformToTileCoords;
 exports.vectorQuerySource = vectorQuerySource;
 exports.vectorTableSource = vectorTableSource;
 exports.vectorTilesetSource = vectorTilesetSource;