@carto/api-client 0.5.6 → 0.5.7-alpha-optional-spatial-filter.0

package/build/api-client.js

@@ -1558,6 +1558,110 @@ function geojsonFeatures({
   return Array.from(map.values());
 }
 
+// node_modules/@math.gl/core/dist/lib/common.js
+var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
+var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
+var DEFAULT_CONFIG = {
+  EPSILON: 1e-12,
+  debug: false,
+  precision: 4,
+  printTypes: false,
+  printDegrees: false,
+  printRowMajor: true,
+  _cartographicRadians: false
+};
+globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
+var config = globalThis.mathgl.config;
+function isArray(value) {
+  return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+}
+function lerp(a, b, t) {
+  if (isArray(a)) {
+    return a.map((ai, i) => lerp(ai, b[i], t));
+  }
+  return t * b + (1 - t) * a;
+}
+
+// node_modules/@math.gl/web-mercator/dist/assert.js
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || "@math.gl/web-mercator: assertion failed.");
+  }
+}
+
+// node_modules/@math.gl/web-mercator/dist/web-mercator-utils.js
+var PI = Math.PI;
+var PI_4 = PI / 4;
+var DEGREES_TO_RADIANS2 = PI / 180;
+var RADIANS_TO_DEGREES2 = 180 / PI;
+var TILE_SIZE = 512;
+function lngLatToWorld(lngLat) {
+  const [lng, lat] = lngLat;
+  assert(Number.isFinite(lng));
+  assert(Number.isFinite(lat) && lat >= -90 && lat <= 90, "invalid latitude");
+  const lambda2 = lng * DEGREES_TO_RADIANS2;
+  const phi2 = lat * DEGREES_TO_RADIANS2;
+  const x = TILE_SIZE * (lambda2 + PI) / (2 * PI);
+  const y = TILE_SIZE * (PI + Math.log(Math.tan(PI_4 + phi2 * 0.5))) / (2 * PI);
+  return [x, y];
+}
+function worldToLngLat(xy) {
+  const [x, y] = xy;
+  const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
+  const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
+  return [lambda2 * RADIANS_TO_DEGREES2, phi2 * RADIANS_TO_DEGREES2];
+}
+
+// node_modules/@math.gl/web-mercator/dist/get-bounds.js
+var DEGREES_TO_RADIANS3 = Math.PI / 180;
+
+// src/utils/transformTileCoordsToWGS84.ts
+var TRANSFORM_FN = {
+  Point: transformPoint,
+  MultiPoint: transformMultiPoint,
+  LineString: transformLineString,
+  MultiLineString: transformMultiLineString,
+  Polygon: transformPolygon,
+  MultiPolygon: transformMultiPolygon
+};
+function transformTileCoordsToWGS84(geometry, bbox2) {
+  const [west, south, east, north] = bbox2;
+  const nw = lngLatToWorld([west, north]);
+  const se = lngLatToWorld([east, south]);
+  const projectedBbox = [nw, se];
+  if (geometry.type === "GeometryCollection") {
+    throw new Error("Unsupported geometry type GeometryCollection");
+  }
+  const transformFn = TRANSFORM_FN[geometry.type];
+  const coordinates = transformFn(geometry.coordinates, projectedBbox);
+  return { ...geometry, coordinates };
+}
+function transformPoint([pointX, pointY], [nw, se]) {
+  const x = lerp(nw[0], se[0], pointX);
+  const y = lerp(nw[1], se[1], pointY);
+  return worldToLngLat([x, y]);
+}
+function getPoints(geometry, bbox2) {
+  return geometry.map((g) => transformPoint(g, bbox2));
+}
+function transformMultiPoint(multiPoint, bbox2) {
+  return getPoints(multiPoint, bbox2);
+}
+function transformLineString(line, bbox2) {
+  return getPoints(line, bbox2);
+}
+function transformMultiLineString(multiLineString2, bbox2) {
+  return multiLineString2.map(
+    (lineString2) => transformLineString(lineString2, bbox2)
+  );
+}
+function transformPolygon(polygon2, bbox2) {
+  return polygon2.map((polygonRing) => getPoints(polygonRing, bbox2));
+}
+function transformMultiPolygon(multiPolygon2, bbox2) {
+  return multiPolygon2.map((polygon2) => transformPolygon(polygon2, bbox2));
+}
+
 // node_modules/@turf/bbox-polygon/dist/esm/index.js
 function bboxPolygon(bbox2, options = {}) {
   const west = Number(bbox2[0]);
@@ -1876,7 +1980,7 @@ var MAX_SAFE_INTEGER = 9007199254740991;
 var POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13];
 var SQRT_BASE = 1e7;
 var MAX = 1e9;
-function clone(configObject) {
+function clone2(configObject) {
   var div, convertBase, parseNumeric, P = BigNumber2.prototype = { constructor: BigNumber2, toString: null, valueOf: null }, ONE = new BigNumber2(1), DECIMAL_PLACES = 20, ROUNDING_MODE = 4, TO_EXP_NEG = -7, TO_EXP_POS = 21, MIN_EXP = -1e7, MAX_EXP = 1e7, CRYPTO = false, MODULO_MODE = 1, POW_PRECISION = 0, FORMAT = {
     prefix: "",
     groupSize: 3,
@@ -2002,7 +2106,7 @@ function clone(configObject) {
       x.c = [x.e = 0];
     }
   }
-  BigNumber2.clone = clone;
+  BigNumber2.clone = clone2;
   BigNumber2.ROUND_UP = 0;
   BigNumber2.ROUND_DOWN = 1;
   BigNumber2.ROUND_CEIL = 2;
@@ -3205,7 +3309,7 @@ function toFixedPoint(str, e, z) {
   }
   return str;
 }
-var BigNumber = clone();
+var BigNumber = clone2();
 var bignumber_default = BigNumber;
 
 // node_modules/splaytree-ts/dist/esm/index.js
@@ -4775,71 +4879,14 @@ function intersect(features, options = {}) {
 }
 var turf_intersect_default = intersect;
 
-// node_modules/@math.gl/core/dist/lib/common.js
-var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
-var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
-var DEFAULT_CONFIG = {
-  EPSILON: 1e-12,
-  debug: false,
-  precision: 4,
-  printTypes: false,
-  printDegrees: false,
-  printRowMajor: true,
-  _cartographicRadians: false
-};
-globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
-var config = globalThis.mathgl.config;
-function isArray(value) {
-  return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
-}
-function lerp(a, b, t) {
-  if (isArray(a)) {
-    return a.map((ai, i) => lerp(ai, b[i], t));
-  }
-  return t * b + (1 - t) * a;
-}
-
-// node_modules/@math.gl/web-mercator/dist/assert.js
-function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message || "@math.gl/web-mercator: assertion failed.");
-  }
-}
-
-// node_modules/@math.gl/web-mercator/dist/web-mercator-utils.js
-var PI = Math.PI;
-var PI_4 = PI / 4;
-var DEGREES_TO_RADIANS2 = PI / 180;
-var RADIANS_TO_DEGREES2 = 180 / PI;
-var TILE_SIZE = 512;
-function lngLatToWorld(lngLat) {
-  const [lng, lat] = lngLat;
-  assert(Number.isFinite(lng));
-  assert(Number.isFinite(lat) && lat >= -90 && lat <= 90, "invalid latitude");
-  const lambda2 = lng * DEGREES_TO_RADIANS2;
-  const phi2 = lat * DEGREES_TO_RADIANS2;
-  const x = TILE_SIZE * (lambda2 + PI) / (2 * PI);
-  const y = TILE_SIZE * (PI + Math.log(Math.tan(PI_4 + phi2 * 0.5))) / (2 * PI);
-  return [x, y];
-}
-function worldToLngLat(xy) {
-  const [x, y] = xy;
-  const lambda2 = x / TILE_SIZE * (2 * PI) - PI;
-  const phi2 = 2 * (Math.atan(Math.exp(y / TILE_SIZE * (2 * PI) - PI)) - PI_4);
-  return [lambda2 * RADIANS_TO_DEGREES2, phi2 * RADIANS_TO_DEGREES2];
-}
-
-// node_modules/@math.gl/web-mercator/dist/get-bounds.js
-var DEGREES_TO_RADIANS3 = Math.PI / 180;
-
 // src/utils/transformToTileCoords.ts
-var TRANSFORM_FN = {
-  Point: transformPoint,
-  MultiPoint: transformMultiPoint,
-  LineString: transformLineString,
-  MultiLineString: transformMultiLineString,
-  Polygon: transformPolygon,
-  MultiPolygon: transformMultiPolygon
+var TRANSFORM_FN2 = {
+  Point: transformPoint2,
+  MultiPoint: transformMultiPoint2,
+  LineString: transformLineString2,
+  MultiLineString: transformMultiLineString2,
+  Polygon: transformPolygon2,
+  MultiPolygon: transformMultiPolygon2
 };
 function transformToTileCoords(geometry, bbox2) {
   const [west, south, east, north] = bbox2;
@@ -4849,34 +4896,34 @@ function transformToTileCoords(geometry, bbox2) {
   if (geometry.type === "GeometryCollection") {
     throw new Error("Unsupported geometry type GeometryCollection");
   }
-  const transformFn = TRANSFORM_FN[geometry.type];
+  const transformFn = TRANSFORM_FN2[geometry.type];
   const coordinates = transformFn(geometry.coordinates, projectedBbox);
   return { ...geometry, coordinates };
 }
-function transformPoint([pointX, pointY], [nw, se]) {
+function transformPoint2([pointX, pointY], [nw, se]) {
   const x = inverseLerp(nw[0], se[0], pointX);
   const y = inverseLerp(nw[1], se[1], pointY);
   return [x, y];
 }
-function getPoints(geometry, bbox2) {
-  return geometry.map((g) => transformPoint(projectFlat(g), bbox2));
+function getPoints2(geometry, bbox2) {
+  return geometry.map((g) => transformPoint2(projectFlat(g), bbox2));
 }
-function transformMultiPoint(multiPoint, bbox2) {
-  return getPoints(multiPoint, bbox2);
+function transformMultiPoint2(multiPoint, bbox2) {
+  return getPoints2(multiPoint, bbox2);
 }
-function transformLineString(line, bbox2) {
-  return getPoints(line, bbox2);
+function transformLineString2(line, bbox2) {
+  return getPoints2(line, bbox2);
 }
-function transformMultiLineString(multiLineString2, bbox2) {
+function transformMultiLineString2(multiLineString2, bbox2) {
   return multiLineString2.map(
-    (lineString2) => transformLineString(lineString2, bbox2)
+    (lineString2) => transformLineString2(lineString2, bbox2)
   );
 }
-function transformPolygon(polygon2, bbox2) {
-  return polygon2.map((polygonRing) => getPoints(polygonRing, bbox2));
+function transformPolygon2(polygon2, bbox2) {
+  return polygon2.map((polygonRing) => getPoints2(polygonRing, bbox2));
 }
-function transformMultiPolygon(multiPolygon2, bbox2) {
-  return multiPolygon2.map((polygon2) => transformPolygon(polygon2, bbox2));
+function transformMultiPolygon2(multiPolygon2, bbox2) {
+  return multiPolygon2.map((polygon2) => transformPolygon2(polygon2, bbox2));
 }
 function projectFlat(xyz) {
   return lngLatToWorld(xyz);
@@ -4885,51 +4932,195 @@ function inverseLerp(a, b, x) {
   return (x - a) / (b - a);
 }
 
-// src/utils/transformTileCoordsToWGS84.ts
-var TRANSFORM_FN2 = {
-  Point: transformPoint2,
-  MultiPoint: transformMultiPoint2,
-  LineString: transformLineString2,
-  MultiLineString: transformMultiLineString2,
-  Polygon: transformPolygon2,
-  MultiPolygon: transformMultiPolygon2
-};
-function transformTileCoordsToWGS84(geometry, bbox2) {
-  const [west, south, east, north] = bbox2;
-  const nw = lngLatToWorld([west, north]);
-  const se = lngLatToWorld([east, south]);
-  const projectedBbox = [nw, se];
-  if (geometry.type === "GeometryCollection") {
-    throw new Error("Unsupported geometry type GeometryCollection");
+// src/filters/tileIntersection.ts
+import {
+  cellToBoundary as quadbinCellToBoundary,
+  geometryToCells as quadbinGeometryToCells
+} from "quadbin";
+import {
+  cellToBoundary as h3CellToBoundary,
+  polygonToCells as h3PolygonToCells
+} from "h3-js";
+
+// node_modules/@turf/bbox-clip/dist/esm/index.js
+function lineclip(points, bbox2, result) {
+  var len = points.length, codeA = bitCode(points[0], bbox2), part = [], i, codeB, lastCode;
+  let a;
+  let b;
+  if (!result) result = [];
+  for (i = 1; i < len; i++) {
+    a = points[i - 1];
+    b = points[i];
+    codeB = lastCode = bitCode(b, bbox2);
+    while (true) {
+      if (!(codeA | codeB)) {
+        part.push(a);
+        if (codeB !== lastCode) {
+          part.push(b);
+          if (i < len - 1) {
+            result.push(part);
+            part = [];
+          }
+        } else if (i === len - 1) {
+          part.push(b);
+        }
+        break;
+      } else if (codeA & codeB) {
+        break;
+      } else if (codeA) {
+        a = intersect2(a, b, codeA, bbox2);
+        codeA = bitCode(a, bbox2);
+      } else {
+        b = intersect2(a, b, codeB, bbox2);
+        codeB = bitCode(b, bbox2);
+      }
+    }
+    codeA = lastCode;
+  }
+  if (part.length) result.push(part);
+  return result;
+}
+function polygonclip(points, bbox2) {
+  var result, edge, prev, prevInside, i, p, inside;
+  for (edge = 1; edge <= 8; edge *= 2) {
+    result = [];
+    prev = points[points.length - 1];
+    prevInside = !(bitCode(prev, bbox2) & edge);
+    for (i = 0; i < points.length; i++) {
+      p = points[i];
+      inside = !(bitCode(p, bbox2) & edge);
+      if (inside !== prevInside) result.push(intersect2(prev, p, edge, bbox2));
+      if (inside) result.push(p);
+      prev = p;
+      prevInside = inside;
+    }
+    points = result;
+    if (!points.length) break;
   }
-  const transformFn = TRANSFORM_FN2[geometry.type];
-  const coordinates = transformFn(geometry.coordinates, projectedBbox);
-  return { ...geometry, coordinates };
+  return result;
 }
-function transformPoint2([pointX, pointY], [nw, se]) {
-  const x = lerp(nw[0], se[0], pointX);
-  const y = lerp(nw[1], se[1], pointY);
-  return worldToLngLat([x, y]);
+function intersect2(a, b, edge, bbox2) {
+  return edge & 8 ? [a[0] + (b[0] - a[0]) * (bbox2[3] - a[1]) / (b[1] - a[1]), bbox2[3]] : edge & 4 ? [a[0] + (b[0] - a[0]) * (bbox2[1] - a[1]) / (b[1] - a[1]), bbox2[1]] : edge & 2 ? [bbox2[2], a[1] + (b[1] - a[1]) * (bbox2[2] - a[0]) / (b[0] - a[0])] : edge & 1 ? [bbox2[0], a[1] + (b[1] - a[1]) * (bbox2[0] - a[0]) / (b[0] - a[0])] : null;
 }
-function getPoints2(geometry, bbox2) {
-  return geometry.map((g) => transformPoint2(g, bbox2));
+function bitCode(p, bbox2) {
+  var code = 0;
+  if (p[0] < bbox2[0]) code |= 1;
+  else if (p[0] > bbox2[2]) code |= 2;
+  if (p[1] < bbox2[1]) code |= 4;
+  else if (p[1] > bbox2[3]) code |= 8;
+  return code;
 }
-function transformMultiPoint2(multiPoint, bbox2) {
-  return getPoints2(multiPoint, bbox2);
+function bboxClip(feature2, bbox2) {
+  const geom = getGeom(feature2);
+  const type = geom.type;
+  const properties = feature2.type === "Feature" ? feature2.properties : {};
+  let coords = geom.coordinates;
+  switch (type) {
+    case "LineString":
+    case "MultiLineString": {
+      const lines = [];
+      if (type === "LineString") {
+        coords = [coords];
+      }
+      coords.forEach((line) => {
+        lineclip(line, bbox2, lines);
+      });
+      if (lines.length === 1) {
+        return lineString(lines[0], properties);
+      }
+      return multiLineString(lines, properties);
+    }
+    case "Polygon":
+      return polygon(clipPolygon(coords, bbox2), properties);
+    case "MultiPolygon":
+      return multiPolygon(
+        coords.map((poly) => {
+          return clipPolygon(poly, bbox2);
+        }),
+        properties
+      );
+    default:
+      throw new Error("geometry " + type + " not supported");
+  }
 }
-function transformLineString2(line, bbox2) {
-  return getPoints2(line, bbox2);
+function clipPolygon(rings, bbox2) {
+  const outRings = [];
+  for (const ring of rings) {
+    const clipped = polygonclip(ring, bbox2);
+    if (clipped.length > 0) {
+      if (clipped[0][0] !== clipped[clipped.length - 1][0] || clipped[0][1] !== clipped[clipped.length - 1][1]) {
+        clipped.push(clipped[0]);
+      }
+      if (clipped.length >= 4) {
+        outRings.push(clipped);
+      }
+    }
+  }
+  return outRings;
 }
-function transformMultiLineString2(multiLineString2, bbox2) {
-  return multiLineString2.map(
-    (lineString2) => transformLineString2(lineString2, bbox2)
+var turf_bbox_clip_default = bboxClip;
+
+// src/filters/tileIntersection.ts
+function intersectTileGeometry(tileBbox, tileFormat, spatialFilter) {
+  const tilePolygon = turf_bbox_polygon_default(tileBbox);
+  if (!spatialFilter || turf_boolean_within_default(tilePolygon, spatialFilter)) {
+    return true;
+  }
+  const clippedSpatialFilter = turf_intersect_default(
+    featureCollection([tilePolygon, feature(spatialFilter)])
   );
+  if (!clippedSpatialFilter) {
+    return false;
+  }
+  return tileFormat === "mvt" /* MVT */ ? transformToTileCoords(clippedSpatialFilter.geometry, tileBbox) : clippedSpatialFilter.geometry;
 }
-function transformPolygon2(polygon2, bbox2) {
-  return polygon2.map((polygonRing) => getPoints2(polygonRing, bbox2));
+function intersectTileRaster(parent, cellResolution, spatialFilter) {
+  return intersectTileQuadbin(parent, cellResolution, spatialFilter);
 }
-function transformMultiPolygon2(multiPolygon2, bbox2) {
-  return multiPolygon2.map((polygon2) => transformPolygon2(polygon2, bbox2));
+function intersectTileQuadbin(parent, cellResolution, spatialFilter) {
+  const tilePolygon = quadbinCellToBoundary(parent);
+  if (!spatialFilter || turf_boolean_within_default(tilePolygon, spatialFilter)) {
+    return true;
+  }
+  const clippedSpatialFilter = turf_intersect_default(
+    featureCollection([feature(tilePolygon), feature(spatialFilter)])
+  );
+  if (!clippedSpatialFilter) {
+    return false;
+  }
+  const cells = quadbinGeometryToCells(
+    clippedSpatialFilter.geometry,
+    cellResolution
+  );
+  return new Set(cells);
+}
+var BBOX_WEST = [-180, -90, 0, 90];
+var BBOX_EAST = [0, -90, 180, 90];
+function intersectTileH3(parent, cellResolution, spatialFilter) {
+  const tilePolygon = {
+    type: "Polygon",
+    coordinates: [h3CellToBoundary(parent, true)]
+  };
+  if (!spatialFilter || turf_boolean_within_default(tilePolygon, spatialFilter)) {
+    return true;
+  }
+  const clippedSpatialFilter = turf_intersect_default(
+    featureCollection([feature(tilePolygon), feature(spatialFilter)])
+  );
+  if (!clippedSpatialFilter) {
+    return false;
+  }
+  const cellsWest = h3PolygonToCells(
+    turf_bbox_clip_default(clippedSpatialFilter, BBOX_WEST).geometry.coordinates,
+    cellResolution,
+    true
+  );
+  const cellsEast = h3PolygonToCells(
+    turf_bbox_clip_default(clippedSpatialFilter, BBOX_EAST).geometry.coordinates,
+    cellResolution,
+    true
+  );
+  return new Set(cellsWest.concat(cellsEast));
 }
 
 // src/filters/tileFeaturesGeometries.ts
@@ -4946,55 +5137,45 @@ function tileFeaturesGeometries({
     if (tile.isVisible === false || !tile.data) {
       continue;
     }
-    const bbox2 = [
+    const tileBbox = [
       tile.bbox.west,
       tile.bbox.south,
       tile.bbox.east,
       tile.bbox.north
     ];
-    const bboxToGeom = turf_bbox_polygon_default(bbox2);
-    const tileIsFullyVisible = turf_boolean_within_default(bboxToGeom, spatialFilter);
-    const spatialFilterFeature = {
-      type: "Feature",
-      geometry: spatialFilter,
-      properties: {}
-    };
-    const clippedGeometryToIntersect = turf_intersect_default(
-      featureCollection([bboxToGeom, spatialFilterFeature])
+    const intersection3 = intersectTileGeometry(
+      tileBbox,
+      tileFormat,
+      spatialFilter
     );
-    if (!clippedGeometryToIntersect) {
-      continue;
-    }
-    const transformedGeometryToIntersect = tileFormat === "mvt" /* MVT */ ? transformToTileCoords(clippedGeometryToIntersect.geometry, bbox2) : clippedGeometryToIntersect.geometry;
+    if (intersection3 === false) continue;
+    const transformedSpatialFilter = intersection3 === true ? void 0 : intersection3;
     calculateFeatures({
       map,
-      tileIsFullyVisible,
-      geometryIntersection: transformedGeometryToIntersect,
+      spatialFilter: transformedSpatialFilter,
       data: tile.data.points,
       type: "Point",
-      bbox: bbox2,
+      bbox: tileBbox,
       tileFormat,
       uniqueIdProperty,
       options
     });
     calculateFeatures({
       map,
-      tileIsFullyVisible,
-      geometryIntersection: transformedGeometryToIntersect,
+      spatialFilter: transformedSpatialFilter,
       data: tile.data.lines,
       type: "LineString",
-      bbox: bbox2,
+      bbox: tileBbox,
       tileFormat,
       uniqueIdProperty,
       options
     });
     calculateFeatures({
       map,
-      tileIsFullyVisible,
-      geometryIntersection: transformedGeometryToIntersect,
+      spatialFilter: transformedSpatialFilter,
       data: tile.data.polygons,
       type: "Polygon",
-      bbox: bbox2,
+      bbox: tileBbox,
       tileFormat,
       uniqueIdProperty,
       options
@@ -5012,7 +5193,7 @@ function processTileFeatureProperties({
   tileFormat,
   uniqueIdProperty,
   storeGeometry,
-  geometryIntersection
+  spatialFilter
 }) {
   const tileProps = getPropertiesFromTile(data, startIndex);
   const uniquePropertyValue = getUniquePropertyValue(
@@ -5024,7 +5205,7 @@ function processTileFeatureProperties({
     return;
   }
   let geometry = null;
-  if (storeGeometry || geometryIntersection) {
+  if (storeGeometry || spatialFilter) {
     const { positions } = data;
     const ringCoordinates = getRingCoordinatesFor(
       startIndex,
@@ -5033,7 +5214,7 @@ function processTileFeatureProperties({
     );
     geometry = getFeatureByType(ringCoordinates, type);
   }
-  if (geometry && geometryIntersection && !turf_boolean_intersects_default(geometry, geometryIntersection)) {
+  if (geometry && spatialFilter && !turf_boolean_intersects_default(geometry, spatialFilter)) {
     return;
   }
   const properties = parseProperties(tileProps);
@@ -5045,7 +5226,7 @@ function processTileFeatureProperties({
 function addIntersectedFeaturesInTile({
   map,
   data,
-  geometryIntersection,
+  spatialFilter,
   type,
   bbox: bbox2,
   tileFormat,
@@ -5067,7 +5248,7 @@ function addIntersectedFeaturesInTile({
       tileFormat,
       uniqueIdProperty,
       storeGeometry,
-      geometryIntersection
+      spatialFilter
     });
   }
 }
@@ -5149,8 +5330,7 @@ function getRingCoordinatesFor(startIndex, endIndex, positions) {
 }
 function calculateFeatures({
   map,
-  tileIsFullyVisible,
-  geometryIntersection,
+  spatialFilter,
   data,
   type,
   bbox: bbox2,
@@ -5161,7 +5341,7 @@ function calculateFeatures({
   if (!data?.properties.length) {
     return;
   }
-  if (tileIsFullyVisible) {
+  if (!spatialFilter) {
     addAllFeaturesInTile({
       map,
       data,
@@ -5175,7 +5355,7 @@ function calculateFeatures({
     addIntersectedFeaturesInTile({
       map,
       data,
-      geometryIntersection,
+      spatialFilter,
       type,
       bbox: bbox2,
       tileFormat,
@@ -5225,128 +5405,8 @@ function createIndicesForPoints(data) {
 }
 
 // src/filters/tileFeaturesSpatialIndex.ts
-import { getResolution as quadbinGetResolution, geometryToCells } from "quadbin";
-
-// node_modules/@turf/bbox-clip/dist/esm/index.js
-function lineclip(points, bbox2, result) {
-  var len = points.length, codeA = bitCode(points[0], bbox2), part = [], i, codeB, lastCode;
-  let a;
-  let b;
-  if (!result) result = [];
-  for (i = 1; i < len; i++) {
-    a = points[i - 1];
-    b = points[i];
-    codeB = lastCode = bitCode(b, bbox2);
-    while (true) {
-      if (!(codeA | codeB)) {
-        part.push(a);
-        if (codeB !== lastCode) {
-          part.push(b);
-          if (i < len - 1) {
-            result.push(part);
-            part = [];
-          }
-        } else if (i === len - 1) {
-          part.push(b);
-        }
-        break;
-      } else if (codeA & codeB) {
-        break;
-      } else if (codeA) {
-        a = intersect2(a, b, codeA, bbox2);
-        codeA = bitCode(a, bbox2);
-      } else {
-        b = intersect2(a, b, codeB, bbox2);
-        codeB = bitCode(b, bbox2);
-      }
-    }
-    codeA = lastCode;
-  }
-  if (part.length) result.push(part);
-  return result;
-}
-function polygonclip(points, bbox2) {
-  var result, edge, prev, prevInside, i, p, inside;
-  for (edge = 1; edge <= 8; edge *= 2) {
-    result = [];
-    prev = points[points.length - 1];
-    prevInside = !(bitCode(prev, bbox2) & edge);
-    for (i = 0; i < points.length; i++) {
-      p = points[i];
-      inside = !(bitCode(p, bbox2) & edge);
-      if (inside !== prevInside) result.push(intersect2(prev, p, edge, bbox2));
-      if (inside) result.push(p);
-      prev = p;
-      prevInside = inside;
-    }
-    points = result;
-    if (!points.length) break;
-  }
-  return result;
-}
-function intersect2(a, b, edge, bbox2) {
-  return edge & 8 ? [a[0] + (b[0] - a[0]) * (bbox2[3] - a[1]) / (b[1] - a[1]), bbox2[3]] : edge & 4 ? [a[0] + (b[0] - a[0]) * (bbox2[1] - a[1]) / (b[1] - a[1]), bbox2[1]] : edge & 2 ? [bbox2[2], a[1] + (b[1] - a[1]) * (bbox2[2] - a[0]) / (b[0] - a[0])] : edge & 1 ? [bbox2[0], a[1] + (b[1] - a[1]) * (bbox2[0] - a[0]) / (b[0] - a[0])] : null;
-}
-function bitCode(p, bbox2) {
-  var code = 0;
-  if (p[0] < bbox2[0]) code |= 1;
-  else if (p[0] > bbox2[2]) code |= 2;
-  if (p[1] < bbox2[1]) code |= 4;
-  else if (p[1] > bbox2[3]) code |= 8;
-  return code;
-}
-function bboxClip(feature2, bbox2) {
-  const geom = getGeom(feature2);
-  const type = geom.type;
-  const properties = feature2.type === "Feature" ? feature2.properties : {};
-  let coords = geom.coordinates;
-  switch (type) {
-    case "LineString":
-    case "MultiLineString": {
-      const lines = [];
-      if (type === "LineString") {
-        coords = [coords];
-      }
-      coords.forEach((line) => {
-        lineclip(line, bbox2, lines);
-      });
-      if (lines.length === 1) {
-        return lineString(lines[0], properties);
-      }
-      return multiLineString(lines, properties);
-    }
-    case "Polygon":
-      return polygon(clipPolygon(coords, bbox2), properties);
-    case "MultiPolygon":
-      return multiPolygon(
-        coords.map((poly) => {
-          return clipPolygon(poly, bbox2);
-        }),
-        properties
-      );
-    default:
-      throw new Error("geometry " + type + " not supported");
-  }
-}
-function clipPolygon(rings, bbox2) {
-  const outRings = [];
-  for (const ring of rings) {
-    const clipped = polygonclip(ring, bbox2);
-    if (clipped.length > 0) {
-      if (clipped[0][0] !== clipped[clipped.length - 1][0] || clipped[0][1] !== clipped[clipped.length - 1][1]) {
-        clipped.push(clipped[0]);
-      }
-      if (clipped.length >= 4) {
-        outRings.push(clipped);
-      }
-    }
-  }
-  return outRings;
-}
-var turf_bbox_clip_default = bboxClip;
-
-// src/filters/tileFeaturesSpatialIndex.ts
-import { getResolution as h3GetResolution, polygonToCells } from "h3-js";
+import { getResolution as quadbinGetResolution } from "quadbin";
+import { getResolution as h3GetResolution } from "h3-js";
 function tileFeaturesSpatialIndex({
   tiles,
   spatialFilter,
@@ -5355,28 +5415,40 @@ function tileFeaturesSpatialIndex({
 }) {
   const map = /* @__PURE__ */ new Map();
   const spatialIndex = getSpatialIndex(spatialDataType);
-  const resolution = getResolution(tiles, spatialIndex);
+  const cellResolution = getResolution(tiles, spatialIndex);
   const spatialIndexIDName = spatialDataColumn ? spatialDataColumn : spatialIndex;
-  if (!resolution) {
+  if (!cellResolution) {
     return [];
   }
-  const cells = getCellsCoverGeometry(spatialFilter, spatialIndex, resolution);
-  if (!cells?.length) {
-    return [];
-  }
-  const cellsSet = new Set(cells);
   for (const tile of tiles) {
     if (tile.isVisible === false || !tile.data) {
       continue;
     }
+    const parent = getTileIndex(tile, spatialIndex);
+    const intersection3 = spatialIndex === "quadbin" /* QUADBIN */ ? intersectTileQuadbin(
+      parent,
+      cellResolution,
+      spatialFilter
+    ) : intersectTileH3(
+      parent,
+      cellResolution,
+      spatialFilter
+    );
+    if (!intersection3) continue;
     tile.data.forEach((d) => {
-      if (cellsSet.has(d.id)) {
+      if (intersection3 === true || intersection3.has(d.id)) {
         map.set(d.id, { ...d.properties, [spatialIndexIDName]: d.id });
       }
     });
   }
   return Array.from(map.values());
 }
+function getTileIndex(tile, spatialIndex) {
+  if (spatialIndex === "quadbin" /* QUADBIN */) {
+    return tile.index.q;
+  }
+  return tile.id;
+}
 function getResolution(tiles, spatialIndex) {
   const data = tiles.find((tile) => tile.data?.length)?.data;
   if (!data) {
@@ -5389,26 +5461,6 @@ function getResolution(tiles, spatialIndex) {
     return h3GetResolution(data[0].id);
   }
 }
-var bboxWest = [-180, -90, 0, 90];
-var bboxEast = [0, -90, 180, 90];
-function getCellsCoverGeometry(geometry, spatialIndex, resolution) {
-  if (spatialIndex === "quadbin" /* QUADBIN */) {
-    return geometryToCells(geometry, resolution);
-  }
-  if (spatialIndex === "h3" /* H3 */) {
-    return polygonToCells(
-      turf_bbox_clip_default(geometry, bboxWest).geometry.coordinates,
-      resolution,
-      true
-    ).concat(
-      polygonToCells(
-        turf_bbox_clip_default(geometry, bboxEast).geometry.coordinates,
-        resolution,
-        true
-      )
-    );
-  }
-}
 function getSpatialIndex(spatialDataType) {
   switch (spatialDataType) {
     case "h3":
@@ -5435,7 +5487,6 @@ var DEFAULT_AGGREGATION_EXP = `1 AS ${DEFAULT_AGGREGATION_EXP_ALIAS}`;
 import {
   cellToChildren as _cellToChildren,
   cellToTile,
-  geometryToCells as geometryToCells2,
   getResolution as getResolution2
 } from "quadbin";
 function tileFeaturesRaster({
@@ -5451,15 +5502,20 @@ function tileFeaturesRaster({
   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 intersection3 = intersectTileRaster(
+      parent,
+      cellResolution,
+      options.spatialFilter
+    );
+    if (intersection3 === false) continue;
+    const tileSortedCells = cellToChildrenSorted(parent, cellResolution);
+    for (let i = 0; i < tileSortedCells.length; i++) {
+      if (intersection3 !== true && !intersection3.has(tileSortedCells[i])) {
+        continue;
+      }
       const cellData = {};
       let cellDataExists = false;
       for (const band in tile.data.cells.numericProps) {
@@ -5471,7 +5527,7 @@ function tileFeaturesRaster({
         }
       }
       if (cellDataExists) {
-        data.set(children[i], cellData);
+        data.set(tileSortedCells[i], cellData);
       }
     }
   }
@@ -7180,7 +7236,7 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
   }
   _extractTileFeatures(spatialFilter) {
     const prevInputs = this._tileFeatureExtractPreviousInputs;
-    if (this._features.length && prevInputs.spatialFilter && booleanEqual(prevInputs.spatialFilter, spatialFilter)) {
+    if (this._features.length && spatialFilterEquals(prevInputs.spatialFilter, spatialFilter)) {
       return;
     }
     this._features = tileFeatures({
@@ -7420,7 +7476,6 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
    * INTERNAL
    */
   _getFilteredFeatures(spatialFilter, filters, filterOwner) {
-    assert2(spatialFilter, "spatialFilter required for tilesets");
     this._extractTileFeatures(spatialFilter);
     return applyFilters(
       this._features,
@@ -7444,6 +7499,11 @@ function assertColumn(features, ...columnArgs) {
 function normalizeColumns(columns) {
   return Array.isArray(columns) ? columns : typeof columns === "string" ? [columns] : [];
 }
+function spatialFilterEquals(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  return booleanEqual(a, b);
+}
 
 // src/widget-sources/widget-tileset-source.ts
 var WidgetTilesetSource = class extends WidgetSource {
@@ -9963,11 +10023,68 @@ function _getHexagonResolution(viewport, tileSize) {
     Math.floor(hexagonScaleFactor + latitudeScaleFactor - BIAS)
   );
 }
+
+// src/utils/CellSet.ts
+var EMPTY_U32 = 2 ** 32 - 1;
+var CellSet = class {
+  constructor(cells) {
+    /** List of cells stored by the set. Stored by reference, without copying. */
+    __publicField(this, "cells");
+    /** DataView representing a single cell ID. Pre-allocated to reduce memory during queries. */
+    __publicField(this, "cellView", new DataView(new ArrayBuffer(8)));
+    /** Hash table, mapping a hash index (computed) to an index in the 'cells' array. */
+    __publicField(this, "hashTable");
+    this.cells = cells;
+    this.hashTable = new Uint32Array(hashBuckets(cells.length)).fill(EMPTY_U32);
+    for (let cellIndex = 0; cellIndex < cells.length; cellIndex++) {
+      this.hashTable[this.hashLookup(cells[cellIndex])] = cellIndex;
+    }
+  }
+  has(cell) {
+    const hashIndex = this.hashLookup(cell);
+    return this.hashTable[hashIndex] !== EMPTY_U32;
+  }
+  hashLookup(cell) {
+    this.cellView.setBigUint64(0, cell);
+    const hashval = hash(this.cellView);
+    const hashmod = this.hashTable.length - 1;
+    let bucket = hashval & hashmod;
+    for (let probe = 0; probe <= hashmod; probe++) {
+      const cellIndex = this.hashTable[bucket];
+      if (cellIndex === EMPTY_U32 || cell === this.cells[cellIndex]) {
+        return bucket;
+      }
+      bucket = bucket + probe + 1 & hashmod;
+    }
+    throw new Error("Hash table full.");
+  }
+};
+function hash(view, h = 0) {
+  const m = 1540483477;
+  const r = 24;
+  for (let i = 0, il = view.byteLength / 4; i < il; i++) {
+    let k = view.getUint32(i * 4);
+    k = Math.imul(k, m) >>> 0;
+    k = (k ^ k >> r) >>> 0;
+    k = Math.imul(k, m) >>> 0;
+    h = Math.imul(h, m) >>> 0;
+    h = (h ^ k) >>> 0;
+  }
+  return h;
+}
+function hashBuckets(initialCount) {
+  let buckets = 1;
+  while (buckets < initialCount + initialCount / 4) {
+    buckets *= 2;
+  }
+  return buckets;
+}
 export {
   AggregationTypes,
   ApiVersion,
   basemap_styles_default as BASEMAP,
   CartoAPIError,
+  CellSet,
   DEFAULT_API_BASE_URL,
   FEATURE_GEOM_PROPERTY,
   FilterType,