@carto/api-client 0.5.0-alpha.13 → 0.5.0-alpha.14

package/build/api-client.js

@@ -26,324 +26,6 @@ var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__
 ));
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
-// node_modules/tilebelt/index.js
-var require_tilebelt = __commonJS({
-  "node_modules/tilebelt/index.js"(exports, module) {
-    "use strict";
-    var d2r = Math.PI / 180;
-    var 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) {
-      if (tile[0] % 2 === 0 && tile[1] % 2 === 0) {
-        return [tile[0] / 2, tile[1] / 2, tile[2] - 1];
-      } else if (tile[0] % 2 === 0 && !tile[1] % 2 === 0) {
-        return [tile[0] / 2, (tile[1] - 1) / 2, tile[2] - 1];
-      } else if (!tile[0] % 2 === 0 && tile[1] % 2 === 0) {
-        return [(tile[0] - 1) / 2, tile[1] / 2, tile[2] - 1];
-      } else {
-        return [(tile[0] - 1) / 2, (tile[1] - 1) / 2, tile[2] - 1];
-      }
-    }
-    function getSiblings(tile) {
-      return getChildren(getParent(tile));
-    }
-    function hasSiblings(tile, tiles2) {
-      var siblings = getSiblings(tile);
-      for (var i = 0; i < siblings.length; i++) {
-        if (!hasTile(tiles2, siblings[i])) return false;
-      }
-      return true;
-    }
-    function hasTile(tiles2, tile) {
-      for (var i = 0; i < tiles2.length; i++) {
-        if (tilesEqual(tiles2[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 min2 = pointToTile(bboxCoords[0], bboxCoords[1], 32);
-      var max2 = pointToTile(bboxCoords[2], bboxCoords[3], 32);
-      var bbox = [min2[0], min2[1], max2[0], max2[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 sin2 = Math.sin(lat * d2r), z2 = Math.pow(2, z), x = z2 * (lon / 360 + 0.5), y = z2 * (0.5 - 0.25 * Math.log((1 + sin2) / (1 - sin2)) / Math.PI);
-      return [x, y, z];
-    }
-    module.exports = {
-      tileToGeoJSON,
-      tileToBBOX,
-      getChildren,
-      getParent,
-      getSiblings,
-      hasTile,
-      hasSiblings,
-      tilesEqual,
-      tileToQuadkey,
-      quadkeyToTile,
-      pointToTile,
-      bboxToTile,
-      pointToTileFraction
-    };
-  }
-});
-
-// node_modules/@mapbox/tile-cover/index.js
-var require_tile_cover = __commonJS({
-  "node_modules/@mapbox/tile-cover/index.js"(exports) {
-    "use strict";
-    var tilebelt = require_tilebelt();
-    exports.geojson = function(geom, limits) {
-      return {
-        type: "FeatureCollection",
-        features: getTiles(geom, limits).map(tileToFeature)
-      };
-    };
-    function tileToFeature(t) {
-      return {
-        type: "Feature",
-        geometry: tilebelt.tileToGeoJSON(t),
-        properties: {}
-      };
-    }
-    exports.tiles = getTiles;
-    exports.indexes = function(geom, limits) {
-      return getTiles(geom, limits).map(tilebelt.tileToQuadkey);
-    };
-    function getTiles(geom, limits) {
-      var i, tile, coords = geom.coordinates, maxZoom = limits.max_zoom, tileHash = {}, tiles2 = [];
-      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, tiles2, coords, maxZoom);
-      } else if (geom.type === "MultiPolygon") {
-        for (i = 0; i < coords.length; i++) {
-          polygonCover(tileHash, tiles2, coords[i], maxZoom);
-        }
-      } else {
-        throw new Error("Geometry type not implemented");
-      }
-      if (limits.min_zoom !== maxZoom) {
-        var len = tiles2.length;
-        appendHashTiles(tileHash, tiles2);
-        for (i = 0; i < len; i++) {
-          var t = tiles2[i];
-          tileHash[toID(t[0], t[1], t[2])] = true;
-        }
-        return mergeTiles(tileHash, tiles2, limits);
-      }
-      appendHashTiles(tileHash, tiles2);
-      return tiles2;
-    }
-    function mergeTiles(tileHash, tiles2, limits) {
-      var mergedTiles = [];
-      for (var z = limits.max_zoom; z > limits.min_zoom; z--) {
-        var parentTileHash = {};
-        var parentTiles = [];
-        for (var i = 0; i < tiles2.length; i++) {
-          var t = tiles2[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 < tiles2.length; i++) {
-          t = tiles2[i];
-          if (tileHash[toID(t[0], t[1], t[2])]) mergedTiles.push(t);
-        }
-        tileHash = parentTileHash;
-        tiles2 = 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];
-          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);
-      for (i = 0; i < intersections.length; i += 2) {
-        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, tiles2) {
-      var keys = Object.keys(hash);
-      for (var i = 0; i < keys.length; i++) {
-        tiles2.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];
-    }
-  }
-});
-
 // node_modules/thenby/thenBy.module.js
 var require_thenBy_module = __commonJS({
   "node_modules/thenby/thenBy.module.js"(exports, module) {
@@ -802,14 +484,14 @@ function transformMultiPolygon2(multiPolygon2, bbox) {
 import { featureCollection } from "@turf/helpers";
 var FEATURE_GEOM_PROPERTY = "__geomValue";
 function tileFeaturesGeometries({
-  tiles: tiles2,
+  tiles,
   tileFormat,
   spatialFilter,
   uniqueIdProperty,
   options
 }) {
   const map = /* @__PURE__ */ new Map();
-  for (const tile of tiles2) {
+  for (const tile of tiles) {
     if (tile.isVisible === false || !tile.data) {
       continue;
     }
@@ -1090,57 +772,19 @@ function createIndicesForPoints(data) {
   data.pointIndices = pointIndices;
 }
 
-// node_modules/quadbin/dist/esm/index.js
-var import_tile_cover = __toESM(require_tile_cover(), 1);
-var B = [
-  0x5555555555555555n,
-  0x3333333333333333n,
-  0x0f0f0f0f0f0f0f0fn,
-  0x00ff00ff00ff00ffn,
-  0x0000ffff0000ffffn,
-  0x00000000ffffffffn
-];
-var 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(quadbin) {
-  return quadbin >> 52n & 0x1fn;
-}
-function geometryToCells(geometry, resolution) {
-  const zoom = Number(resolution);
-  return (0, import_tile_cover.tiles)(geometry, {
-    min_zoom: zoom,
-    max_zoom: zoom
-  }).map(([x, y, z]) => tileToCell({ x, y, z }));
-}
-
 // src/filters/tileFeaturesSpatialIndex.ts
+import { getResolution as quadbinGetResolution, geometryToCells } from "quadbin";
 import bboxClip from "@turf/bbox-clip";
 import { getResolution as h3GetResolution, polygonToCells } from "h3-js";
 function tileFeaturesSpatialIndex({
-  tiles: tiles2,
+  tiles,
   spatialFilter,
   spatialDataColumn,
   spatialDataType
 }) {
   const map = /* @__PURE__ */ new Map();
   const spatialIndex = getSpatialIndex(spatialDataType);
-  const resolution = getResolution2(tiles2, spatialIndex);
+  const resolution = getResolution(tiles, spatialIndex);
   const spatialIndexIDName = spatialDataColumn ? spatialDataColumn : spatialIndex;
   if (!resolution) {
     return [];
@@ -1150,7 +794,7 @@ function tileFeaturesSpatialIndex({
     return [];
   }
   const cellsSet = new Set(cells);
-  for (const tile of tiles2) {
+  for (const tile of tiles) {
     if (tile.isVisible === false || !tile.data) {
       continue;
     }
@@ -1162,13 +806,13 @@ function tileFeaturesSpatialIndex({
   }
   return Array.from(map.values());
 }
-function getResolution2(tiles2, spatialIndex) {
-  const data = tiles2.find((tile) => tile.data?.length)?.data;
+function getResolution(tiles, spatialIndex) {
+  const data = tiles.find((tile) => tile.data?.length)?.data;
   if (!data) {
     return;
   }
   if (spatialIndex === "quadbin" /* QUADBIN */) {
-    return Number(getResolution(data[0].id));
+    return Number(quadbinGetResolution(data[0].id));
   }
   if (spatialIndex === "h3" /* H3 */) {
     return h3GetResolution(data[0].id);
@@ -1213,30 +857,167 @@ var DEFAULT_TILE_RESOLUTION = 0.5;
 var DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
 var DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
 
+// src/filters/tileFeaturesRaster.ts
+import {
+  cellToChildren as _cellToChildren,
+  cellToTile,
+  geometryToCells as geometryToCells2,
+  getResolution as getResolution2
+} from "quadbin";
+function tileFeaturesRaster({
+  tiles,
+  ...options
+}) {
+  const metadataByBand = {};
+  for (const band of options.rasterMetadata.bands) {
+    metadataByBand[band.name] = { ...band, nodata: Number(band.nodata) };
+  }
+  tiles = tiles.filter(isRasterTileVisible);
+  if (tiles.length === 0) return [];
+  const tileResolution = getResolution2(tiles[0].index.q);
+  const tileBlockSize = tiles[0].data.blockSize;
+  const cellResolution = tileResolution + BigInt(Math.log2(tileBlockSize));
+  const spatialFilterCells = new Set(
+    geometryToCells2(options.spatialFilter, cellResolution)
+  );
+  const data = /* @__PURE__ */ new Map();
+  for (const tile of tiles) {
+    const parent = tile.index.q;
+    const children = cellToChildrenSorted(parent, cellResolution);
+    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];
+        const bandMetadata = metadataByBand[band];
+        if (isValidBandValue(value, bandMetadata.nodata)) {
+          cellData[band] = tile.data.cells.numericProps[band].value[i];
+          cellDataExists = true;
+        }
+      }
+      if (cellDataExists) {
+        data.set(children[i], cellData);
+      }
+    }
+  }
+  return Array.from(data.values());
+}
+function isRasterTile(tile) {
+  return !!tile.data?.cells;
+}
+function isRasterTileVisible(tile) {
+  return !!(tile.isVisible && tile.data?.cells?.numericProps);
+}
+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;
+    }
+  );
+}
+function isValidBandValue(value, nodata) {
+  return Number.isNaN(value) ? false : nodata !== value;
+}
+
+// src/utils.ts
+var FILTER_TYPES = new Set(Object.values(FilterType));
+var isFilterType = (type) => FILTER_TYPES.has(type);
+function getApplicableFilters(owner, filters) {
+  if (!filters) return {};
+  const applicableFilters = {};
+  for (const column in filters) {
+    for (const type in filters[column]) {
+      if (!isFilterType(type)) continue;
+      const filter = filters[column][type];
+      const isApplicable = !owner || !filter?.owner || filter?.owner !== owner;
+      if (filter && isApplicable) {
+        applicableFilters[column] || (applicableFilters[column] = {});
+        applicableFilters[column][type] = filter;
+      }
+    }
+  }
+  return applicableFilters;
+}
+function normalizeObjectKeys(el) {
+  if (Array.isArray(el)) {
+    return el.map((value) => normalizeObjectKeys(value));
+  } else if (typeof el !== "object") {
+    return el;
+  }
+  return Object.entries(el).reduce(
+    (acc, [key, value]) => {
+      acc[key.toLowerCase()] = typeof value === "object" && value ? normalizeObjectKeys(value) : value;
+      return acc;
+    },
+    {}
+  );
+}
+function assert2(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+var _InvalidColumnError = class _InvalidColumnError extends Error {
+  constructor(message) {
+    super(`${_InvalidColumnError.NAME}: ${message}`);
+    this.name = _InvalidColumnError.NAME;
+  }
+  static is(error) {
+    return error instanceof _InvalidColumnError || error.message?.includes(_InvalidColumnError.NAME);
+  }
+};
+__publicField(_InvalidColumnError, "NAME", "InvalidColumnError");
+var InvalidColumnError = _InvalidColumnError;
+function isEmptyObject(object) {
+  for (const _ in object) {
+    return false;
+  }
+  return true;
+}
+var isObject = (x) => x !== null && typeof x === "object";
+var isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
+
 // src/filters/tileFeatures.ts
 function tileFeatures({
-  tiles: tiles2,
+  tiles,
   spatialFilter,
   uniqueIdProperty,
   tileFormat,
   spatialDataColumn = DEFAULT_GEO_COLUMN,
   spatialDataType,
+  rasterMetadata,
   options = {}
 }) {
-  if (spatialDataType !== "geo") {
-    return tileFeaturesSpatialIndex({
-      tiles: tiles2,
+  if (spatialDataType === "geo") {
+    return tileFeaturesGeometries({
+      tiles,
+      tileFormat,
+      spatialFilter,
+      uniqueIdProperty,
+      options
+    });
+  }
+  if (tiles.some(isRasterTile)) {
+    assert2(rasterMetadata, "Missing raster metadata");
+    return tileFeaturesRaster({
+      tiles,
       spatialFilter,
       spatialDataColumn,
-      spatialDataType
+      spatialDataType,
+      rasterMetadata
     });
   }
-  return tileFeaturesGeometries({
-    tiles: tiles2,
-    tileFormat,
+  return tileFeaturesSpatialIndex({
+    tiles,
     spatialFilter,
-    uniqueIdProperty,
-    options
+    spatialDataColumn,
+    spatialDataType
   });
 }
 
@@ -1321,64 +1102,6 @@ function getFilterValue(filtersWithoutTimeType, timeColumn, timeFilter, filterSi
   };
 }
 
-// src/utils.ts
-var FILTER_TYPES = new Set(Object.values(FilterType));
-var isFilterType = (type) => FILTER_TYPES.has(type);
-function getApplicableFilters(owner, filters) {
-  if (!filters) return {};
-  const applicableFilters = {};
-  for (const column in filters) {
-    for (const type in filters[column]) {
-      if (!isFilterType(type)) continue;
-      const filter = filters[column][type];
-      const isApplicable = !owner || !filter?.owner || filter?.owner !== owner;
-      if (filter && isApplicable) {
-        applicableFilters[column] || (applicableFilters[column] = {});
-        applicableFilters[column][type] = filter;
-      }
-    }
-  }
-  return applicableFilters;
-}
-function normalizeObjectKeys(el) {
-  if (Array.isArray(el)) {
-    return el.map((value) => normalizeObjectKeys(value));
-  } else if (typeof el !== "object") {
-    return el;
-  }
-  return Object.entries(el).reduce(
-    (acc, [key, value]) => {
-      acc[key.toLowerCase()] = typeof value === "object" && value ? normalizeObjectKeys(value) : value;
-      return acc;
-    },
-    {}
-  );
-}
-function assert2(condition, message) {
-  if (!condition) {
-    throw new Error(message);
-  }
-}
-var _InvalidColumnError = class _InvalidColumnError extends Error {
-  constructor(message) {
-    super(`${_InvalidColumnError.NAME}: ${message}`);
-    this.name = _InvalidColumnError.NAME;
-  }
-  static is(error) {
-    return error instanceof _InvalidColumnError || error.message?.includes(_InvalidColumnError.NAME);
-  }
-};
-__publicField(_InvalidColumnError, "NAME", "InvalidColumnError");
-var InvalidColumnError = _InvalidColumnError;
-function isEmptyObject(object) {
-  for (const _ in object) {
-    return false;
-  }
-  return true;
-}
-var isObject = (x) => x !== null && typeof x === "object";
-var isPureObject = (x) => isObject(x) && x.constructor === {}.constructor;
-
 // src/filters.ts
 function addFilter(filters, { column, type, values, owner }) {
   if (!filters[column]) {
@@ -2446,17 +2169,6 @@ var WidgetQuerySource = class extends WidgetRemoteSource {
   }
 };
 
-// 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/operations/aggregation.ts
 var aggregationFunctions = {
   count: (values) => values.length,
@@ -2811,8 +2523,8 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
    * After tiles are loaded, {@link extractTileFeatures} must be called
    * before computing statistics on the tiles.
    */
-  loadTiles(tiles2) {
-    this._tiles = tiles2;
+  loadTiles(tiles) {
+    this._tiles = tiles;
     this._features.length = 0;
   }
   /** Configures options used to extract features from tiles. */
@@ -2826,12 +2538,10 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
       return;
     }
     this._features = tileFeatures({
-      tiles: this._tiles,
-      tileFormat: this.props.tileFormat,
+      ...this.props,
       ...this._tileFeatureExtractOptions,
-      spatialFilter,
-      spatialDataColumn: this.props.spatialDataColumn,
-      spatialDataType: this.props.spatialDataType
+      tiles: this._tiles,
+      spatialFilter
     });
     prevInputs.spatialFilter = spatialFilter;
   }
@@ -2862,12 +2572,6 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
     filterOwner,
     spatialFilter
   }) {
-    if (operation === "custom") {
-      throw new Error("Custom aggregation not supported for tilesets");
-    }
-    if (column && column !== "*" || operation !== "count") {
-      assertColumn(this._features, column);
-    }
     const filteredFeatures = this._getFilteredFeatures(
       spatialFilter,
       filters,
@@ -2876,6 +2580,12 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
     if (filteredFeatures.length === 0 && operation !== "count") {
       return { value: null };
     }
+    if (operation === "custom") {
+      throw new Error("Custom aggregation not supported for tilesets");
+    }
+    if (column && column !== "*" || operation !== "count") {
+      assertColumn(this._features, column);
+    }
     const targetOperation = aggregationFunctions[operation];
     return {
       value: targetOperation(filteredFeatures, column, joinOperation)
@@ -3040,7 +2750,6 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
     filterOwner,
     spatialFilter
   }) {
-    assertColumn(this._features, column);
     const filteredFeatures = this._getFilteredFeatures(
       spatialFilter,
       filters,
@@ -3049,6 +2758,7 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
     if (!this._features.length) {
       return null;
     }
+    assertColumn(this._features, column);
     return {
       min: aggregationFunctions.min(filteredFeatures, column),
       max: aggregationFunctions.max(filteredFeatures, column)
@@ -3177,19 +2887,26 @@ var WidgetTilesetSource = class extends WidgetSource {
    * After tiles are loaded, {@link extractTileFeatures} must be called
    * before computing statistics on the tiles.
    */
-  loadTiles(tiles2) {
+  loadTiles(tiles) {
     if (!this._workerEnabled) {
-      return this._localImpl.loadTiles(tiles2);
+      return this._localImpl.loadTiles(tiles);
     }
     const worker = this._getWorker();
-    tiles2 = tiles2.map(({ id, bbox, data }) => ({
-      id,
-      bbox,
-      data
-    }));
+    tiles = tiles.map(
+      ({ id, index, bbox, isVisible, data }) => {
+        const tile = {
+          id,
+          index,
+          isVisible,
+          data,
+          bbox
+        };
+        return tile;
+      }
+    );
     worker.postMessage({
       method: "loadTiles" /* LOAD_TILES */,
-      params: [tiles2]
+      params: [tiles]
     });
   }
   /** Configures options used to extract features from tiles. */
@@ -3271,6 +2988,21 @@ var WidgetTilesetSource = class extends WidgetSource {
   }
 };
 
+// src/widget-sources/widget-raster-source.ts
+var WidgetRasterSource = class extends WidgetTilesetSource {
+};
+
+// 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/sources/h3-query-source.ts
 var h3QuerySource = async function(options) {
   const {
@@ -3375,10 +3107,17 @@ var rasterSource = async function(options) {
   if (filters) {
     urlParameters.filters = filters;
   }
-  return baseSource(
-    "raster",
-    options,
-    urlParameters
+  return baseSource("raster", options, urlParameters).then(
+    (result) => ({
+      ...result,
+      widgetSource: new WidgetRasterSource({
+        ...options,
+        tileFormat: getTileFormat(result),
+        spatialDataColumn: "quadbin",
+        spatialDataType: "quadbin",
+        rasterMetadata: result.raster_metadata
+      })
+    })
   );
 };
 
@@ -3621,6 +3360,7 @@ export {
   SpatialIndex,
   TileFormat,
   WidgetQuerySource,
+  WidgetRasterSource,
   WidgetRemoteSource,
   WidgetSource,
   WidgetTableSource,