@deck.gl/carto 8.10.0-alpha.2 → 8.10.0-alpha.4

package/src/layers/schema/carto-vector-tile-loader.ts

@@ -1,32 +1,102 @@
+import earcut from 'earcut';
 import {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';
-import type {BinaryFeatures} from '@loaders.gl/schema';
+import type {BinaryFeatures, BinaryPolygonFeatures, TypedArray} from '@loaders.gl/schema';
 
 import {TileReader} from './carto-tile';
 import {parsePbf} from './tile-loader-utils';
+import {getWorkerUrl} from '../../utils';
+
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+const id = 'cartoVectorTile';
+
+type CartoVectorTileLoaderOptions = LoaderOptions & {
+  cartoVectorTile?: {
+    workerUrl: string;
+  };
+};
+
+const DEFAULT_OPTIONS: CartoVectorTileLoaderOptions = {
+  cartoVectorTile: {
+    workerUrl: getWorkerUrl(id, VERSION)
+  }
+};
 
 const CartoVectorTileLoader: LoaderWithParser = {
   name: 'CARTO Vector Tile',
-  version: '1',
-  id: 'cartoVectorTile',
+  version: VERSION,
+  id,
   module: 'carto',
   extensions: ['pbf'],
   mimeTypes: ['application/vnd.carto-vector-tile'],
   category: 'geometry',
-  worker: false,
-  parse: async (arrayBuffer, options) => parseCartoVectorTile(arrayBuffer, options),
+  parse: async (arrayBuffer, options?: CartoVectorTileLoaderOptions) =>
+    parseCartoVectorTile(arrayBuffer, options),
   parseSync: parseCartoVectorTile,
-  options: {}
+  worker: true,
+  options: DEFAULT_OPTIONS
 };
 
+function triangulatePolygon(
+  polygons: BinaryPolygonFeatures,
+  target: number[],
+  {
+    startPosition,
+    endPosition,
+    indices
+  }: {startPosition: number; endPosition: number; indices: TypedArray}
+): void {
+  const coordLength = polygons.positions.size;
+  const start = startPosition * coordLength;
+  const end = endPosition * coordLength;
+
+  // Extract positions and holes for just this polygon
+  const polygonPositions = polygons.positions.value.subarray(start, end);
+
+  // Holes are referenced relative to outer polygon
+  const holes = indices.slice(1).map((n: number) => n - startPosition);
+
+  // Compute triangulation
+  const triangles = earcut(polygonPositions, holes, coordLength);
+
+  // Indices returned by triangulation are relative to start
+  // of polygon, so we need to offset
+  for (let t = 0, tl = triangles.length; t < tl; ++t) {
+    target.push(startPosition + triangles[t]);
+  }
+}
+
+function triangulate(polygons: BinaryPolygonFeatures) {
+  const {polygonIndices, positions, primitivePolygonIndices} = polygons;
+  const triangles = [];
+
+  let rangeStart = 0;
+  for (let i = 0; i < polygonIndices.value.length - 1; i++) {
+    const startPosition = polygonIndices.value[i];
+    const endPosition = polygonIndices.value[i + 1];
+
+    // Extract hole indices between start & end position
+    const rangeEnd = primitivePolygonIndices.value.indexOf(endPosition);
+    const indices = primitivePolygonIndices.value.subarray(rangeStart, rangeEnd);
+    rangeStart = rangeEnd;
+
+    triangulatePolygon(polygons, triangles, {startPosition, endPosition, indices});
+  }
+
+  polygons.triangles = {value: new Uint32Array(triangles), size: 1};
+}
+
 function parseCartoVectorTile(
   arrayBuffer: ArrayBuffer,
-  options?: LoaderOptions
+  options?: CartoVectorTileLoaderOptions
 ): BinaryFeatures | null {
   if (!arrayBuffer) return null;
   const tile = parsePbf(arrayBuffer, TileReader);
 
-  // Note: there is slight, difference in `numericProps` type, however geojson/mvtlayer can cope with this
-  return tile as unknown as BinaryFeatures;
+  if (tile.polygons && !tile.polygons.triangles) {
+    triangulate(tile.polygons);
+  }
+
+  return tile;
 }
 
 export default CartoVectorTileLoader;

package/src/layers/utils.ts

@@ -0,0 +1,11 @@
+/**
+ * Adds access token to Authorization header in loadOptions
+ */
+export function injectAccessToken(loadOptions: any, accessToken: string): void {
+  if (!loadOptions?.fetch?.headers?.Authorization) {
+    loadOptions.fetch = {
+      ...loadOptions.fetch,
+      headers: {...loadOptions.fetch?.headers, Authorization: `Bearer ${accessToken}`}
+    };
+  }
+}

package/src/layers/{carto-tile-layer.ts → vector-tile-layer.ts}

@@ -17,19 +17,23 @@ import {binaryToGeojson} from '@loaders.gl/gis';
 import type {BinaryFeatures} 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;
 
-const defaultProps: DefaultProps<CartoTileLayerProps> = {
+const defaultProps: DefaultProps<VectorTileLayerProps> = {
   ...MVTLayer.defaultProps,
+  data: TilejsonPropType,
   formatTiles: defaultTileFormat
 };
 
-/** All properties supported by CartoTileLayer. */
-export type CartoTileLayerProps = _CartoTileLayerProps & MVTLayerProps;
+/** All properties supported by VectorTileLayer. */
+export type VectorTileLayerProps = _VectorTileLayerProps & Omit<MVTLayerProps, 'data'>;
 
-/** Properties added by CartoTileLayer. */
-type _CartoTileLayerProps = {
+/** 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`.
@@ -39,37 +43,48 @@ type _CartoTileLayerProps = {
   formatTiles?: TileFormat;
 };
 
-export default class CartoTileLayer<ExtraProps extends {} = {}> extends MVTLayer<
-  Required<_CartoTileLayerProps> & ExtraProps
+// TODO Perhaps we can't subclass MVTLayer and keep types. Better to subclass TileLayer instead?
+// @ts-ignore
+export default class VectorTileLayer<ExtraProps extends {} = {}> extends MVTLayer<
+  Required<_VectorTileLayerProps> & ExtraProps
 > {
-  static layerName = 'CartoTileLayer';
+  static layerName = 'VectorTileLayer';
   static defaultProps = defaultProps;
 
   initializeState(): void {
     super.initializeState();
-    const binary = this.props.formatTiles === TILE_FORMATS.BINARY;
+    const binary = this.props.formatTiles === TILE_FORMATS.BINARY || TILE_FORMATS.MVT;
     this.setState({binary});
   }
 
+  updateState(parameters) {
+    const {props} = parameters;
+    if (props.data) {
+      super.updateState(parameters);
+
+      const formatTiles = new URL(props.data.tiles[0]).searchParams.get('formatTiles');
+      const mvt = formatTiles === TILE_FORMATS.MVT;
+      this.setState({mvt});
+    }
+  }
+
+  getLoadOptions(): any {
+    const loadOptions = super.getLoadOptions() || {};
+    const tileJSON = this.props.data as CartoTilejsonResult;
+    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);
     if (!url) {
       return Promise.reject('Invalid URL');
     }
 
-    let loadOptions = this.getLoadOptions();
-    const {fetch, formatTiles} = this.props;
+    const loadOptions = this.getLoadOptions();
+    const {fetch} = this.props;
     const {signal} = tile;
-
-    // The backend doesn't yet support our custom mime-type, so force it here
-    // TODO remove once backend sends the correct mime-type
-    if (formatTiles === TILE_FORMATS.BINARY) {
-      loadOptions = {
-        ...loadOptions,
-        mimeType: 'application/vnd.carto-vector-tile'
-      };
-    }
-
     return fetch(url, {propName: 'data', layer: this, loadOptions, signal});
   }
 
@@ -85,6 +100,10 @@ export default class CartoTileLayer<ExtraProps extends {} = {}> extends MVTLayer
       return null;
     }
 
+    if (this.state.mvt) {
+      return super.renderSubLayers(props) as GeoJsonLayer;
+    }
+
     const tileBbox = props.tile.bbox as any;
     const {west, south, east, north} = tileBbox;
 

package/src/sources/base-source.ts

@@ -0,0 +1,55 @@
+import type {MapType} from '../api/maps-api-common';
+import {APIErrorContext} from '../api/carto-api-error';
+import {
+  CartoSourceOptionalOptions,
+  CartoSourceRequiredOptions,
+  CartoTilejsonResult,
+  GeojsonResult,
+  JsonResult,
+  SOURCE_DEFAULTS,
+  Tilejson,
+  TilejsonMapInstantiation
+} from './common';
+import {buildApiEndpoint, requestWithParameters} from './utils';
+
+export async function cartoBaseSource<UrlParameters extends Record<string, string>>(
+  endpoint: MapType,
+  options: Partial<CartoSourceOptionalOptions> & CartoSourceRequiredOptions,
+  urlParameters: UrlParameters
+): Promise<CartoTilejsonResult | GeojsonResult | JsonResult> {
+  const mergedOptions = {...SOURCE_DEFAULTS, ...options, endpoint};
+  const baseUrl = buildApiEndpoint(mergedOptions);
+  const {accessToken, format} = mergedOptions;
+  const headers = {Authorization: `Bearer ${options.accessToken}`, ...options.headers};
+
+  const errorContext: APIErrorContext = {
+    requestType: 'Map instantiation',
+    connection: options.connectionName,
+    type: endpoint,
+    source: JSON.stringify(urlParameters, undefined, 2)
+  };
+  const mapInstantiation = await requestWithParameters<TilejsonMapInstantiation>({
+    baseUrl,
+    parameters: urlParameters,
+    headers,
+    errorContext
+  });
+
+  const dataUrl = mapInstantiation[format].url[0];
+  errorContext.requestType = 'Map data';
+
+  if (format === 'tilejson') {
+    const tilejson = await requestWithParameters<Tilejson>({
+      baseUrl: dataUrl,
+      headers,
+      errorContext
+    });
+    return {...tilejson, accessToken};
+  }
+
+  return await requestWithParameters<GeojsonResult | JsonResult>({
+    baseUrl: dataUrl,
+    headers,
+    errorContext
+  });
+}

package/src/sources/common.ts

@@ -0,0 +1,132 @@
+/* eslint-disable camelcase */
+import type {Feature} from 'geojson';
+import {Format, MapInstantiation, TileFormat, QueryParameters} from '../api/maps-api-common';
+
+export type CartoSourceRequiredOptions = {
+  accessToken: string;
+  connectionName: string;
+};
+
+export type CartoSourceOptionalOptions = {
+  apiBaseUrl: string;
+  clientId: string;
+  format: Format;
+  formatTiles: TileFormat;
+  headers: Record<string, string>;
+  mapsUrl?: string;
+};
+
+export type CartoSourceOptions = CartoSourceRequiredOptions & Partial<CartoSourceOptionalOptions>;
+
+export type CartoAggregationOptions = {
+  aggregationExp: string;
+  aggregationResLevel?: number;
+};
+
+export type CartoQuerySourceOptions = {
+  spatialDataColumn?: string;
+  sqlQuery: string;
+  queryParameters?: QueryParameters;
+};
+
+export type CartoTableSourceOptions = {
+  columns?: string[];
+  spatialDataColumn?: string;
+  tableName: string;
+};
+
+export type CartoTilesetSourceOptions = {
+  tableName: string;
+};
+
+export const SOURCE_DEFAULTS: CartoSourceOptionalOptions = {
+  apiBaseUrl: 'https://gcp-us-east1.api.carto.com',
+  clientId: 'deck-gl-carto',
+  format: 'tilejson',
+  formatTiles: 'binary',
+  headers: {}
+};
+
+export type TilejsonMapInstantiation = MapInstantiation & {
+  tilejson: {url: string[]};
+};
+
+export interface Tilejson {
+  tilejson: string;
+  name: string;
+  description: string;
+  version: string;
+  attribution: string;
+  scheme: string;
+  tiles: string[];
+  properties_tiles: string[];
+  minresolution: number;
+  maxresolution: number;
+  minzoom: number;
+  maxzoom: number;
+  bounds: [number, number, number, number];
+  center: [number, number, number];
+  vector_layers: VectorLayer[];
+  tilestats: Tilestats;
+}
+
+export interface Tilestats {
+  layerCount: number;
+  layers: Layer[];
+}
+
+export interface Layer {
+  layer: string;
+  count: number;
+  attributeCount: number;
+  attributes: Attribute[];
+}
+
+export interface Attribute {
+  attribute: string;
+  type: string;
+}
+
+export interface VectorLayer {
+  id: string;
+  minzoom: number;
+  maxzoom: number;
+  fields: Record<string, string>;
+}
+
+export type CartoTilejsonResult = Tilejson & {accessToken: string};
+export type GeojsonResult = {type: 'FeatureCollection'; features: Feature[]};
+export type JsonResult = any[];
+export interface TilejsonSource<T> {
+  (options: T & {format?: 'tilejson'}): Promise<CartoTilejsonResult>;
+}
+export interface TypedSource<T> extends TilejsonSource<T> {
+  (options: T & {format: 'geojson'}): Promise<GeojsonResult>;
+  (options: T & {format: 'json'}): Promise<JsonResult>;
+}
+
+export const DEFAULT_CLIENT = 'deck-gl-carto';
+export const V3_MINOR_VERSION = '3.2';
+export const MAX_GET_LENGTH = 8192;
+
+export const DEFAULT_PARAMETERS = {
+  client: DEFAULT_CLIENT,
+  v: V3_MINOR_VERSION
+};
+
+export const DEFAULT_HEADERS = {
+  Accept: 'application/json',
+  'Content-Type': 'application/json'
+};
+
+export const TilejsonPropType = {
+  type: 'object' as const,
+  value: null as null | CartoTilejsonResult,
+  validate: (value: CartoTilejsonResult, propType) =>
+    (propType.optional && value === null) ||
+    (typeof value === 'object' &&
+      Array.isArray(value.tiles) &&
+      value.tiles.every(url => typeof url === 'string')),
+  compare: 2,
+  async: true
+};

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

@@ -0,0 +1,45 @@
+/* eslint-disable camelcase */
+import {cartoBaseSource} from './base-source';
+import {
+  CartoAggregationOptions,
+  CartoQuerySourceOptions,
+  CartoSourceOptions,
+  TilejsonSource
+} from './common';
+
+export type CartoH3QuerySourceOptions = CartoSourceOptions &
+  CartoQuerySourceOptions &
+  CartoAggregationOptions;
+type UrlParameters = {
+  aggregationExp: string;
+  aggregationResLevel?: string;
+  geo_column?: string;
+  q: string;
+  queryParameters?: string;
+};
+
+const cartoH3QuerySource: TilejsonSource<CartoH3QuerySourceOptions> = async function (
+  options: CartoH3QuerySourceOptions
+): Promise<any> {
+  const {
+    aggregationExp,
+    aggregationResLevel = 4,
+    sqlQuery,
+    spatialDataColumn = 'h3:h3',
+    queryParameters
+  } = options;
+  const urlParameters: UrlParameters = {aggregationExp, 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);
+};
+
+export {cartoH3QuerySource};

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

@@ -0,0 +1,46 @@
+/* eslint-disable camelcase */
+import {cartoBaseSource} from './base-source';
+import {
+  CartoAggregationOptions,
+  CartoSourceOptions,
+  CartoTableSourceOptions,
+  TilejsonSource
+} from './common';
+
+export type CartoH3TableSourceOptions = CartoSourceOptions &
+  CartoTableSourceOptions &
+  CartoAggregationOptions;
+
+type UrlParameters = {
+  aggregationExp: string;
+  aggregationResLevel?: string;
+  columns?: string;
+  geo_column?: string;
+  name: string;
+};
+
+const cartoH3TableSource: TilejsonSource<CartoH3TableSourceOptions> = async function (
+  options: CartoH3TableSourceOptions
+): Promise<any> {
+  const {
+    aggregationExp,
+    aggregationResLevel = 4,
+    columns,
+    spatialDataColumn = 'h3:h3',
+    tableName
+  } = options;
+  const urlParameters: UrlParameters = {aggregationExp, name: tableName};
+
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  if (columns) {
+    urlParameters.columns = columns.join(',');
+  }
+  if (spatialDataColumn) {
+    urlParameters.geo_column = spatialDataColumn;
+  }
+  return cartoBaseSource<UrlParameters>('table', options, urlParameters);
+};
+
+export {cartoH3TableSource};

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

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

package/src/sources/index.ts

@@ -0,0 +1,32 @@
+export {SOURCE_DEFAULTS} from './common';
+export type {CartoTilejsonResult, GeojsonResult, JsonResult} from './common';
+
+export {cartoH3QuerySource} from './h3-query-source';
+export type {CartoH3QuerySourceOptions} from './h3-query-source';
+
+export {cartoH3TableSource} from './h3-table-source';
+export type {CartoH3TableSourceOptions} from './h3-table-source';
+
+export {cartoH3TilesetSource} from './h3-tileset-source';
+export type {CartoH3TilesetSourceOptions} from './h3-tileset-source';
+
+export {cartoRasterSource} from './raster-source';
+export type {CartoRasterSourceOptions} from './raster-source';
+
+export {cartoQuadbinQuerySource} from './quadbin-query-source';
+export type {CartoQuadbinQuerySourceOptions} from './quadbin-query-source';
+
+export {cartoQuadbinTableSource} from './quadbin-table-source';
+export type {CartoQuadbinTableSourceOptions} from './quadbin-table-source';
+
+export {cartoQuadbinTilesetSource} from './quadbin-tileset-source';
+export type {CartoQuadbinTilesetSourceOptions} from './quadbin-tileset-source';
+
+export {cartoVectorQuerySource} from './vector-query-source';
+export type {CartoVectorQuerySourceOptions} from './vector-query-source';
+
+export {cartoVectorTableSource} from './vector-table-source';
+export type {CartoVectorTableSourceOptions} from './vector-table-source';
+
+export {cartoVectorTilesetSource} from './vector-tileset-source';
+export type {CartoVectorTilesetSourceOptions} from './vector-tileset-source';

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

@@ -0,0 +1,46 @@
+/* eslint-disable camelcase */
+import {cartoBaseSource} from './base-source';
+import {
+  CartoAggregationOptions,
+  CartoQuerySourceOptions,
+  CartoSourceOptions,
+  TilejsonSource
+} from './common';
+
+export type CartoQuadbinQuerySourceOptions = CartoSourceOptions &
+  CartoQuerySourceOptions &
+  CartoAggregationOptions;
+
+type UrlParameters = {
+  aggregationExp: string;
+  aggregationResLevel?: string;
+  geo_column?: string;
+  q: string;
+  queryParameters?: string;
+};
+
+const cartoQuadbinQuerySource: TilejsonSource<CartoQuadbinQuerySourceOptions> = async function (
+  options: CartoQuadbinQuerySourceOptions
+): Promise<any> {
+  const {
+    aggregationExp,
+    aggregationResLevel = 6,
+    sqlQuery,
+    spatialDataColumn = 'quadbin:quadbin',
+    queryParameters
+  } = options;
+  const urlParameters: UrlParameters = {aggregationExp, 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);
+};
+
+export {cartoQuadbinQuerySource};

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

@@ -0,0 +1,46 @@
+/* eslint-disable camelcase */
+import {cartoBaseSource} from './base-source';
+import {
+  CartoAggregationOptions,
+  CartoSourceOptions,
+  CartoTableSourceOptions,
+  TilejsonSource
+} from './common';
+
+export type CartoQuadbinTableSourceOptions = CartoSourceOptions &
+  CartoTableSourceOptions &
+  CartoAggregationOptions;
+
+type UrlParameters = {
+  aggregationExp: string;
+  aggregationResLevel?: string;
+  columns?: string;
+  geo_column?: string;
+  name: string;
+};
+
+const cartoQuadbinTableSource: TilejsonSource<CartoQuadbinTableSourceOptions> = async function (
+  options: CartoQuadbinTableSourceOptions
+): Promise<any> {
+  const {
+    aggregationExp,
+    aggregationResLevel = 6,
+    columns,
+    spatialDataColumn = 'quadbin:quadbin',
+    tableName
+  } = options;
+  const urlParameters: UrlParameters = {aggregationExp, name: tableName};
+
+  if (aggregationResLevel) {
+    urlParameters.aggregationResLevel = String(aggregationResLevel);
+  }
+  if (columns) {
+    urlParameters.columns = columns.join(',');
+  }
+  if (spatialDataColumn) {
+    urlParameters.geo_column = spatialDataColumn;
+  }
+  return cartoBaseSource<UrlParameters>('table', options, urlParameters);
+};
+
+export {cartoQuadbinTableSource};

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

@@ -0,0 +1,16 @@
+import {cartoBaseSource} from './base-source';
+import {CartoSourceOptions, CartoTilesetSourceOptions, TilejsonSource} from './common';
+
+export type CartoQuadbinTilesetSourceOptions = CartoSourceOptions & CartoTilesetSourceOptions;
+type UrlParameters = {name: string};
+
+const cartoQuadbinTilesetSource: TilejsonSource<CartoQuadbinTilesetSourceOptions> = async function (
+  options: CartoQuadbinTilesetSourceOptions
+): Promise<any> {
+  const {tableName} = options;
+  const urlParameters: UrlParameters = {name: tableName};
+
+  return cartoBaseSource<UrlParameters>('tileset', options, urlParameters);
+};
+
+export {cartoQuadbinTilesetSource};

package/src/sources/raster-source.ts

@@ -0,0 +1,16 @@
+import {cartoBaseSource} from './base-source';
+import {CartoSourceOptions, CartoTilesetSourceOptions, TypedSource} from './common';
+
+export type CartoRasterSourceOptions = CartoSourceOptions & CartoTilesetSourceOptions;
+type UrlParameters = {name: string};
+
+const cartoRasterSource: TypedSource<CartoRasterSourceOptions> = async function (
+  options: CartoRasterSourceOptions
+): Promise<any> {
+  const {tableName} = options;
+  const urlParameters: UrlParameters = {name: tableName};
+
+  return cartoBaseSource<UrlParameters>('raster', options, urlParameters);
+};
+
+export {cartoRasterSource};