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

package/build/worker.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) {
@@ -404,6 +86,10 @@ var FilterType = /* @__PURE__ */ ((FilterType2) => {
   return FilterType2;
 })(FilterType || {});
 var DEFAULT_API_BASE_URL = "https://gcp-us-east1.api.carto.com";
+var SpatialIndexColumn = Object.freeze({
+  ["h3" /* H3 */]: ["h3", "hex", "h3id", "hex_id", "h3hex"],
+  ["quadbin" /* QUADBIN */]: ["quadbin"]
+});
 
 // src/utils.ts
 var FILTER_TYPES = new Set(Object.values(FilterType));
@@ -755,14 +441,14 @@ function transformMultiPolygon2(multiPolygon, 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;
     }
@@ -1043,57 +729,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 [];
@@ -1103,7 +751,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;
     }
@@ -1115,13 +763,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);
@@ -1160,33 +808,112 @@ function getSpatialIndex(spatialDataType) {
 
 // src/constants-internal.ts
 var DEFAULT_GEO_COLUMN = "geom";
-var DEFAULT_AGGREGATION_RES_LEVEL_H3 = 4;
-var DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN = 6;
+var DEFAULT_AGGREGATION_EXP_ALIAS = "__aggregationValue";
+var DEFAULT_AGGREGATION_EXP = `1 AS ${DEFAULT_AGGREGATION_EXP_ALIAS}`;
+
+// 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/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)) {
+    assert(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
   });
 }
 
@@ -1535,77 +1262,16 @@ function getClient() {
   return client;
 }
 
-// src/spatial-index.ts
-var DEFAULT_TILE_SIZE = 512;
-var QUADBIN_ZOOM_MAX_OFFSET = 4;
-function getSpatialFiltersResolution(source2, viewState) {
-  const dataResolution = source2.dataResolution ?? Number.MAX_VALUE;
-  const aggregationResLevel = source2.aggregationResLevel ?? (source2.spatialDataType === "h3" ? DEFAULT_AGGREGATION_RES_LEVEL_H3 : DEFAULT_AGGREGATION_RES_LEVEL_QUADBIN);
-  const aggregationResLevelOffset = Math.max(
-    0,
-    Math.floor(aggregationResLevel)
-  );
-  const currentZoomInt = Math.ceil(viewState.zoom);
-  if (source2.spatialDataType === "h3") {
-    const tileSize = DEFAULT_TILE_SIZE;
-    const maxResolutionForZoom = maxH3SpatialFiltersResolutions.find(
-      ([zoom]) => zoom === currentZoomInt
-    )?.[1] ?? Math.max(0, currentZoomInt - 3);
-    const maxSpatialFiltersResolution = maxResolutionForZoom ? Math.min(dataResolution, maxResolutionForZoom) : dataResolution;
-    const hexagonResolution = _getHexagonResolution(viewState, tileSize) + aggregationResLevelOffset;
-    return Math.min(hexagonResolution, maxSpatialFiltersResolution);
-  }
-  if (source2.spatialDataType === "quadbin") {
-    const maxResolutionForZoom = currentZoomInt + QUADBIN_ZOOM_MAX_OFFSET;
-    const maxSpatialFiltersResolution = Math.min(
-      dataResolution,
-      maxResolutionForZoom
-    );
-    const quadsResolution = Math.floor(viewState.zoom) + aggregationResLevelOffset;
-    return Math.min(quadsResolution, maxSpatialFiltersResolution);
-  }
-  return void 0;
-}
-var maxH3SpatialFiltersResolutions = [
-  [20, 14],
-  [19, 13],
-  [18, 12],
-  [17, 11],
-  [16, 10],
-  [15, 9],
-  [14, 8],
-  [13, 7],
-  [12, 7],
-  [11, 7],
-  [10, 6],
-  [9, 6],
-  [8, 5],
-  [7, 4],
-  [6, 4],
-  [5, 3],
-  [4, 2],
-  [3, 1],
-  [2, 1],
-  [1, 0]
-];
-var BIAS = 2;
-function _getHexagonResolution(viewport, tileSize) {
-  const zoomOffset = Math.log2(tileSize / DEFAULT_TILE_SIZE);
-  const hexagonScaleFactor = 2 / 3 * (viewport.zoom - zoomOffset);
-  const latitudeScaleFactor = Math.log(
-    1 / Math.cos(Math.PI * viewport.latitude / 180)
-  );
-  return Math.max(
-    0,
-    Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS)
-  );
-}
-
 // src/widget-sources/widget-source.ts
 var _WidgetSource = class _WidgetSource {
   constructor(props) {
     __publicField(this, "props");
-    this.props = { ..._WidgetSource.defaultProps, ...props };
+    this.props = {
+      ..._WidgetSource.defaultProps,
+      clientId: getClient(),
+      // Refresh clientId, default may have changed.
+      ...props
+    };
   }
   /**
    * Destroys the widget source and releases allocated resources.
@@ -1616,17 +1282,6 @@ var _WidgetSource = class _WidgetSource {
    */
   destroy() {
   }
-  _getSpatialFiltersResolution(source2, spatialFilter, referenceViewState) {
-    if (!spatialFilter || source2.spatialDataType === "geo") {
-      return;
-    }
-    if (!referenceViewState) {
-      throw new Error(
-        'Missing required option, "spatialIndexReferenceViewState".'
-      );
-    }
-    return getSpatialFiltersResolution(source2, referenceViewState);
-  }
 };
 __publicField(_WidgetSource, "defaultProps", {
   apiVersion: "v3" /* V3 */,
@@ -1652,8 +1307,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. */
@@ -1667,12 +1322,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;
   }
@@ -1703,12 +1356,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,
@@ -1717,6 +1364,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)
@@ -1881,7 +1534,6 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
     filterOwner,
     spatialFilter
   }) {
-    assertColumn(this._features, column);
     const filteredFeatures = this._getFilteredFeatures(
       spatialFilter,
       filters,
@@ -1890,6 +1542,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)