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

package/build/api-client.modern.js

@@ -6,6 +6,7 @@ import { featureCollection, feature, polygon, multiPolygon } from '@turf/helpers
 import intersects from '@turf/boolean-intersects';
 import booleanWithin from '@turf/boolean-within';
 import intersect from '@turf/intersect';
+import { getResolution as getResolution$1, geometryToCells, cellToChildren, cellToTile } from 'quadbin';
 import { getResolution as getResolution$2, polygonToCells } from 'h3-js';
 
 /**
@@ -635,7 +636,7 @@ function excludeURLParameters(baseUrlString, parameters) {
   return baseUrl.toString();
 }
 
-const _excluded$2 = ["accessToken", "connectionName", "cache"];
+const _excluded$3 = ["accessToken", "connectionName", "cache"];
 const SOURCE_DEFAULTS = {
   apiBaseUrl: DEFAULT_API_BASE_URL,
   clientId: getClient(),
@@ -649,7 +650,7 @@ async function baseSource(endpoint, options, urlParameters) {
       connectionName,
       cache
     } = options,
-    optionalOptions = _objectWithoutPropertiesLoose(options, _excluded$2);
+    optionalOptions = _objectWithoutPropertiesLoose(options, _excluded$3);
   const mergedOptions = _extends({}, SOURCE_DEFAULTS, {
     accessToken,
     connectionName,
@@ -777,7 +778,7 @@ function getSpatialFiltersResolution(source, viewState) {
     const tileSize = DEFAULT_TILE_SIZE;
     const maxResolutionForZoom = (_maxH3SpatialFiltersR = (_maxH3SpatialFiltersR2 = maxH3SpatialFiltersResolutions.find(([zoom]) => zoom === currentZoomInt)) == null ? void 0 : _maxH3SpatialFiltersR2[1]) != null ? _maxH3SpatialFiltersR : Math.max(0, currentZoomInt - 3);
     const maxSpatialFiltersResolution = maxResolutionForZoom ? Math.min(dataResolution, maxResolutionForZoom) : dataResolution;
-    const hexagonResolution = getHexagonResolution(viewState, tileSize) + aggregationResLevelOffset;
+    const hexagonResolution = _getHexagonResolution(viewState, tileSize) + aggregationResLevelOffset;
     return Math.min(hexagonResolution, maxSpatialFiltersResolution);
   }
   if (source.spatialDataType === 'quadbin') {
@@ -792,10 +793,13 @@ const maxH3SpatialFiltersResolutions = [[20, 14], [19, 13], [18, 12], [17, 11],
 // stolen from https://github.com/visgl/deck.gl/blob/master/modules/carto/src/layers/h3-tileset-2d.ts
 // Relative scale factor (0 = no biasing, 2 = a few hexagons cover view)
 const BIAS = 2;
-// Resolution conversion function. Takes a WebMercatorViewport and returns
-// a H3 resolution such that the screen space size of the hexagons is
-// similar
-function getHexagonResolution(viewport, tileSize) {
+/**
+ * Resolution conversion function. Takes a WebMercatorViewport and returns
+ * a H3 resolution such that the screen space size of the hexagons is
+ * "similar" to the given tileSize on screen. Intended for use with deck.gl.
+ * @internal
+ */
+function _getHexagonResolution(viewport, tileSize) {
   // Difference in given tile size compared to deck's internal 512px tile size,
   // expressed as an offset to the viewport zoom.
   const zoomOffset = Math.log2(tileSize / DEFAULT_TILE_SIZE);
@@ -1013,7 +1017,7 @@ function objectToURLSearchParams(object) {
   return params;
 }
 
-const _excluded$1 = ["filterOwner", "spatialFilter", "spatialFiltersMode", "spatialIndexReferenceViewState", "abortController"],
+const _excluded$2 = ["filterOwner", "spatialFilter", "spatialFiltersMode", "spatialIndexReferenceViewState", "abortController"],
   _excluded2 = ["filterOwner", "spatialFilter", "spatialFiltersMode", "spatialIndexReferenceViewState", "abortController"],
   _excluded3 = ["filterOwner", "spatialFilter", "spatialFiltersMode", "spatialIndexReferenceViewState", "abortController", "operationExp"],
   _excluded4 = ["filterOwner", "spatialFilter", "spatialFiltersMode", "spatialIndexReferenceViewState", "abortController"],
@@ -1035,7 +1039,7 @@ class WidgetRemoteSource extends WidgetSource {
         spatialIndexReferenceViewState,
         abortController
       } = options,
-      params = _objectWithoutPropertiesLoose(options, _excluded$1);
+      params = _objectWithoutPropertiesLoose(options, _excluded$2);
     const {
       column,
       operation,
@@ -1380,37 +1384,6 @@ class WidgetQuerySource extends WidgetRemoteSource {
   }
 }
 
-/**
- * Source for Widget API requests on a data source defined as a table.
- *
- * Generally not intended to be constructed directly. Instead, call
- * {@link vectorTableSource}, {@link h3TableSource}, or {@link quadbinTableSource},
- * which can be shared with map layers. Sources contain a `widgetSource` property,
- * for use by widget implementations.
- *
- * Example:
- *
- * ```javascript
- * import { vectorTableSource } from '@carto/api-client';
- *
- * const data = vectorTableSource({
- *   accessToken: '••••',
- *   connectionName: 'carto_dw',
- *   tableName: 'carto-demo-data.demo_tables.retail_stores'
- * });
- *
- * const { widgetSource } = await data;
- * ```
- */
-class WidgetTableSource extends WidgetRemoteSource {
-  getModelSource(owner) {
-    return _extends({}, super._getModelSource(owner), {
-      type: 'table',
-      data: this.props.tableName
-    });
-  }
-}
-
 function makeIntervalComplete(intervals) {
   return intervals.map(val => {
     if (val[0] === undefined || val[0] === null) {
@@ -2107,369 +2080,6 @@ function createIndicesForPoints(data) {
   data.pointIndices = pointIndices;
 }
 
-// a tile is an array [x,y,z]
-var d2r = Math.PI / 180,
-  r2d = 180 / Math.PI;
-function tileToBBOX(tile) {
-  var e = tile2lon(tile[0] + 1, tile[2]);
-  var w = tile2lon(tile[0], tile[2]);
-  var s = tile2lat(tile[1] + 1, tile[2]);
-  var n = tile2lat(tile[1], tile[2]);
-  return [w, s, e, n];
-}
-function tileToGeoJSON(tile) {
-  var bbox = tileToBBOX(tile);
-  var poly = {
-    type: 'Polygon',
-    coordinates: [[[bbox[0], bbox[1]], [bbox[0], bbox[3]], [bbox[2], bbox[3]], [bbox[2], bbox[1]], [bbox[0], bbox[1]]]]
-  };
-  return poly;
-}
-function tile2lon(x, z) {
-  return x / Math.pow(2, z) * 360 - 180;
-}
-function tile2lat(y, z) {
-  var n = Math.PI - 2 * Math.PI * y / Math.pow(2, z);
-  return r2d * Math.atan(0.5 * (Math.exp(n) - Math.exp(-n)));
-}
-function pointToTile(lon, lat, z) {
-  var tile = pointToTileFraction(lon, lat, z);
-  tile[0] = Math.floor(tile[0]);
-  tile[1] = Math.floor(tile[1]);
-  return tile;
-}
-function getChildren(tile) {
-  return [[tile[0] * 2, tile[1] * 2, tile[2] + 1], [tile[0] * 2 + 1, tile[1] * 2, tile[2] + 1], [tile[0] * 2 + 1, tile[1] * 2 + 1, tile[2] + 1], [tile[0] * 2, tile[1] * 2 + 1, tile[2] + 1]];
-}
-function getParent(tile) {
-  // top left
-  if (tile[0] % 2 === 0 && tile[1] % 2 === 0) {
-    return [tile[0] / 2, tile[1] / 2, tile[2] - 1];
-  }
-  // bottom left
-  else if (tile[0] % 2 === 0 && !tile[1] % 2 === 0) {
-    return [tile[0] / 2, (tile[1] - 1) / 2, tile[2] - 1];
-  }
-  // top right
-  else if (!tile[0] % 2 === 0 && tile[1] % 2 === 0) {
-    return [(tile[0] - 1) / 2, tile[1] / 2, tile[2] - 1];
-  }
-  // bottom right
-  else {
-    return [(tile[0] - 1) / 2, (tile[1] - 1) / 2, tile[2] - 1];
-  }
-}
-function getSiblings(tile) {
-  return getChildren(getParent(tile));
-}
-function hasSiblings(tile, tiles) {
-  var siblings = getSiblings(tile);
-  for (var i = 0; i < siblings.length; i++) {
-    if (!hasTile(tiles, siblings[i])) return false;
-  }
-  return true;
-}
-function hasTile(tiles, tile) {
-  for (var i = 0; i < tiles.length; i++) {
-    if (tilesEqual(tiles[i], tile)) return true;
-  }
-  return false;
-}
-function tilesEqual(tile1, tile2) {
-  return tile1[0] === tile2[0] && tile1[1] === tile2[1] && tile1[2] === tile2[2];
-}
-function tileToQuadkey(tile) {
-  var index = '';
-  for (var z = tile[2]; z > 0; z--) {
-    var b = 0;
-    var mask = 1 << z - 1;
-    if ((tile[0] & mask) !== 0) b++;
-    if ((tile[1] & mask) !== 0) b += 2;
-    index += b.toString();
-  }
-  return index;
-}
-function quadkeyToTile(quadkey) {
-  var x = 0;
-  var y = 0;
-  var z = quadkey.length;
-  for (var i = z; i > 0; i--) {
-    var mask = 1 << i - 1;
-    switch (quadkey[z - i]) {
-      case '0':
-        break;
-      case '1':
-        x |= mask;
-        break;
-      case '2':
-        y |= mask;
-        break;
-      case '3':
-        x |= mask;
-        y |= mask;
-        break;
-    }
-  }
-  return [x, y, z];
-}
-function bboxToTile(bboxCoords) {
-  var min = pointToTile(bboxCoords[0], bboxCoords[1], 32);
-  var max = pointToTile(bboxCoords[2], bboxCoords[3], 32);
-  var bbox = [min[0], min[1], max[0], max[1]];
-  var z = getBboxZoom(bbox);
-  if (z === 0) return [0, 0, 0];
-  var x = bbox[0] >>> 32 - z;
-  var y = bbox[1] >>> 32 - z;
-  return [x, y, z];
-}
-function getBboxZoom(bbox) {
-  var MAX_ZOOM = 28;
-  for (var z = 0; z < MAX_ZOOM; z++) {
-    var mask = 1 << 32 - (z + 1);
-    if ((bbox[0] & mask) != (bbox[2] & mask) || (bbox[1] & mask) != (bbox[3] & mask)) {
-      return z;
-    }
-  }
-  return MAX_ZOOM;
-}
-function pointToTileFraction(lon, lat, z) {
-  var sin = Math.sin(lat * d2r),
-    z2 = Math.pow(2, z),
-    x = z2 * (lon / 360 + 0.5),
-    y = z2 * (0.5 - 0.25 * Math.log((1 + sin) / (1 - sin)) / Math.PI);
-  return [x, y, z];
-}
-var tilebelt = {
-  tileToGeoJSON: tileToGeoJSON,
-  tileToBBOX: tileToBBOX,
-  getChildren: getChildren,
-  getParent: getParent,
-  getSiblings: getSiblings,
-  hasTile: hasTile,
-  hasSiblings: hasSiblings,
-  tilesEqual: tilesEqual,
-  tileToQuadkey: tileToQuadkey,
-  quadkeyToTile: quadkeyToTile,
-  pointToTile: pointToTile,
-  bboxToTile: bboxToTile,
-  pointToTileFraction: pointToTileFraction
-};
-
-/**
- * Given a geometry, create cells and return them in their raw form,
- * as an array of cell identifiers.
- *
- * @alias tiles
- * @param {Object} geom GeoJSON geometry
- * @param {Object} limits an object with min_zoom and max_zoom properties
- * specifying the minimum and maximum level to be tiled.
- * @returns {Array<Array<number>>} An array of tiles given as [x, y, z] arrays
- */
-var tiles = getTiles;
-function getTiles(geom, limits) {
-  var i,
-    tile,
-    coords = geom.coordinates,
-    maxZoom = limits.max_zoom,
-    tileHash = {},
-    tiles = [];
-  if (geom.type === 'Point') {
-    return [tilebelt.pointToTile(coords[0], coords[1], maxZoom)];
-  } else if (geom.type === 'MultiPoint') {
-    for (i = 0; i < coords.length; i++) {
-      tile = tilebelt.pointToTile(coords[i][0], coords[i][1], maxZoom);
-      tileHash[toID(tile[0], tile[1], tile[2])] = true;
-    }
-  } else if (geom.type === 'LineString') {
-    lineCover(tileHash, coords, maxZoom);
-  } else if (geom.type === 'MultiLineString') {
-    for (i = 0; i < coords.length; i++) {
-      lineCover(tileHash, coords[i], maxZoom);
-    }
-  } else if (geom.type === 'Polygon') {
-    polygonCover(tileHash, tiles, coords, maxZoom);
-  } else if (geom.type === 'MultiPolygon') {
-    for (i = 0; i < coords.length; i++) {
-      polygonCover(tileHash, tiles, coords[i], maxZoom);
-    }
-  } else {
-    throw new Error('Geometry type not implemented');
-  }
-  if (limits.min_zoom !== maxZoom) {
-    // sync tile hash and tile array so that both contain the same tiles
-    var len = tiles.length;
-    appendHashTiles(tileHash, tiles);
-    for (i = 0; i < len; i++) {
-      var t = tiles[i];
-      tileHash[toID(t[0], t[1], t[2])] = true;
-    }
-    return mergeTiles(tileHash, tiles, limits);
-  }
-  appendHashTiles(tileHash, tiles);
-  return tiles;
-}
-function mergeTiles(tileHash, tiles, limits) {
-  var mergedTiles = [];
-  for (var z = limits.max_zoom; z > limits.min_zoom; z--) {
-    var parentTileHash = {};
-    var parentTiles = [];
-    for (var i = 0; i < tiles.length; i++) {
-      var t = tiles[i];
-      if (t[0] % 2 === 0 && t[1] % 2 === 0) {
-        var id2 = toID(t[0] + 1, t[1], z),
-          id3 = toID(t[0], t[1] + 1, z),
-          id4 = toID(t[0] + 1, t[1] + 1, z);
-        if (tileHash[id2] && tileHash[id3] && tileHash[id4]) {
-          tileHash[toID(t[0], t[1], t[2])] = false;
-          tileHash[id2] = false;
-          tileHash[id3] = false;
-          tileHash[id4] = false;
-          var parentTile = [t[0] / 2, t[1] / 2, z - 1];
-          if (z - 1 === limits.min_zoom) mergedTiles.push(parentTile);else {
-            parentTileHash[toID(t[0] / 2, t[1] / 2, z - 1)] = true;
-            parentTiles.push(parentTile);
-          }
-        }
-      }
-    }
-    for (i = 0; i < tiles.length; i++) {
-      t = tiles[i];
-      if (tileHash[toID(t[0], t[1], t[2])]) mergedTiles.push(t);
-    }
-    tileHash = parentTileHash;
-    tiles = parentTiles;
-  }
-  return mergedTiles;
-}
-function polygonCover(tileHash, tileArray, geom, zoom) {
-  var intersections = [];
-  for (var i = 0; i < geom.length; i++) {
-    var ring = [];
-    lineCover(tileHash, geom[i], zoom, ring);
-    for (var j = 0, len = ring.length, k = len - 1; j < len; k = j++) {
-      var m = (j + 1) % len;
-      var y = ring[j][1];
-
-      // add interesction if it's not local extremum or duplicate
-      if ((y > ring[k][1] || y > ring[m][1]) && (
-      // not local minimum
-      y < ring[k][1] || y < ring[m][1]) &&
-      // not local maximum
-      y !== ring[m][1]) intersections.push(ring[j]);
-    }
-  }
-  intersections.sort(compareTiles); // sort by y, then x
-
-  for (i = 0; i < intersections.length; i += 2) {
-    // fill tiles between pairs of intersections
-    y = intersections[i][1];
-    for (var x = intersections[i][0] + 1; x < intersections[i + 1][0]; x++) {
-      var id = toID(x, y, zoom);
-      if (!tileHash[id]) {
-        tileArray.push([x, y, zoom]);
-      }
-    }
-  }
-}
-function compareTiles(a, b) {
-  return a[1] - b[1] || a[0] - b[0];
-}
-function lineCover(tileHash, coords, maxZoom, ring) {
-  var prevX, prevY;
-  for (var i = 0; i < coords.length - 1; i++) {
-    var start = tilebelt.pointToTileFraction(coords[i][0], coords[i][1], maxZoom),
-      stop = tilebelt.pointToTileFraction(coords[i + 1][0], coords[i + 1][1], maxZoom),
-      x0 = start[0],
-      y0 = start[1],
-      x1 = stop[0],
-      y1 = stop[1],
-      dx = x1 - x0,
-      dy = y1 - y0;
-    if (dy === 0 && dx === 0) continue;
-    var sx = dx > 0 ? 1 : -1,
-      sy = dy > 0 ? 1 : -1,
-      x = Math.floor(x0),
-      y = Math.floor(y0),
-      tMaxX = dx === 0 ? Infinity : Math.abs(((dx > 0 ? 1 : 0) + x - x0) / dx),
-      tMaxY = dy === 0 ? Infinity : Math.abs(((dy > 0 ? 1 : 0) + y - y0) / dy),
-      tdx = Math.abs(sx / dx),
-      tdy = Math.abs(sy / dy);
-    if (x !== prevX || y !== prevY) {
-      tileHash[toID(x, y, maxZoom)] = true;
-      if (ring && y !== prevY) ring.push([x, y]);
-      prevX = x;
-      prevY = y;
-    }
-    while (tMaxX < 1 || tMaxY < 1) {
-      if (tMaxX < tMaxY) {
-        tMaxX += tdx;
-        x += sx;
-      } else {
-        tMaxY += tdy;
-        y += sy;
-      }
-      tileHash[toID(x, y, maxZoom)] = true;
-      if (ring && y !== prevY) ring.push([x, y]);
-      prevX = x;
-      prevY = y;
-    }
-  }
-  if (ring && y === ring[0][1]) ring.pop();
-}
-function appendHashTiles(hash, tiles) {
-  var keys = Object.keys(hash);
-  for (var i = 0; i < keys.length; i++) {
-    tiles.push(fromID(+keys[i]));
-  }
-}
-function toID(x, y, z) {
-  var dim = 2 * (1 << z);
-  return (dim * y + x) * 32 + z;
-}
-function fromID(id) {
-  var z = id % 32,
-    dim = 2 * (1 << z),
-    xy = (id - z) / 32,
-    x = xy % dim,
-    y = (xy - x) / dim % dim;
-  return [x, y, z];
-}
-
-const B = [0x5555555555555555n, 0x3333333333333333n, 0x0f0f0f0f0f0f0f0fn, 0x00ff00ff00ff00ffn, 0x0000ffff0000ffffn, 0x00000000ffffffffn];
-const S = [0n, 1n, 2n, 4n, 8n, 16n];
-function tileToCell(tile) {
-  if (tile.z < 0 || tile.z > 26) {
-    throw new Error('Wrong zoom');
-  }
-  const z = BigInt(tile.z);
-  let x = BigInt(tile.x) << 32n - z;
-  let y = BigInt(tile.y) << 32n - z;
-  for (let i = 0; i < 5; i++) {
-    const s = S[5 - i];
-    const b = B[4 - i];
-    x = (x | x << s) & b;
-    y = (y | y << s) & b;
-  }
-  const quadbin = 0x4000000000000000n | 1n << 59n |
-  // | (mode << 59) | (mode_dep << 57)
-  z << 52n | (x | y << 1n) >> 12n | 0xfffffffffffffn >> z * 2n;
-  return quadbin;
-}
-function getResolution$1(quadbin) {
-  return quadbin >> 52n & 0x1fn;
-}
-function geometryToCells(geometry, resolution) {
-  const zoom = Number(resolution);
-  return tiles(geometry, {
-    min_zoom: zoom,
-    max_zoom: zoom
-  }).map(([x, y, z]) => tileToCell({
-    x,
-    y,
-    z
-  }));
-}
-
 function tileFeaturesSpatialIndex({
   tiles,
   spatialFilter,
@@ -2544,6 +2154,81 @@ function getSpatialIndex(spatialDataType) {
   }
 }
 
+const _excluded$1 = ["tiles"];
+function tileFeaturesRaster(_ref) {
+  let {
+      tiles
+    } = _ref,
+    options = _objectWithoutPropertiesLoose(_ref, _excluded$1);
+  // Cache band metadata for faster lookup while iterating over pixels.
+  const bandMetadataByName = {};
+  for (const band of options.rasterMetadata.bands) {
+    bandMetadataByName[band.name] = band;
+  }
+  // Omit empty and invisible tiles for simpler processing and types.
+  tiles = tiles.filter(isRasterTileVisible);
+  if (tiles.length === 0) return [];
+  // Raster tiles, and all pixels, are quadbin cells. Resolution of a pixel is
+  // the resolution of the tile, plus the number of subdivisions. Block size
+  // must be square, N x N, where N is a power of two.
+  const tileResolution = getResolution$1(tiles[0].index.q);
+  const tileBlockSize = tiles[0].data.blockSize;
+  const cellResolution = tileResolution + BigInt(Math.log2(tileBlockSize));
+  // Compute covering cells for the spatial filter, at same resolution as the
+  // raster pixels, to be used as a mask.
+  const spatialFilterCells = new Set(geometryToCells(options.spatialFilter, cellResolution));
+  const data = new Map();
+  for (const tile of tiles) {
+    const parent = tile.index.q;
+    const children = cellToChildrenSorted(parent, cellResolution);
+    // For each pixel/cell within the spatial filter, create a FeatureData.
+    // Order is row-major, starting from NW and ending at SE.
+    for (let i = 0; i < children.length; i++) {
+      if (!spatialFilterCells.has(children[i])) continue;
+      const cellData = {};
+      let cellDataExists = false;
+      for (const band in tile.data.cells.numericProps) {
+        const value = tile.data.cells.numericProps[band].value[i];
+        // TODO(cleanup): nodata should be a number, not a string.
+        if (Number(bandMetadataByName[band].nodata) !== value) {
+          cellData[band] = tile.data.cells.numericProps[band].value[i];
+          cellDataExists = true;
+        }
+      }
+      if (cellDataExists) {
+        data.set(children[i], cellData);
+      }
+    }
+  }
+  return Array.from(data.values());
+}
+/**
+ * Detects whether a given {@link Tile} is a {@link RasterTile}.
+ * @privateRemarks Method of detection is arbitrary, and may be changed.
+ */
+function isRasterTile(tile) {
+  return tile.data ? tile.data.hasOwnProperty('cells') : false;
+}
+function isRasterTileVisible(tile) {
+  var _tile$data;
+  return !!(tile.isVisible && (_tile$data = tile.data) != null && (_tile$data = _tile$data.cells) != null && _tile$data.numericProps);
+}
+/**
+ * For the raster format, children are sorted in row-major order, starting from
+ * NW and ending at SE. Order returned by quadbin's cellToChildren() is not
+ * defined (and not related to the raster format), so sort explicitly here.
+ */
+function cellToChildrenSorted(parent, resolution) {
+  return cellToChildren(parent, resolution).sort((cellA, cellB) => {
+    const tileA = cellToTile(cellA);
+    const tileB = cellToTile(cellB);
+    if (tileA.y !== tileB.y) {
+      return tileA.y > tileB.y ? 1 : -1;
+    }
+    return tileA.x > tileB.x ? 1 : -1;
+  });
+}
+
 /** @internalRemarks Source: @carto/react-core */
 function tileFeatures({
   tiles,
@@ -2552,6 +2237,7 @@ function tileFeatures({
   tileFormat,
   spatialDataColumn = DEFAULT_GEO_COLUMN,
   spatialDataType,
+  rasterMetadata,
   options = {}
 }) {
   // TODO(cleanup): Is an empty response the expected result when spatialFilter
@@ -2559,20 +2245,30 @@ function tileFeatures({
   if (!spatialFilter) {
     return [];
   }
-  if (spatialDataType !== 'geo') {
-    return tileFeaturesSpatialIndex({
+  if (spatialDataType === 'geo') {
+    return tileFeaturesGeometries({
+      tiles,
+      tileFormat,
+      spatialFilter,
+      uniqueIdProperty,
+      options
+    });
+  }
+  if (tiles.some(isRasterTile)) {
+    assert$1(rasterMetadata, 'Missing raster metadata');
+    return tileFeaturesRaster({
       tiles: tiles,
       spatialFilter,
       spatialDataColumn,
-      spatialDataType
+      spatialDataType,
+      rasterMetadata
     });
   }
-  return tileFeaturesGeometries({
-    tiles,
-    tileFormat,
+  return tileFeaturesSpatialIndex({
+    tiles: tiles,
     spatialFilter,
-    uniqueIdProperty,
-    options
+    spatialDataColumn,
+    spatialDataType
   });
 }
 
@@ -3024,15 +2720,12 @@ class WidgetTilesetSource extends WidgetSource {
     uniqueIdProperty,
     options
   }) {
-    this._features = tileFeatures({
+    this._features = tileFeatures(_extends({
       tiles: this._tiles,
       options,
       spatialFilter,
-      uniqueIdProperty,
-      tileFormat: this.props.tileFormat,
-      spatialDataColumn: this.props.spatialDataColumn,
-      spatialDataType: this.props.spatialDataType
-    });
+      uniqueIdProperty
+    }, this.props));
   }
   /** Loads features as GeoJSON (used for testing). */
   loadGeoJSON({
@@ -3253,6 +2946,39 @@ function normalizeColumns(columns) {
   return Array.isArray(columns) ? columns : typeof columns === 'string' ? [columns] : [];
 }
 
+class WidgetRasterSource extends WidgetTilesetSource {}
+
+/**
+ * Source for Widget API requests on a data source defined as a table.
+ *
+ * Generally not intended to be constructed directly. Instead, call
+ * {@link vectorTableSource}, {@link h3TableSource}, or {@link quadbinTableSource},
+ * which can be shared with map layers. Sources contain a `widgetSource` property,
+ * for use by widget implementations.
+ *
+ * Example:
+ *
+ * ```javascript
+ * import { vectorTableSource } from '@carto/api-client';
+ *
+ * const data = vectorTableSource({
+ *   accessToken: '••••',
+ *   connectionName: 'carto_dw',
+ *   tableName: 'carto-demo-data.demo_tables.retail_stores'
+ * });
+ *
+ * const { widgetSource } = await data;
+ * ```
+ */
+class WidgetTableSource extends WidgetRemoteSource {
+  getModelSource(owner) {
+    return _extends({}, super._getModelSource(owner), {
+      type: 'table',
+      data: this.props.tableName
+    });
+  }
+}
+
 const h3QuerySource = async function h3QuerySource(options) {
   const {
     aggregationExp,
@@ -3339,9 +3065,6 @@ const h3TilesetSource = async function h3TilesetSource(options) {
   }));
 };
 
-// deck.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
 const rasterSource = async function rasterSource(options) {
   const {
     tableName,
@@ -3353,7 +3076,14 @@ const rasterSource = async function rasterSource(options) {
   if (filters) {
     urlParameters.filters = filters;
   }
-  return baseSource('raster', options, urlParameters);
+  return baseSource('raster', options, urlParameters).then(result => _extends({}, result, {
+    widgetSource: new WidgetRasterSource(_extends({}, options, {
+      tileFormat: getTileFormat(result),
+      spatialDataColumn: 'quadbin',
+      spatialDataType: 'quadbin',
+      rasterMetadata: result.raster_metadata
+    }))
+  }));
 };
 
 const quadbinQuerySource = async function quadbinQuerySource(options) {
@@ -3570,5 +3300,5 @@ const query = async function query(options) {
   });
 };
 
-export { ApiVersion, CartoAPIError, DEFAULT_API_BASE_URL, FEATURE_GEOM_PROPERTY, FilterType, Provider, SOURCE_DEFAULTS, SpatialIndex, TileFormat, WidgetQuerySource, WidgetRemoteSource, WidgetSource, WidgetTableSource, WidgetTilesetSource, addFilter, aggregate, aggregationFunctions, applyFilters, applySorting, boundaryQuerySource, boundaryTableSource, buildBinaryFeatureFilter, buildFeatureFilter, buildPublicMapUrl, buildStatsUrl, clearFilters, createPolygonSpatialFilter, createViewportSpatialFilter, filterFunctions, geojsonFeatures, getClient, 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 };
+export { ApiVersion, CartoAPIError, DEFAULT_API_BASE_URL, FEATURE_GEOM_PROPERTY, FilterType, Provider, SOURCE_DEFAULTS, SpatialIndex, TileFormat, WidgetQuerySource, WidgetRasterSource, WidgetRemoteSource, WidgetSource, WidgetTableSource, WidgetTilesetSource, _getHexagonResolution, addFilter, aggregate, aggregationFunctions, applyFilters, applySorting, boundaryQuerySource, boundaryTableSource, buildBinaryFeatureFilter, buildFeatureFilter, buildPublicMapUrl, buildStatsUrl, clearFilters, createPolygonSpatialFilter, createViewportSpatialFilter, filterFunctions, geojsonFeatures, getClient, 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 };
 //# sourceMappingURL=api-client.modern.js.map