@deck.gl/carto 8.10.0-alpha.7 → 9.0.0-alpha.3

package/src/layers/vector-tile-layer.ts

@@ -1,6 +1,7 @@
 import {registerLoaders} from '@loaders.gl/core';
+import CartoPropertiesTileLoader from './schema/carto-properties-tile-loader';
 import CartoVectorTileLoader from './schema/carto-vector-tile-loader';
-registerLoaders([CartoVectorTileLoader]);
+registerLoaders([CartoPropertiesTileLoader, CartoVectorTileLoader]);
 
 import {DefaultProps} from '@deck.gl/core';
 import {ClipExtension} from '@deck.gl/extensions';
@@ -15,17 +16,15 @@ import {
 import {GeoJsonLayer} from '@deck.gl/layers';
 import {binaryToGeojson} from '@loaders.gl/gis';
 import type {BinaryFeatureCollection} from '@loaders.gl/schema';
-import {TileFormat, TILE_FORMATS} from '../api/maps-api-common';
 import type {Feature} from 'geojson';
-import {TilejsonPropType, CartoTilejsonResult} from '../sources/common';
-import {injectAccessToken} from './utils';
 
-const defaultTileFormat = TILE_FORMATS.BINARY;
+import type {TilejsonResult} from '../sources/types';
+import {TilejsonPropType, injectAccessToken, mergeBoundaryData} from './utils';
 
 const defaultProps: DefaultProps<VectorTileLayerProps> = {
   ...MVTLayer.defaultProps,
   data: TilejsonPropType,
-  formatTiles: defaultTileFormat
+  dataComparator: TilejsonPropType.equal
 };
 
 /** All properties supported by VectorTileLayer. */
@@ -33,14 +32,7 @@ export type VectorTileLayerProps = _VectorTileLayerProps & Omit<MVTLayerProps, '
 
 /** Properties added by VectorTileLayer. */
 type _VectorTileLayerProps = {
-  data: null | CartoTilejsonResult | Promise<CartoTilejsonResult>;
-  /** Use to override the default tile data format.
-   *
-   * Possible values are: `TILE_FORMATS.BINARY`, `TILE_FORMATS.GEOJSON` and `TILE_FORMATS.MVT`.
-   *
-   * Only supported when `apiVersion` is `API_VERSIONS.V3` and `format` is `FORMATS.TILEJSON`.
-   */
-  formatTiles?: TileFormat;
+  data: null | TilejsonResult | Promise<TilejsonResult>;
 };
 
 // TODO Perhaps we can't subclass MVTLayer and keep types. Better to subclass TileLayer instead?
@@ -51,10 +43,13 @@ export default class VectorTileLayer<ExtraProps extends {} = {}> extends MVTLaye
   static layerName = 'VectorTileLayer';
   static defaultProps = defaultProps;
 
+  state!: MVTLayer['state'] & {
+    mvt: boolean;
+  };
+
   initializeState(): void {
     super.initializeState();
-    const binary = this.props.formatTiles === TILE_FORMATS.BINARY || TILE_FORMATS.MVT;
-    this.setState({binary});
+    this.setState({binary: true});
   }
 
   updateState(parameters) {
@@ -63,21 +58,23 @@ export default class VectorTileLayer<ExtraProps extends {} = {}> extends MVTLaye
       super.updateState(parameters);
 
       const formatTiles = new URL(props.data.tiles[0]).searchParams.get('formatTiles');
-      const mvt = formatTiles === TILE_FORMATS.MVT;
+      const mvt = formatTiles === 'mvt';
       this.setState({mvt});
     }
   }
 
   getLoadOptions(): any {
     const loadOptions = super.getLoadOptions() || {};
-    const tileJSON = this.props.data as CartoTilejsonResult;
+    const tileJSON = this.props.data as TilejsonResult;
     injectAccessToken(loadOptions, tileJSON.accessToken);
     loadOptions.gis = {format: 'binary'}; // Use binary for MVT loading
     return loadOptions;
   }
 
-  getTileData(tile: TileLoadProps) {
-    const url = _getURLFromTemplate(this.state.data, tile);
+  async getTileData(tile: TileLoadProps) {
+    const tileJSON = this.props.data as TilejsonResult;
+    const {tiles, properties_tiles} = tileJSON;
+    const url = _getURLFromTemplate(tiles, tile);
     if (!url) {
       return Promise.reject('Invalid URL');
     }
@@ -85,7 +82,29 @@ export default class VectorTileLayer<ExtraProps extends {} = {}> extends MVTLaye
     const loadOptions = this.getLoadOptions();
     const {fetch} = this.props;
     const {signal} = tile;
-    return fetch(url, {propName: 'data', layer: this, loadOptions, signal});
+
+    // Fetch geometry and attributes separately
+    const geometryFetch = fetch(url, {propName: 'data', layer: this, loadOptions, signal});
+
+    if (!properties_tiles) {
+      return await geometryFetch;
+    }
+
+    const propertiesUrl = _getURLFromTemplate(properties_tiles, tile);
+    if (!propertiesUrl) {
+      return Promise.reject('Invalid properties URL');
+    }
+
+    const attributesFetch = fetch(propertiesUrl, {
+      propName: 'data',
+      layer: this,
+      loadOptions,
+      signal
+    });
+    const [geometry, attributes] = await Promise.all([geometryFetch, attributesFetch]);
+    if (!geometry) return null;
+
+    return mergeBoundaryData(geometry, attributes);
   }
 
   renderSubLayers(

package/src/sources/base-source.ts

@@ -1,25 +1,39 @@
-import type {MapType} from '../api/maps-api-common';
-import {APIErrorContext} from '../api/carto-api-error';
-import {
-  CartoSourceOptionalOptions,
-  CartoSourceRequiredOptions,
-  CartoTilejsonResult,
+/* eslint-disable camelcase */
+import {DEFAULT_API_BASE_URL, DEFAULT_CLIENT} from '../api/common';
+import {buildSourceUrl} from '../api/endpoints';
+import {requestWithParameters} from '../api/request-with-parameters';
+import type {APIErrorContext, MapType} from '../api/types';
+import type {
   GeojsonResult,
   JsonResult,
-  SOURCE_DEFAULTS,
+  SourceOptionalOptions,
+  SourceRequiredOptions,
   Tilejson,
-  TilejsonMapInstantiation
-} from './common';
-import {buildApiEndpoint, requestWithParameters} from './utils';
+  TilejsonMapInstantiation,
+  TilejsonResult
+} from './types';
 
-export async function cartoBaseSource<UrlParameters extends Record<string, string>>(
+export const SOURCE_DEFAULTS: SourceOptionalOptions = {
+  apiBaseUrl: DEFAULT_API_BASE_URL,
+  clientId: DEFAULT_CLIENT,
+  format: 'tilejson',
+  headers: {}
+};
+
+export async function baseSource<UrlParameters extends Record<string, string>>(
   endpoint: MapType,
-  options: Partial<CartoSourceOptionalOptions> & CartoSourceRequiredOptions,
+  options: Partial<SourceOptionalOptions> & SourceRequiredOptions,
   urlParameters: UrlParameters
-): Promise<CartoTilejsonResult | GeojsonResult | JsonResult> {
-  const mergedOptions = {...SOURCE_DEFAULTS, ...options, endpoint};
-  const baseUrl = buildApiEndpoint(mergedOptions);
-  const {accessToken, format} = mergedOptions;
+): Promise<TilejsonResult | GeojsonResult | JsonResult> {
+  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 {format} = mergedOptions;
   const headers = {Authorization: `Bearer ${options.accessToken}`, ...options.headers};
 
   const errorContext: APIErrorContext = {
@@ -36,15 +50,18 @@ export async function cartoBaseSource<UrlParameters extends Record<string, strin
   });
 
   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 tilejson = await requestWithParameters<Tilejson>({
+    return await requestWithParameters<TilejsonResult>({
+      accessToken,
       baseUrl: dataUrl,
       headers,
       errorContext
     });
-    return {...tilejson, accessToken};
   }
 
   return await requestWithParameters<GeojsonResult | JsonResult>({

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

@@ -0,0 +1,31 @@
+import {QueryParameters} from '../api';
+import {baseSource} from './base-source';
+import type {SourceOptions, TilejsonResult} from './types';
+
+export type BoundaryQuerySourceOptions = SourceOptions & {
+  boundaryId: string;
+  matchingColumn?: string;
+  sqlQuery: string;
+  queryParameters: QueryParameters;
+};
+type UrlParameters = {
+  boundaryId: string;
+  matchingColumn: string;
+  sqlQuery: string;
+  queryParameters?: string;
+};
+
+export const boundaryQuerySource = async function (
+  options: BoundaryQuerySourceOptions
+): Promise<TilejsonResult> {
+  const {boundaryId, matchingColumn = 'id', sqlQuery, queryParameters} = options;
+  const urlParameters: UrlParameters = {
+    boundaryId,
+    matchingColumn,
+    sqlQuery
+  };
+  if (queryParameters) {
+    urlParameters.queryParameters = JSON.stringify(queryParameters);
+  }
+  return baseSource<UrlParameters>('boundary', options, urlParameters) as Promise<TilejsonResult>;
+};

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

@@ -0,0 +1,31 @@
+import {baseSource} from './base-source';
+import type {SourceOptions, TilejsonResult} from './types';
+
+export type BoundaryTableSourceOptions = SourceOptions & {
+  boundaryId: string;
+  columns?: string[];
+  matchingColumn?: string;
+  tableName: string;
+};
+type UrlParameters = {
+  boundaryId: string;
+  columns?: string;
+  matchingColumn: string;
+  tableName: string;
+};
+
+export const boundaryTableSource = async function (
+  options: BoundaryTableSourceOptions
+): Promise<TilejsonResult> {
+  const {boundaryId, columns, matchingColumn = 'id', tableName} = options;
+  const urlParameters: UrlParameters = {
+    boundaryId,
+    matchingColumn,
+    tableName
+  };
+
+  if (columns) {
+    urlParameters.columns = columns.join(',');
+  }
+  return baseSource<UrlParameters>('boundary', options, urlParameters) as Promise<TilejsonResult>;
+};

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

@@ -0,0 +1,14 @@
+import {baseSource} from './base-source';
+import type {SourceOptions, TilejsonResult} from './types';
+
+export type BoundaryTilesetSourceOptions = SourceOptions & {boundaryId: string};
+type UrlParameters = {boundaryId: string};
+
+export const boundaryTilesetSource = async function (
+  options: BoundaryTilesetSourceOptions
+): Promise<TilejsonResult> {
+  const {boundaryId} = options;
+  const urlParameters: UrlParameters = {boundaryId};
+
+  return baseSource<UrlParameters>('boundary', options, urlParameters) as Promise<TilejsonResult>;
+};

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

@@ -1,45 +1,45 @@
 /* eslint-disable camelcase */
-import {cartoBaseSource} from './base-source';
-import {
-  CartoAggregationOptions,
-  CartoQuerySourceOptions,
-  CartoSourceOptions,
-  TilejsonSource
-} from './common';
+import {baseSource} from './base-source';
+import type {
+  AggregationOptions,
+  QuerySourceOptions,
+  SourceOptions,
+  SpatialDataType,
+  TilejsonResult
+} from './types';
 
-export type CartoH3QuerySourceOptions = CartoSourceOptions &
-  CartoQuerySourceOptions &
-  CartoAggregationOptions;
+export type H3QuerySourceOptions = SourceOptions & QuerySourceOptions & AggregationOptions;
 type UrlParameters = {
   aggregationExp: string;
   aggregationResLevel?: string;
-  geo_column?: string;
+  spatialDataType: SpatialDataType;
+  spatialDataColumn?: string;
   q: string;
   queryParameters?: string;
 };
 
-const cartoH3QuerySource: TilejsonSource<CartoH3QuerySourceOptions> = async function (
-  options: CartoH3QuerySourceOptions
-): Promise<any> {
+export const h3QuerySource = async function (
+  options: H3QuerySourceOptions
+): Promise<TilejsonResult> {
   const {
     aggregationExp,
     aggregationResLevel = 4,
     sqlQuery,
-    spatialDataColumn = 'h3:h3',
+    spatialDataColumn = 'h3',
     queryParameters
   } = options;
-  const urlParameters: UrlParameters = {aggregationExp, q: sqlQuery};
+  const urlParameters: UrlParameters = {
+    aggregationExp,
+    spatialDataColumn,
+    spatialDataType: 'h3',
+    q: sqlQuery
+  };
 
   if (aggregationResLevel) {
     urlParameters.aggregationResLevel = String(aggregationResLevel);
   }
-  if (spatialDataColumn) {
-    urlParameters.geo_column = spatialDataColumn;
-  }
   if (queryParameters) {
     urlParameters.queryParameters = JSON.stringify(queryParameters);
   }
-  return cartoBaseSource<UrlParameters>('query', options, urlParameters);
+  return baseSource<UrlParameters>('query', options, urlParameters) as Promise<TilejsonResult>;
 };
-
-export {cartoH3QuerySource};

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

@@ -1,35 +1,40 @@
 /* eslint-disable camelcase */
-import {cartoBaseSource} from './base-source';
-import {
-  CartoAggregationOptions,
-  CartoSourceOptions,
-  CartoTableSourceOptions,
-  TilejsonSource
-} from './common';
+import {baseSource} from './base-source';
+import type {
+  AggregationOptions,
+  SourceOptions,
+  SpatialDataType,
+  TableSourceOptions,
+  TilejsonResult
+} from './types';
 
-export type CartoH3TableSourceOptions = CartoSourceOptions &
-  CartoTableSourceOptions &
-  CartoAggregationOptions;
+export type H3TableSourceOptions = SourceOptions & TableSourceOptions & AggregationOptions;
 
 type UrlParameters = {
   aggregationExp: string;
   aggregationResLevel?: string;
   columns?: string;
-  geo_column?: string;
+  spatialDataType: SpatialDataType;
+  spatialDataColumn?: string;
   name: string;
 };
 
-const cartoH3TableSource: TilejsonSource<CartoH3TableSourceOptions> = async function (
-  options: CartoH3TableSourceOptions
-): Promise<any> {
+export const h3TableSource = async function (
+  options: H3TableSourceOptions
+): Promise<TilejsonResult> {
   const {
     aggregationExp,
     aggregationResLevel = 4,
     columns,
-    spatialDataColumn = 'h3:h3',
+    spatialDataColumn = 'h3',
     tableName
   } = options;
-  const urlParameters: UrlParameters = {aggregationExp, name: tableName};
+  const urlParameters: UrlParameters = {
+    aggregationExp,
+    name: tableName,
+    spatialDataColumn,
+    spatialDataType: 'h3'
+  };
 
   if (aggregationResLevel) {
     urlParameters.aggregationResLevel = String(aggregationResLevel);
@@ -37,10 +42,5 @@ const cartoH3TableSource: TilejsonSource<CartoH3TableSourceOptions> = async func
   if (columns) {
     urlParameters.columns = columns.join(',');
   }
-  if (spatialDataColumn) {
-    urlParameters.geo_column = spatialDataColumn;
-  }
-  return cartoBaseSource<UrlParameters>('table', options, urlParameters);
+  return baseSource<UrlParameters>('table', options, urlParameters) as Promise<TilejsonResult>;
 };
-
-export {cartoH3TableSource};

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

@@ -1,16 +1,14 @@
-import {cartoBaseSource} from './base-source';
-import {CartoSourceOptions, CartoTilesetSourceOptions, TilejsonSource} from './common';
+import {baseSource} from './base-source';
+import type {SourceOptions, TilejsonResult, TilesetSourceOptions} from './types';
 
-export type CartoH3TilesetSourceOptions = CartoSourceOptions & CartoTilesetSourceOptions;
+export type H3TilesetSourceOptions = SourceOptions & TilesetSourceOptions;
 type UrlParameters = {name: string};
 
-const cartoH3TilesetSource: TilejsonSource<CartoH3TilesetSourceOptions> = async function (
-  options: CartoH3TilesetSourceOptions
-): Promise<any> {
+export const h3TilesetSource = async function (
+  options: H3TilesetSourceOptions
+): Promise<TilejsonResult> {
   const {tableName} = options;
   const urlParameters: UrlParameters = {name: tableName};
 
-  return cartoBaseSource<UrlParameters>('tileset', options, urlParameters);
+  return baseSource<UrlParameters>('tileset', options, urlParameters) as Promise<TilejsonResult>;
 };
-
-export {cartoH3TilesetSource};

package/src/sources/index.ts

@@ -1,32 +1,41 @@
-export {SOURCE_DEFAULTS} from './common';
-export type {CartoTilejsonResult, GeojsonResult, JsonResult} from './common';
+export {SOURCE_DEFAULTS} from './base-source';
+export type {TilejsonResult, GeojsonResult, JsonResult} from './types';
 
-export {cartoH3QuerySource} from './h3-query-source';
-export type {CartoH3QuerySourceOptions} from './h3-query-source';
+export {boundaryQuerySource} from './boundary-query-source';
+export type {BoundaryQuerySourceOptions} from './boundary-query-source';
 
-export {cartoH3TableSource} from './h3-table-source';
-export type {CartoH3TableSourceOptions} from './h3-table-source';
+export {boundaryTableSource} from './boundary-table-source';
+export type {BoundaryTableSourceOptions} from './boundary-table-source';
 
-export {cartoH3TilesetSource} from './h3-tileset-source';
-export type {CartoH3TilesetSourceOptions} from './h3-tileset-source';
+export {boundaryTilesetSource} from './boundary-tileset-source';
+export type {BoundaryTilesetSourceOptions} from './boundary-tileset-source';
 
-export {cartoRasterSource} from './raster-source';
-export type {CartoRasterSourceOptions} from './raster-source';
+export {h3QuerySource} from './h3-query-source';
+export type {H3QuerySourceOptions} from './h3-query-source';
 
-export {cartoQuadbinQuerySource} from './quadbin-query-source';
-export type {CartoQuadbinQuerySourceOptions} from './quadbin-query-source';
+export {h3TableSource} from './h3-table-source';
+export type {H3TableSourceOptions} from './h3-table-source';
 
-export {cartoQuadbinTableSource} from './quadbin-table-source';
-export type {CartoQuadbinTableSourceOptions} from './quadbin-table-source';
+export {h3TilesetSource} from './h3-tileset-source';
+export type {H3TilesetSourceOptions} from './h3-tileset-source';
 
-export {cartoQuadbinTilesetSource} from './quadbin-tileset-source';
-export type {CartoQuadbinTilesetSourceOptions} from './quadbin-tileset-source';
+export {rasterSource} from './raster-source';
+export type {RasterSourceOptions} from './raster-source';
 
-export {cartoVectorQuerySource} from './vector-query-source';
-export type {CartoVectorQuerySourceOptions} from './vector-query-source';
+export {quadbinQuerySource} from './quadbin-query-source';
+export type {QuadbinQuerySourceOptions} from './quadbin-query-source';
 
-export {cartoVectorTableSource} from './vector-table-source';
-export type {CartoVectorTableSourceOptions} from './vector-table-source';
+export {quadbinTableSource} from './quadbin-table-source';
+export type {QuadbinTableSourceOptions} from './quadbin-table-source';
 
-export {cartoVectorTilesetSource} from './vector-tileset-source';
-export type {CartoVectorTilesetSourceOptions} from './vector-tileset-source';
+export {quadbinTilesetSource} from './quadbin-tileset-source';
+export type {QuadbinTilesetSourceOptions} from './quadbin-tileset-source';
+
+export {vectorQuerySource} from './vector-query-source';
+export type {VectorQuerySourceOptions} from './vector-query-source';
+
+export {vectorTableSource} from './vector-table-source';
+export type {VectorTableSourceOptions} from './vector-table-source';
+
+export {vectorTilesetSource} from './vector-tileset-source';
+export type {VectorTilesetSourceOptions} from './vector-tileset-source';

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

@@ -1,46 +1,46 @@
 /* eslint-disable camelcase */
-import {cartoBaseSource} from './base-source';
-import {
-  CartoAggregationOptions,
-  CartoQuerySourceOptions,
-  CartoSourceOptions,
-  TilejsonSource
-} from './common';
+import {baseSource} from './base-source';
+import type {
+  AggregationOptions,
+  QuerySourceOptions,
+  SourceOptions,
+  SpatialDataType,
+  TilejsonResult
+} from './types';
 
-export type CartoQuadbinQuerySourceOptions = CartoSourceOptions &
-  CartoQuerySourceOptions &
-  CartoAggregationOptions;
+export type QuadbinQuerySourceOptions = SourceOptions & QuerySourceOptions & AggregationOptions;
 
 type UrlParameters = {
   aggregationExp: string;
   aggregationResLevel?: string;
-  geo_column?: string;
+  spatialDataType: SpatialDataType;
+  spatialDataColumn?: string;
   q: string;
   queryParameters?: string;
 };
 
-const cartoQuadbinQuerySource: TilejsonSource<CartoQuadbinQuerySourceOptions> = async function (
-  options: CartoQuadbinQuerySourceOptions
-): Promise<any> {
+export const quadbinQuerySource = async function (
+  options: QuadbinQuerySourceOptions
+): Promise<TilejsonResult> {
   const {
     aggregationExp,
     aggregationResLevel = 6,
     sqlQuery,
-    spatialDataColumn = 'quadbin:quadbin',
+    spatialDataColumn = 'quadbin',
     queryParameters
   } = options;
-  const urlParameters: UrlParameters = {aggregationExp, q: sqlQuery};
+  const urlParameters: UrlParameters = {
+    aggregationExp,
+    q: sqlQuery,
+    spatialDataColumn,
+    spatialDataType: 'quadbin'
+  };
 
   if (aggregationResLevel) {
     urlParameters.aggregationResLevel = String(aggregationResLevel);
   }
-  if (spatialDataColumn) {
-    urlParameters.geo_column = spatialDataColumn;
-  }
   if (queryParameters) {
     urlParameters.queryParameters = JSON.stringify(queryParameters);
   }
-  return cartoBaseSource<UrlParameters>('query', options, urlParameters);
+  return baseSource<UrlParameters>('query', options, urlParameters) as Promise<TilejsonResult>;
 };
-
-export {cartoQuadbinQuerySource};

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

@@ -1,35 +1,41 @@
 /* eslint-disable camelcase */
-import {cartoBaseSource} from './base-source';
-import {
-  CartoAggregationOptions,
-  CartoSourceOptions,
-  CartoTableSourceOptions,
-  TilejsonSource
-} from './common';
+import {baseSource} from './base-source';
+import type {
+  AggregationOptions,
+  SourceOptions,
+  SpatialDataType,
+  TableSourceOptions,
+  TilejsonResult
+} from './types';
 
-export type CartoQuadbinTableSourceOptions = CartoSourceOptions &
-  CartoTableSourceOptions &
-  CartoAggregationOptions;
+export type QuadbinTableSourceOptions = SourceOptions & TableSourceOptions & AggregationOptions;
 
 type UrlParameters = {
   aggregationExp: string;
   aggregationResLevel?: string;
   columns?: string;
-  geo_column?: string;
+  spatialDataType: SpatialDataType;
+  spatialDataColumn?: string;
   name: string;
 };
 
-const cartoQuadbinTableSource: TilejsonSource<CartoQuadbinTableSourceOptions> = async function (
-  options: CartoQuadbinTableSourceOptions
-): Promise<any> {
+export const quadbinTableSource = async function (
+  options: QuadbinTableSourceOptions
+): Promise<TilejsonResult> {
   const {
     aggregationExp,
     aggregationResLevel = 6,
     columns,
-    spatialDataColumn = 'quadbin:quadbin',
+    spatialDataColumn = 'quadbin',
     tableName
   } = options;
-  const urlParameters: UrlParameters = {aggregationExp, name: tableName};
+
+  const urlParameters: UrlParameters = {
+    aggregationExp,
+    name: tableName,
+    spatialDataColumn,
+    spatialDataType: 'quadbin'
+  };
 
   if (aggregationResLevel) {
     urlParameters.aggregationResLevel = String(aggregationResLevel);
@@ -37,10 +43,5 @@ const cartoQuadbinTableSource: TilejsonSource<CartoQuadbinTableSourceOptions> =
   if (columns) {
     urlParameters.columns = columns.join(',');
   }
-  if (spatialDataColumn) {
-    urlParameters.geo_column = spatialDataColumn;
-  }
-  return cartoBaseSource<UrlParameters>('table', options, urlParameters);
+  return baseSource<UrlParameters>('table', options, urlParameters) as Promise<TilejsonResult>;
 };
-
-export {cartoQuadbinTableSource};