@carto/api-client 0.5.0-alpha.3 → 0.5.0-alpha.5

package/build/api-client.js

@@ -0,0 +1,1712 @@
+import {
+  ApiVersion,
+  DEFAULT_AGGREGATION_RES_LEVEL_H3,
+  DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
+  DEFAULT_API_BASE_URL,
+  DEFAULT_GEO_COLUMN,
+  DEFAULT_MAX_LENGTH_URL,
+  DEFAULT_TILE_RESOLUTION,
+  FEATURE_GEOM_PROPERTY,
+  FilterType,
+  InvalidColumnError,
+  Provider,
+  SpatialIndex,
+  TileFormat,
+  V3_MINOR_VERSION,
+  WidgetSource,
+  WidgetTilesetSource,
+  __publicField,
+  _buildFeatureFilter,
+  _getHexagonResolution,
+  aggregate,
+  aggregationFunctions,
+  applyFilters,
+  applySorting,
+  assert,
+  buildBinaryFeatureFilter,
+  filterFunctions,
+  geojsonFeatures,
+  getApplicableFilters,
+  getClient,
+  groupValuesByColumn,
+  groupValuesByDateColumn,
+  histogram,
+  isEmptyObject,
+  isPureObject,
+  makeIntervalComplete,
+  normalizeObjectKeys,
+  scatterPlot,
+  setClient,
+  tileFeatures,
+  tileFeaturesGeometries,
+  tileFeaturesSpatialIndex,
+  transformToTileCoords
+} from "./chunk-V3E7BKVR.js";
+
+// src/deck/get-data-filter-extension-props.ts
+function getDataFilterExtensionProps(filters, filtersLogicalOperator, filterSize) {
+  filterSize ?? (filterSize = 4);
+  const { filtersWithoutTimeType, timeColumn, timeFilter } = getFiltersByType(filters);
+  return {
+    filterRange: getFilterRange(timeFilter, filterSize),
+    updateTriggers: getUpdateTriggers(
+      filtersWithoutTimeType,
+      timeColumn,
+      timeFilter
+    ),
+    getFilterValue: getFilterValue(
+      filtersWithoutTimeType,
+      timeColumn,
+      timeFilter,
+      filterSize,
+      filtersLogicalOperator
+    )
+  };
+}
+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 === "time" /* TIME */) {
+        timeColumn = column;
+        timeFilter = typeData;
+      } else {
+        filtersWithoutTimeType[column] = { [type]: typeData };
+      }
+    }
+  }
+  return {
+    filtersWithoutTimeType,
+    timeColumn,
+    timeFilter
+  };
+}
+function getFilterRange(timeFilter, filterSize) {
+  const result = Array(filterSize).fill([0, 0]);
+  result[0] = [1, 1];
+  if (timeFilter) {
+    const offsetBy = timeFilter.params?.offsetBy || 0;
+    result[1] = timeFilter.values[0].map((v) => v - offsetBy);
+  }
+  return result;
+}
+function getUpdateTriggers(filtersWithoutTimeType, timeColumn, timeFilter) {
+  const result = { ...filtersWithoutTimeType };
+  if (timeColumn && timeFilter) {
+    result[timeColumn] = {
+      ...result[timeColumn],
+      offsetBy: timeFilter.params?.offsetBy,
+      ["time" /* TIME */]: {}
+      // Allows working with other filters, without an impact on performance.
+    };
+  }
+  return {
+    getFilterValue: JSON.stringify(result)
+  };
+}
+function getFilterValue(filtersWithoutTimeType, timeColumn, timeFilter, filterSize, filtersLogicalOperator) {
+  const result = Array(filterSize).fill(0);
+  const featureFilter = _buildFeatureFilter({
+    filters: filtersWithoutTimeType,
+    type: "number",
+    filtersLogicalOperator
+  });
+  return (feature2) => {
+    result[0] = featureFilter(feature2);
+    if (timeColumn && timeFilter) {
+      const offsetBy = timeFilter.params?.offsetBy || 0;
+      const f = feature2.properties || feature2;
+      result[1] = f[timeColumn] - offsetBy;
+    }
+    return result;
+  };
+}
+
+// src/filters.ts
+function addFilter(filters, { column, type, values, owner }) {
+  if (!filters[column]) {
+    filters[column] = {};
+  }
+  const filter = { values, owner };
+  filters[column][type] = filter;
+  return filters;
+}
+function removeFilter(filters, { column, owner }) {
+  const filter = filters[column];
+  if (!filter) {
+    return filters;
+  }
+  if (owner) {
+    for (const type of Object.values(FilterType)) {
+      if (owner === filter[type]?.owner) {
+        delete filter[type];
+      }
+    }
+  }
+  if (!owner || isEmptyObject(filter)) {
+    delete filters[column];
+  }
+  return filters;
+}
+function clearFilters(filters) {
+  for (const column of Object.keys(filters)) {
+    delete filters[column];
+  }
+  return filters;
+}
+function hasFilter(filters, { column, owner }) {
+  const filter = filters[column];
+  if (!filter) {
+    return false;
+  }
+  if (!owner) {
+    return true;
+  }
+  for (const type of Object.values(FilterType)) {
+    if (owner === filter[type]?.owner) {
+      return true;
+    }
+  }
+  return false;
+}
+function getFilter(filters, { column, type, owner }) {
+  const filter = filters[column];
+  if (!filter) {
+    return null;
+  }
+  if (!owner || owner === filter[type]?.owner) {
+    return filter[type] || null;
+  }
+  return null;
+}
+
+// src/geo.ts
+import bboxClip from "@turf/bbox-clip";
+import bboxPolygon from "@turf/bbox-polygon";
+import union from "@turf/union";
+import { getType } from "@turf/invariant";
+import { polygon, multiPolygon, feature, featureCollection } from "@turf/helpers";
+function createViewportSpatialFilter(viewport) {
+  if (_isGlobalViewport(viewport)) {
+    return;
+  }
+  return createPolygonSpatialFilter(bboxPolygon(viewport).geometry);
+}
+function createPolygonSpatialFilter(spatialFilter) {
+  return spatialFilter && _normalizeGeometry(spatialFilter) || void 0;
+}
+function _isGlobalViewport(viewport) {
+  const [minx, miny, maxx, maxy] = viewport;
+  return maxx - minx > 179.5 * 2 && maxy - miny > 85.05 * 2;
+}
+function _normalizeGeometry(geometry) {
+  const WORLD = [-180, -90, 180, 90];
+  const worldClip = _clean(
+    bboxClip(geometry, WORLD).geometry
+  );
+  const geometryTxWest = _tx(geometry, 360);
+  const geometryTxEast = _tx(geometry, -360);
+  let result = worldClip;
+  if (result && geometryTxWest) {
+    const worldWestClip = _clean(
+      bboxClip(geometryTxWest, WORLD).geometry
+    );
+    if (worldWestClip) {
+      const collection = featureCollection([
+        feature(result),
+        feature(worldWestClip)
+      ]);
+      const merged = union(collection);
+      result = merged ? _clean(merged.geometry) : result;
+    }
+  }
+  if (result && geometryTxEast) {
+    const worldEastClip = _clean(
+      bboxClip(geometryTxEast, WORLD).geometry
+    );
+    if (worldEastClip) {
+      const collection = featureCollection([
+        feature(result),
+        feature(worldEastClip)
+      ]);
+      const merged = union(collection);
+      result = merged ? _clean(merged.geometry) : result;
+    }
+  }
+  return result;
+}
+function _cleanPolygonCoords(cc) {
+  const coords = cc.filter((c) => c.length > 0);
+  return coords.length > 0 ? coords : null;
+}
+function _cleanMultiPolygonCoords(ccc) {
+  const coords = ccc.map(_cleanPolygonCoords).filter((cc) => cc);
+  return coords.length > 0 ? coords : null;
+}
+function _clean(geometry) {
+  if (!geometry) {
+    return null;
+  }
+  if (_isPolygon(geometry)) {
+    const coords = _cleanPolygonCoords(geometry.coordinates);
+    return coords ? polygon(coords).geometry : null;
+  }
+  if (_isMultiPolygon(geometry)) {
+    const coords = _cleanMultiPolygonCoords(geometry.coordinates);
+    return coords ? multiPolygon(coords).geometry : null;
+  }
+  return null;
+}
+function _txContourCoords(cc, distance) {
+  return cc.map((c) => [c[0] + distance, c[1]]);
+}
+function _txPolygonCoords(ccc, distance) {
+  return ccc.map((cc) => _txContourCoords(cc, distance));
+}
+function _txMultiPolygonCoords(cccc, distance) {
+  return cccc.map((ccc) => _txPolygonCoords(ccc, distance));
+}
+function _tx(geometry, distance) {
+  if (geometry && getType(geometry) === "Polygon") {
+    const coords = _txPolygonCoords(
+      geometry.coordinates,
+      distance
+    );
+    return polygon(coords).geometry;
+  } else if (geometry && getType(geometry) === "MultiPolygon") {
+    const coords = _txMultiPolygonCoords(
+      geometry.coordinates,
+      distance
+    );
+    return multiPolygon(coords).geometry;
+  } else {
+    return null;
+  }
+}
+function _isPolygon(geometry) {
+  return getType(geometry) === "Polygon";
+}
+function _isMultiPolygon(geometry) {
+  return getType(geometry) === "MultiPolygon";
+}
+
+// src/api/endpoints.ts
+function joinPath(...args) {
+  return args.map((part) => part.endsWith("/") ? part.slice(0, -1) : part).join("/");
+}
+function buildV3Path(apiBaseUrl, version, endpoint, ...rest) {
+  return joinPath(apiBaseUrl, version, endpoint, ...rest);
+}
+function buildPublicMapUrl({
+  apiBaseUrl,
+  cartoMapId
+}) {
+  return buildV3Path(apiBaseUrl, "v3", "maps", "public", cartoMapId);
+}
+function buildStatsUrl({
+  attribute,
+  apiBaseUrl,
+  connectionName,
+  source,
+  type
+}) {
+  if (type === "query") {
+    return buildV3Path(apiBaseUrl, "v3", "stats", connectionName, attribute);
+  }
+  return buildV3Path(
+    apiBaseUrl,
+    "v3",
+    "stats",
+    connectionName,
+    source,
+    attribute
+  );
+}
+function buildSourceUrl({
+  apiBaseUrl,
+  connectionName,
+  endpoint
+}) {
+  return buildV3Path(apiBaseUrl, "v3", "maps", connectionName, endpoint);
+}
+function buildQueryUrl({
+  apiBaseUrl,
+  connectionName
+}) {
+  return buildV3Path(apiBaseUrl, "v3", "sql", connectionName, "query");
+}
+
+// src/api/carto-api-error.ts
+var CartoAPIError = class extends Error {
+  constructor(error, errorContext, response, responseJson) {
+    let responseString = "Failed to connect";
+    if (response) {
+      responseString = "Server returned: ";
+      if (response.status === 400) {
+        responseString += "Bad request";
+      } else if (response.status === 401 || response.status === 403) {
+        responseString += "Unauthorized access";
+      } else if (response.status === 404) {
+        responseString += "Not found";
+      } else {
+        responseString += "Error";
+      }
+      responseString += ` (${response.status}):`;
+    }
+    responseString += ` ${error.message || error}`;
+    let message = `${errorContext.requestType} API request failed`;
+    message += `
+${responseString}`;
+    for (const key of Object.keys(errorContext)) {
+      if (key === "requestType") continue;
+      message += `
+${formatErrorKey(key)}: ${errorContext[key]}`;
+    }
+    message += "\n";
+    super(message);
+    /** Source error from server */
+    __publicField(this, "error");
+    /** Context (API call & parameters) in which error occured */
+    __publicField(this, "errorContext");
+    /** Response from server */
+    __publicField(this, "response");
+    /** JSON Response from server */
+    __publicField(this, "responseJson");
+    this.name = "CartoAPIError";
+    this.response = response;
+    this.responseJson = responseJson;
+    this.error = error;
+    this.errorContext = errorContext;
+  }
+};
+function formatErrorKey(key) {
+  return key.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase());
+}
+
+// src/api/request-with-parameters.ts
+var DEFAULT_HEADERS = {
+  Accept: "application/json",
+  "Content-Type": "application/json"
+};
+var DEFAULT_REQUEST_CACHE = /* @__PURE__ */ new Map();
+async function requestWithParameters({
+  baseUrl,
+  parameters = {},
+  headers: customHeaders = {},
+  errorContext,
+  maxLengthURL = DEFAULT_MAX_LENGTH_URL,
+  localCache
+}) {
+  parameters = {
+    v: V3_MINOR_VERSION,
+    client: getClient(),
+    ...typeof deck !== "undefined" && deck.VERSION && { deckglVersion: deck.VERSION },
+    ...parameters
+  };
+  baseUrl = excludeURLParameters(baseUrl, Object.keys(parameters));
+  const key = createCacheKey(baseUrl, parameters, customHeaders);
+  const {
+    cache: REQUEST_CACHE,
+    canReadCache,
+    canStoreInCache
+  } = getCacheSettings(localCache);
+  if (canReadCache && REQUEST_CACHE.has(key)) {
+    return REQUEST_CACHE.get(key);
+  }
+  const url = createURLWithParameters(baseUrl, parameters);
+  const headers = { ...DEFAULT_HEADERS, ...customHeaders };
+  const fetchPromise = url.length > maxLengthURL ? fetch(baseUrl, {
+    method: "POST",
+    body: JSON.stringify(parameters),
+    headers
+  }) : fetch(url, { headers });
+  let response;
+  let responseJson;
+  const jsonPromise = fetchPromise.then((_response) => {
+    response = _response;
+    return response.json();
+  }).then((json) => {
+    responseJson = json;
+    if (!response || !response.ok) {
+      throw new Error(json.error);
+    }
+    return json;
+  }).catch((error) => {
+    if (canStoreInCache) {
+      REQUEST_CACHE.delete(key);
+    }
+    throw new CartoAPIError(error, errorContext, response, responseJson);
+  });
+  if (canStoreInCache) {
+    REQUEST_CACHE.set(key, jsonPromise);
+  }
+  return jsonPromise;
+}
+function getCacheSettings(localCache) {
+  const canReadCache = localCache?.cacheControl?.includes("no-cache") ? false : true;
+  const canStoreInCache = localCache?.cacheControl?.includes("no-store") ? false : true;
+  const cache = localCache?.cache || DEFAULT_REQUEST_CACHE;
+  return {
+    cache,
+    canReadCache,
+    canStoreInCache
+  };
+}
+function createCacheKey(baseUrl, parameters, headers) {
+  const parameterEntries = Object.entries(parameters).sort(
+    ([a], [b]) => a > b ? 1 : -1
+  );
+  const headerEntries = Object.entries(headers).sort(
+    ([a], [b]) => a > b ? 1 : -1
+  );
+  return JSON.stringify({
+    baseUrl,
+    parameters: parameterEntries,
+    headers: headerEntries
+  });
+}
+function createURLWithParameters(baseUrlString, parameters) {
+  const baseUrl = new URL(baseUrlString);
+  for (const [key, value] of Object.entries(parameters)) {
+    if (isPureObject(value) || Array.isArray(value)) {
+      baseUrl.searchParams.set(key, JSON.stringify(value));
+    } else {
+      baseUrl.searchParams.set(
+        key,
+        value.toString()
+      );
+    }
+  }
+  return baseUrl.toString();
+}
+function excludeURLParameters(baseUrlString, parameters) {
+  const baseUrl = new URL(baseUrlString);
+  for (const param of parameters) {
+    if (baseUrl.searchParams.has(param)) {
+      baseUrl.searchParams.delete(param);
+    }
+  }
+  return baseUrl.toString();
+}
+
+// src/sources/base-source.ts
+var SOURCE_DEFAULTS = {
+  apiBaseUrl: DEFAULT_API_BASE_URL,
+  clientId: getClient(),
+  format: "tilejson",
+  headers: {},
+  maxLengthURL: DEFAULT_MAX_LENGTH_URL
+};
+async function baseSource(endpoint, options, urlParameters) {
+  const { accessToken, connectionName, cache, ...optionalOptions } = options;
+  const mergedOptions = {
+    ...SOURCE_DEFAULTS,
+    accessToken,
+    connectionName,
+    endpoint
+  };
+  for (const key in optionalOptions) {
+    if (optionalOptions[key]) {
+      mergedOptions[key] = optionalOptions[key];
+    }
+  }
+  const baseUrl = buildSourceUrl(mergedOptions);
+  const { clientId, maxLengthURL, format, localCache } = mergedOptions;
+  const headers = {
+    Authorization: `Bearer ${options.accessToken}`,
+    ...options.headers
+  };
+  const parameters = { client: clientId, ...urlParameters };
+  const errorContext = {
+    requestType: "Map instantiation",
+    connection: options.connectionName,
+    type: endpoint,
+    source: JSON.stringify(parameters, void 0, 2)
+  };
+  const mapInstantiation = await requestWithParameters({
+    baseUrl,
+    parameters,
+    headers,
+    errorContext,
+    maxLengthURL,
+    localCache
+  });
+  const dataUrl = mapInstantiation[format].url[0];
+  if (cache) {
+    cache.value = parseInt(
+      new URL(dataUrl).searchParams.get("cache") || "",
+      10
+    );
+  }
+  errorContext.requestType = "Map data";
+  if (format === "tilejson") {
+    const json = await requestWithParameters({
+      baseUrl: dataUrl,
+      headers,
+      errorContext,
+      maxLengthURL,
+      localCache
+    });
+    if (accessToken) {
+      json.accessToken = accessToken;
+    }
+    return json;
+  }
+  return await requestWithParameters({
+    baseUrl: dataUrl,
+    headers,
+    errorContext,
+    maxLengthURL,
+    localCache
+  });
+}
+
+// src/sources/boundary-query-source.ts
+var boundaryQuerySource = async function(options) {
+  const {
+    columns,
+    filters,
+    tilesetTableName,
+    propertiesSqlQuery,
+    queryParameters
+  } = options;
+  const urlParameters = {
+    tilesetTableName,
+    propertiesSqlQuery
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(",");
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  return baseSource(
+    "boundary",
+    options,
+    urlParameters
+  );
+};
+
+// src/sources/boundary-table-source.ts
+var boundaryTableSource = async function(options) {
+  const { filters, tilesetTableName, columns, propertiesTableName } = options;
+  const urlParameters = {
+    tilesetTableName,
+    propertiesTableName
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(",");
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource(
+    "boundary",
+    options,
+    urlParameters
+  );
+};
+
+// src/models/common.ts
+function dealWithApiError({
+  response,
+  data
+}) {
+  if (data.error === "Column not found") {
+    throw new InvalidColumnError(`${data.error} ${data.column_name}`);
+  }
+  if (typeof data.error === "string" && data.error?.includes("Missing columns")) {
+    throw new InvalidColumnError(data.error);
+  }
+  switch (response.status) {
+    case 401:
+      throw new Error("Unauthorized access. Invalid credentials");
+    case 403:
+      throw new Error("Forbidden access to the requested data");
+    default:
+      throw new Error(
+        data && data.error && typeof data.error === "string" ? data.error : JSON.stringify(data?.hint || data.error?.[0])
+      );
+  }
+}
+async function makeCall({
+  url,
+  accessToken,
+  opts
+}) {
+  let response;
+  let data;
+  const isPost = opts?.method === "POST";
+  try {
+    response = await fetch(url.toString(), {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        ...isPost && { "Content-Type": "application/json" },
+        ...opts.headers
+      },
+      ...isPost && {
+        method: opts?.method,
+        body: opts?.body
+      },
+      signal: opts?.abortController?.signal,
+      ...opts?.otherOptions
+    });
+    data = await response.json();
+  } catch (error) {
+    if (error.name === "AbortError") throw error;
+    throw new Error(`Failed request: ${error}`);
+  }
+  if (!response.ok) {
+    dealWithApiError({ response, data });
+  }
+  return data;
+}
+
+// src/models/model.ts
+var AVAILABLE_MODELS = [
+  "category",
+  "histogram",
+  "formula",
+  "pick",
+  "timeseries",
+  "range",
+  "scatterplot",
+  "table"
+];
+var { V3 } = ApiVersion;
+var REQUEST_GET_MAX_URL_LENGTH = 2048;
+function executeModel(props) {
+  assert(props.source, "executeModel: missing source");
+  assert(props.model, "executeModel: missing model");
+  assert(props.params, "executeModel: missing params");
+  assert(
+    AVAILABLE_MODELS.includes(props.model),
+    `executeModel: model provided isn't valid. Available models: ${AVAILABLE_MODELS.join(
+      ", "
+    )}`
+  );
+  const { model, source, params, opts } = props;
+  const { type, apiVersion, apiBaseUrl, accessToken, connectionName, clientId } = source;
+  assert(apiBaseUrl, "executeModel: missing apiBaseUrl");
+  assert(accessToken, "executeModel: missing accessToken");
+  assert(apiVersion === V3, "executeModel: SQL Model API requires CARTO 3+");
+  assert(type !== "tileset", "executeModel: Tilesets not supported");
+  let url = `${apiBaseUrl}/v3/sql/${connectionName}/model/${model}`;
+  const {
+    data,
+    filters,
+    filtersLogicalOperator = "and",
+    spatialDataType = "geo",
+    spatialFiltersMode = "intersects",
+    spatialFiltersResolution = 0
+  } = source;
+  const queryParams = {
+    type,
+    client: clientId,
+    source: data,
+    params,
+    queryParameters: source.queryParameters || "",
+    filters,
+    filtersLogicalOperator
+  };
+  const spatialDataColumn = source.spatialDataColumn || DEFAULT_GEO_COLUMN;
+  if (model === "pick") {
+    queryParams.spatialDataColumn = spatialDataColumn;
+  }
+  const spatialFilters = source.spatialFilter ? { [spatialDataColumn]: source.spatialFilter } : void 0;
+  if (spatialFilters) {
+    queryParams.spatialFilters = spatialFilters;
+    queryParams.spatialDataColumn = spatialDataColumn;
+    queryParams.spatialDataType = spatialDataType;
+  }
+  if (spatialDataType !== "geo") {
+    if (spatialFiltersResolution > 0) {
+      queryParams.spatialFiltersResolution = spatialFiltersResolution;
+    }
+    queryParams.spatialFiltersMode = spatialFiltersMode;
+  }
+  const urlWithSearchParams = url + "?" + objectToURLSearchParams(queryParams).toString();
+  const isGet = urlWithSearchParams.length <= REQUEST_GET_MAX_URL_LENGTH;
+  if (isGet) {
+    url = urlWithSearchParams;
+  }
+  return makeCall({
+    url,
+    accessToken: source.accessToken,
+    opts: {
+      ...opts,
+      method: isGet ? "GET" : "POST",
+      ...!isGet && { body: JSON.stringify(queryParams) }
+    }
+  });
+}
+function objectToURLSearchParams(object) {
+  const params = new URLSearchParams();
+  for (const key in object) {
+    if (isPureObject(object[key])) {
+      params.append(key, JSON.stringify(object[key]));
+    } else if (Array.isArray(object[key])) {
+      params.append(key, JSON.stringify(object[key]));
+    } else if (object[key] === null) {
+      params.append(key, "null");
+    } else if (object[key] !== void 0) {
+      params.append(key, String(object[key]));
+    }
+  }
+  return params;
+}
+
+// src/widget-sources/widget-remote-source.ts
+var WidgetRemoteSource = class extends WidgetSource {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_headers", {});
+  }
+  /** Assigns HTTP headers to be included on API requests from this source. */
+  setRequestHeaders(headers) {
+    this._headers = headers;
+  }
+  _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
+    };
+  }
+  async getCategories(options) {
+    const {
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      abortController,
+      ...params
+    } = options;
+    const { column, operation, operationColumn } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    return executeModel({
+      model: "category",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: {
+        column,
+        operation,
+        operationColumn: operationColumn || column
+      },
+      opts: { abortController, headers: this._headers }
+    }).then((res) => normalizeObjectKeys(res.rows));
+  }
+  async getFeatures(options) {
+    const {
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      abortController,
+      ...params
+    } = options;
+    const { columns, dataType, featureIds, z, limit, tileResolution } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    return executeModel({
+      model: "pick",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: {
+        columns,
+        dataType,
+        featureIds,
+        z,
+        limit: limit || 1e3,
+        tileResolution: tileResolution || DEFAULT_TILE_RESOLUTION
+      },
+      opts: { abortController, headers: this._headers }
+      // Avoid `normalizeObjectKeys()`, which changes column names.
+    }).then(({ rows }) => ({ rows }));
+  }
+  async getFormula(options) {
+    const {
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      abortController,
+      operationExp,
+      ...params
+    } = options;
+    const { column, operation } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    return executeModel({
+      model: "formula",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: {
+        column: column ?? "*",
+        operation: operation ?? "count",
+        operationExp
+      },
+      opts: { abortController, headers: this._headers }
+    }).then((res) => normalizeObjectKeys(res.rows[0]));
+  }
+  async getHistogram(options) {
+    const {
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      abortController,
+      ...params
+    } = options;
+    const { column, operation, ticks } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    const data = await executeModel({
+      model: "histogram",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: { column, operation, ticks },
+      opts: { abortController, headers: this._headers }
+    }).then((res) => normalizeObjectKeys(res.rows));
+    if (data.length) {
+      const result = Array(ticks.length + 1).fill(0);
+      data.forEach(
+        ({ tick, value }) => result[tick] = value
+      );
+      return result;
+    }
+    return [];
+  }
+  async getRange(options) {
+    const {
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      abortController,
+      ...params
+    } = options;
+    const { column } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    return executeModel({
+      model: "range",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: { column },
+      opts: { abortController, headers: this._headers }
+    }).then((res) => normalizeObjectKeys(res.rows[0]));
+  }
+  async getScatter(options) {
+    const {
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      abortController,
+      ...params
+    } = options;
+    const { xAxisColumn, xAxisJoinOperation, yAxisColumn, yAxisJoinOperation } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    const HARD_LIMIT = 500;
+    return executeModel({
+      model: "scatterplot",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: {
+        xAxisColumn,
+        xAxisJoinOperation,
+        yAxisColumn,
+        yAxisJoinOperation,
+        limit: HARD_LIMIT
+      },
+      opts: { abortController, headers: this._headers }
+    }).then((res) => normalizeObjectKeys(res.rows)).then((res) => res.map(({ x, y }) => [x, y]));
+  }
+  async getTable(options) {
+    const {
+      filters = this.props.filters,
+      filterOwner,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      abortController,
+      ...params
+    } = options;
+    const { columns, sortBy, sortDirection, offset = 0, limit = 10 } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    return executeModel({
+      model: "table",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: {
+        column: columns,
+        sortBy,
+        sortDirection,
+        limit,
+        offset
+      },
+      opts: { abortController, headers: this._headers }
+    }).then((res) => ({
+      // Avoid `normalizeObjectKeys()`, which changes column names.
+      rows: res.rows ?? res.ROWS,
+      totalCount: res.metadata?.total ?? res.METADATA?.TOTAL
+    }));
+  }
+  async getTimeSeries(options) {
+    const {
+      filters = this.props.filters,
+      filterOwner,
+      abortController,
+      spatialFilter,
+      spatialFiltersMode,
+      spatialIndexReferenceViewState,
+      ...params
+    } = options;
+    const {
+      column,
+      operationColumn,
+      joinOperation,
+      operation,
+      stepSize,
+      stepMultiplier,
+      splitByCategory,
+      splitByCategoryLimit,
+      splitByCategoryValues
+    } = params;
+    const source = this.getModelSource(filters, filterOwner);
+    const spatialFiltersResolution = this._getSpatialFiltersResolution(
+      source,
+      spatialFilter,
+      spatialIndexReferenceViewState
+    );
+    return executeModel({
+      model: "timeseries",
+      source: {
+        ...source,
+        spatialFiltersResolution,
+        spatialFiltersMode,
+        spatialFilter
+      },
+      params: {
+        column,
+        stepSize,
+        stepMultiplier,
+        operationColumn: operationColumn || column,
+        joinOperation,
+        operation,
+        splitByCategory,
+        splitByCategoryLimit,
+        splitByCategoryValues
+      },
+      opts: { abortController, headers: this._headers }
+    }).then((res) => ({
+      rows: normalizeObjectKeys(res.rows),
+      categories: res.metadata?.categories
+    }));
+  }
+};
+
+// src/widget-sources/widget-query-source.ts
+var WidgetQuerySource = class extends WidgetRemoteSource {
+  getModelSource(filters, filterOwner) {
+    return {
+      ...super._getModelSource(filters, filterOwner),
+      type: "query",
+      data: this.props.sqlQuery,
+      queryParameters: this.props.queryParameters
+    };
+  }
+};
+
+// src/widget-sources/widget-table-source.ts
+var WidgetTableSource = class extends WidgetRemoteSource {
+  getModelSource(filters, filterOwner) {
+    return {
+      ...super._getModelSource(filters, filterOwner),
+      type: "table",
+      data: this.props.tableName
+    };
+  }
+};
+
+// src/widget-sources/widget-tileset-worker-source.ts
+var _WidgetTilesetWorkerSource = class _WidgetTilesetWorkerSource extends WidgetSource {
+  constructor(props) {
+    super(props);
+    _WidgetTilesetWorkerSource.init();
+    _WidgetTilesetWorkerSource.WORKER.postMessage({
+      tableName: this.props.tableName,
+      method: "init" /* INIT */,
+      params: [this.props]
+    });
+  }
+  /**
+   * 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) {
+    tiles = tiles.map(({ id, bbox, data }) => ({
+      id,
+      bbox,
+      data
+    }));
+    _WidgetTilesetWorkerSource.WORKER.postMessage({
+      tableName: this.props.tableName,
+      method: "loadTiles" /* LOAD_TILES */,
+      params: [tiles]
+    });
+  }
+  /** Configures options used to extract features from tiles. */
+  setTileFeatureExtractOptions(options) {
+    _WidgetTilesetWorkerSource.WORKER.postMessage({
+      tableName: this.props.tableName,
+      type: "setTileFeatureExtractOptions" /* SET_TILE_FEATURE_EXTRACT_OPTIONS */,
+      params: [options]
+    });
+  }
+  /**
+   * Loads features as GeoJSON (used for testing).
+   * @experimental
+   * @internal Not for public use. Spatial filters in other method calls will be ignored.
+   */
+  loadGeoJSON({
+    geojson,
+    spatialFilter
+  }) {
+    _WidgetTilesetWorkerSource.WORKER.postMessage({
+      tableName: this.props.tableName,
+      method: "loadGeoJSON" /* LOAD_GEOJSON */,
+      params: [{ geojson, spatialFilter }]
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async getFeatures() {
+    throw new Error("getFeatures not supported for tilesets");
+  }
+  async getFormula({
+    abortController,
+    ...options
+  }) {
+    return this._executeWorkerMethod(
+      this.props.tableName,
+      "getFormula" /* GET_FORMULA */,
+      [options],
+      abortController?.signal
+    );
+  }
+  async getHistogram({
+    abortController,
+    ...options
+  }) {
+    return this._executeWorkerMethod(
+      this.props.tableName,
+      "getHistogram" /* GET_HISTOGRAM */,
+      [options],
+      abortController?.signal
+    );
+  }
+  async getCategories({
+    abortController,
+    ...options
+  }) {
+    return this._executeWorkerMethod(
+      this.props.tableName,
+      "getCategories" /* GET_CATEGORIES */,
+      [options],
+      abortController?.signal
+    );
+  }
+  async getScatter({
+    abortController,
+    ...options
+  }) {
+    return this._executeWorkerMethod(
+      this.props.tableName,
+      "getScatter" /* GET_SCATTER */,
+      [options],
+      abortController?.signal
+    );
+  }
+  async getTable({
+    abortController,
+    ...options
+  }) {
+    return this._executeWorkerMethod(
+      this.props.tableName,
+      "getTable" /* GET_TABLE */,
+      [options],
+      abortController?.signal
+    );
+  }
+  async getTimeSeries({
+    abortController,
+    ...options
+  }) {
+    return this._executeWorkerMethod(
+      this.props.tableName,
+      "getTimeSeries" /* GET_TIME_SERIES */,
+      [options],
+      abortController?.signal
+    );
+  }
+  async getRange({
+    abortController,
+    ...options
+  }) {
+    return this._executeWorkerMethod(
+      this.props.tableName,
+      "getRange" /* GET_RANGE */,
+      [options],
+      abortController?.signal
+    );
+  }
+  static init() {
+    _WidgetTilesetWorkerSource.WORKER = new Worker(
+      new URL("@carto/api-client/worker", import.meta.url),
+      {
+        type: "module",
+        name: "cartowidgettileset"
+      }
+    );
+  }
+  _executeWorkerMethod(tableName, method, params, signal) {
+    const worker = _WidgetTilesetWorkerSource.WORKER;
+    const requestId = _WidgetTilesetWorkerSource._nextRequestID++;
+    const options = params[0];
+    if (options?.spatialIndexReferenceViewState) {
+      const { zoom, latitude, longitude } = options.spatialIndexReferenceViewState;
+      options.spatialIndexReferenceViewState = { zoom, latitude, longitude };
+    }
+    worker.postMessage({
+      requestId,
+      tableName,
+      method,
+      params
+    });
+    return new Promise((resolve, reject) => {
+      function listener(e) {
+        const response = e.data;
+        if (response.requestId !== requestId) return;
+        worker.removeEventListener("message", listener);
+        if (signal?.aborted) {
+          reject(new Error(signal.reason));
+        } else if (response.ok) {
+          resolve(response.result);
+        } else {
+          reject(new Error(response.error));
+        }
+      }
+      worker.addEventListener("message", listener);
+    });
+  }
+};
+/////////////////////////////////////////////////////////////////////////////
+// WEB WORKER MANAGEMENT
+// TODO: Singleton? Pool shared among datasets? One per dataset?
+__publicField(_WidgetTilesetWorkerSource, "WORKER");
+__publicField(_WidgetTilesetWorkerSource, "_nextRequestID", 1);
+var WidgetTilesetWorkerSource = _WidgetTilesetWorkerSource;
+
+// src/sources/h3-query-source.ts
+var h3QuerySource = async function(options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
+    sqlQuery,
+    spatialDataColumn = "h3",
+    queryParameters,
+    filters
+  } = options;
+  const spatialDataType = "h3";
+  const urlParameters = {
+    aggregationExp,
+    spatialDataColumn,
+    spatialDataType,
+    q: sqlQuery
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource("query", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetQuerySource({
+        ...options,
+        // NOTE: Parameters with default values above must be explicitly passed here.
+        spatialDataColumn,
+        spatialDataType
+      })
+    })
+  );
+};
+
+// src/sources/h3-table-source.ts
+var h3TableSource = async function(options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_H3,
+    spatialDataColumn = "h3",
+    tableName,
+    filters
+  } = options;
+  const spatialDataType = "h3";
+  const urlParameters = {
+    aggregationExp,
+    name: tableName,
+    spatialDataColumn,
+    spatialDataType
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource("table", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetTableSource({
+        ...options,
+        // NOTE: Parameters with default values above must be explicitly passed here.
+        spatialDataColumn,
+        spatialDataType
+      })
+    })
+  );
+};
+
+// src/utils/getTileFormat.ts
+function getTileFormat(tilejson) {
+  const tileParams = new URL(tilejson.tiles[0]).searchParams;
+  return tileParams.get("formatTiles") === "mvt" ? "mvt" /* MVT */ : "binary" /* BINARY */;
+}
+
+// src/workers/utils.ts
+var _isModuleWorkerSupported = false ? false : null;
+function isModuleWorkerSupported() {
+  if (_isModuleWorkerSupported !== null) {
+    return _isModuleWorkerSupported;
+  }
+  try {
+    new Worker("blob://", {
+      get type() {
+        _isModuleWorkerSupported = true;
+        return "module";
+      }
+    });
+  } catch {
+  } finally {
+    _isModuleWorkerSupported || (_isModuleWorkerSupported = false);
+  }
+  return _isModuleWorkerSupported;
+}
+
+// src/sources/h3-tileset-source.ts
+var h3TilesetSource = async function(options) {
+  const { tableName, spatialDataColumn = "h3" } = options;
+  const urlParameters = { name: tableName };
+  const WidgetSourceClass = options.widgetSourceWorker !== false && isModuleWorkerSupported() ? WidgetTilesetWorkerSource : WidgetTilesetSource;
+  return baseSource("tileset", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetSourceClass({
+        ...options,
+        tileFormat: getTileFormat(result),
+        spatialDataColumn,
+        spatialDataType: "h3"
+      })
+    })
+  );
+};
+
+// src/sources/raster-source.ts
+var rasterSource = async function(options) {
+  const { tableName, filters } = options;
+  const urlParameters = { name: tableName };
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource(
+    "raster",
+    options,
+    urlParameters
+  );
+};
+
+// src/sources/quadbin-query-source.ts
+var quadbinQuerySource = async function(options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
+    sqlQuery,
+    spatialDataColumn = "quadbin",
+    queryParameters,
+    filters
+  } = options;
+  const spatialDataType = "quadbin";
+  const urlParameters = {
+    aggregationExp,
+    q: sqlQuery,
+    spatialDataColumn,
+    spatialDataType
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource("query", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetQuerySource({
+        ...options,
+        // NOTE: Parameters with default values above must be explicitly passed here.
+        spatialDataColumn,
+        spatialDataType
+      })
+    })
+  );
+};
+
+// src/sources/quadbin-table-source.ts
+var quadbinTableSource = async function(options) {
+  const {
+    aggregationExp,
+    aggregationResLevel = DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN,
+    spatialDataColumn = "quadbin",
+    tableName,
+    filters
+  } = options;
+  const spatialDataType = "quadbin";
+  const urlParameters = {
+    aggregationExp,
+    name: tableName,
+    spatialDataColumn,
+    spatialDataType
+  };
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  return baseSource("table", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetTableSource({
+        ...options,
+        // NOTE: Parameters with default values above must be explicitly passed here.
+        spatialDataColumn,
+        spatialDataType
+      })
+    })
+  );
+};
+
+// src/sources/quadbin-tileset-source.ts
+var quadbinTilesetSource = async function(options) {
+  const { tableName, spatialDataColumn = "quadbin" } = options;
+  const urlParameters = { name: tableName };
+  const WidgetSourceClass = options.widgetSourceWorker !== false && isModuleWorkerSupported() ? WidgetTilesetWorkerSource : WidgetTilesetSource;
+  return baseSource("tileset", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetSourceClass({
+        ...options,
+        tileFormat: getTileFormat(result),
+        spatialDataColumn,
+        spatialDataType: "quadbin"
+      })
+    })
+  );
+};
+
+// src/sources/vector-query-source.ts
+var vectorQuerySource = async function(options) {
+  const {
+    columns,
+    filters,
+    spatialDataColumn = DEFAULT_GEO_COLUMN,
+    sqlQuery,
+    tileResolution = DEFAULT_TILE_RESOLUTION,
+    queryParameters,
+    aggregationExp
+  } = options;
+  const spatialDataType = "geo";
+  const urlParameters = {
+    spatialDataColumn,
+    spatialDataType,
+    tileResolution: tileResolution.toString(),
+    q: sqlQuery
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(",");
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  if (queryParameters) {
+    urlParameters.queryParameters = queryParameters;
+  }
+  if (aggregationExp) {
+    urlParameters.aggregationExp = aggregationExp;
+  }
+  return baseSource("query", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetQuerySource({
+        ...options,
+        // NOTE: Parameters with default values above must be explicitly passed here.
+        spatialDataColumn,
+        spatialDataType,
+        tileResolution
+      })
+    })
+  );
+};
+
+// src/sources/vector-table-source.ts
+var vectorTableSource = async function(options) {
+  const {
+    columns,
+    filters,
+    spatialDataColumn = DEFAULT_GEO_COLUMN,
+    tableName,
+    tileResolution = DEFAULT_TILE_RESOLUTION,
+    aggregationExp
+  } = options;
+  const spatialDataType = "geo";
+  const urlParameters = {
+    name: tableName,
+    spatialDataColumn,
+    spatialDataType,
+    tileResolution: tileResolution.toString()
+  };
+  if (columns) {
+    urlParameters.columns = columns.join(",");
+  }
+  if (filters) {
+    urlParameters.filters = filters;
+  }
+  if (aggregationExp) {
+    urlParameters.aggregationExp = aggregationExp;
+  }
+  return baseSource("table", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetTableSource({
+        ...options,
+        // NOTE: Parameters with default values above must be explicitly passed here.
+        spatialDataColumn,
+        spatialDataType,
+        tileResolution
+      })
+    })
+  );
+};
+
+// src/sources/vector-tileset-source.ts
+var vectorTilesetSource = async function(options) {
+  const { tableName, spatialDataColumn = DEFAULT_GEO_COLUMN } = options;
+  const urlParameters = { name: tableName };
+  const WidgetSourceClass = options.widgetSourceWorker !== false && isModuleWorkerSupported() ? WidgetTilesetWorkerSource : WidgetTilesetSource;
+  return baseSource("tileset", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetSourceClass({
+        ...options,
+        tileFormat: getTileFormat(result),
+        spatialDataColumn,
+        spatialDataType: "geo"
+      })
+    })
+  );
+};
+
+// src/api/query.ts
+var query = async function(options) {
+  const {
+    apiBaseUrl = SOURCE_DEFAULTS.apiBaseUrl,
+    clientId = SOURCE_DEFAULTS.clientId,
+    maxLengthURL = SOURCE_DEFAULTS.maxLengthURL,
+    localCache,
+    connectionName,
+    sqlQuery,
+    queryParameters
+  } = options;
+  const urlParameters = { q: sqlQuery };
+  if (queryParameters) {
+    urlParameters.queryParameters = JSON.stringify(queryParameters);
+  }
+  const baseUrl = buildQueryUrl({ apiBaseUrl, connectionName });
+  const headers = {
+    Authorization: `Bearer ${options.accessToken}`,
+    ...options.headers
+  };
+  const parameters = { client: clientId, ...urlParameters };
+  const errorContext = {
+    requestType: "SQL",
+    connection: options.connectionName,
+    type: "query",
+    source: JSON.stringify(parameters, void 0, 2)
+  };
+  return await requestWithParameters({
+    baseUrl,
+    parameters,
+    headers,
+    errorContext,
+    maxLengthURL,
+    localCache
+  });
+};
+export {
+  ApiVersion,
+  CartoAPIError,
+  DEFAULT_API_BASE_URL,
+  FEATURE_GEOM_PROPERTY,
+  FilterType,
+  Provider,
+  SOURCE_DEFAULTS,
+  SpatialIndex,
+  TileFormat,
+  WidgetQuerySource,
+  WidgetRemoteSource,
+  WidgetSource,
+  WidgetTableSource,
+  WidgetTilesetSource,
+  WidgetTilesetWorkerSource,
+  _buildFeatureFilter,
+  _getHexagonResolution,
+  addFilter,
+  aggregate,
+  aggregationFunctions,
+  applyFilters,
+  applySorting,
+  boundaryQuerySource,
+  boundaryTableSource,
+  buildBinaryFeatureFilter,
+  buildPublicMapUrl,
+  buildStatsUrl,
+  clearFilters,
+  createPolygonSpatialFilter,
+  createViewportSpatialFilter,
+  filterFunctions,
+  geojsonFeatures,
+  getClient,
+  getDataFilterExtensionProps,
+  getFilter,
+  groupValuesByColumn,
+  groupValuesByDateColumn,
+  h3QuerySource,
+  h3TableSource,
+  h3TilesetSource,
+  hasFilter,
+  histogram,
+  makeIntervalComplete,
+  quadbinQuerySource,
+  quadbinTableSource,
+  quadbinTilesetSource,
+  query,
+  rasterSource,
+  removeFilter,
+  requestWithParameters,
+  scatterPlot,
+  setClient,
+  tileFeatures,
+  tileFeaturesGeometries,
+  tileFeaturesSpatialIndex,
+  transformToTileCoords,
+  vectorQuerySource,
+  vectorTableSource,
+  vectorTilesetSource
+};