@carto/api-client 0.5.7-alpha.6 → 0.5.7

package/build/api-client.cjs

@@ -1727,6 +1727,143 @@ init_cjs_shims();
 // src/filters/tileFeaturesGeometries.ts
 init_cjs_shims();
 
+// src/utils/transformTileCoordsToWGS84.ts
+init_cjs_shims();
+
+// node_modules/@math.gl/core/dist/index.js
+init_cjs_shims();
+
+// node_modules/@math.gl/core/dist/lib/common.js
+init_cjs_shims();
+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/index.js
+init_cjs_shims();
+
+// node_modules/@math.gl/web-mercator/dist/web-mercator-viewport.js
+init_cjs_shims();
+
+// node_modules/@math.gl/web-mercator/dist/math-utils.js
+init_cjs_shims();
+
+// node_modules/@math.gl/web-mercator/dist/web-mercator-utils.js
+init_cjs_shims();
+
+// node_modules/@math.gl/web-mercator/dist/assert.js
+init_cjs_shims();
+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/fit-bounds.js
+init_cjs_shims();
+
+// node_modules/@math.gl/web-mercator/dist/get-bounds.js
+init_cjs_shims();
+var DEGREES_TO_RADIANS3 = Math.PI / 180;
+
+// node_modules/@math.gl/web-mercator/dist/normalize-viewport-props.js
+init_cjs_shims();
+
+// node_modules/@math.gl/web-mercator/dist/fly-to-viewport.js
+init_cjs_shims();
+
+// 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));
+}
+
+// src/filters/tileIntersection.ts
+init_cjs_shims();
+
 // node_modules/@turf/bbox-polygon/dist/esm/index.js
 init_cjs_shims();
 function bboxPolygon(bbox2, options = {}) {
@@ -2058,7 +2195,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,
@@ -2184,7 +2321,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;
@@ -3387,7 +3524,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
@@ -4960,99 +5097,13 @@ var turf_intersect_default = intersect;
 
 // src/utils/transformToTileCoords.ts
 init_cjs_shims();
-
-// node_modules/@math.gl/web-mercator/dist/index.js
-init_cjs_shims();
-
-// node_modules/@math.gl/web-mercator/dist/web-mercator-viewport.js
-init_cjs_shims();
-
-// node_modules/@math.gl/web-mercator/dist/math-utils.js
-init_cjs_shims();
-
-// node_modules/@math.gl/core/dist/index.js
-init_cjs_shims();
-
-// node_modules/@math.gl/core/dist/lib/common.js
-init_cjs_shims();
-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/web-mercator-utils.js
-init_cjs_shims();
-
-// node_modules/@math.gl/web-mercator/dist/assert.js
-init_cjs_shims();
-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/fit-bounds.js
-init_cjs_shims();
-
-// node_modules/@math.gl/web-mercator/dist/get-bounds.js
-init_cjs_shims();
-var DEGREES_TO_RADIANS3 = Math.PI / 180;
-
-// node_modules/@math.gl/web-mercator/dist/normalize-viewport-props.js
-init_cjs_shims();
-
-// node_modules/@math.gl/web-mercator/dist/fly-to-viewport.js
-init_cjs_shims();
-
-// 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;
@@ -5062,34 +5113,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 transformMultiPolygon(multiPolygon2, bbox2) {
-  return multiPolygon2.map((polygon2) => transformPolygon(polygon2, bbox2));
+function transformPolygon2(polygon2, bbox2) {
+  return polygon2.map((polygonRing) => getPoints2(polygonRing, bbox2));
+}
+function transformMultiPolygon2(multiPolygon2, bbox2) {
+  return multiPolygon2.map((polygon2) => transformPolygon2(polygon2, bbox2));
 }
 function projectFlat(xyz) {
   return lngLatToWorld(xyz);
@@ -5098,52 +5149,181 @@ function inverseLerp(a, b, x) {
   return (x - a) / (b - a);
 }
 
-// src/utils/transformTileCoordsToWGS84.ts
+// src/filters/tileIntersection.ts
+var import_quadbin = require("quadbin");
+var import_h3_js = require("h3-js");
+
+// node_modules/@turf/bbox-clip/dist/esm/index.js
 init_cjs_shims();
-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");
+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;
   }
-  const transformFn = TRANSFORM_FN2[geometry.type];
-  const coordinates = transformFn(geometry.coordinates, projectedBbox);
-  return { ...geometry, coordinates };
+  if (part.length) result.push(part);
+  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 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 getPoints2(geometry, bbox2) {
-  return geometry.map((g) => transformPoint2(g, bbox2));
+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 transformMultiPoint2(multiPoint, bbox2) {
-  return getPoints2(multiPoint, 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 transformLineString2(line, bbox2) {
-  return getPoints2(line, 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 transformMultiLineString2(multiLineString2, bbox2) {
-  return multiLineString2.map(
-    (lineString2) => transformLineString2(lineString2, 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;
+}
+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 = (0, import_quadbin.cellToBoundary)(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 = (0, import_quadbin.geometryToCells)(
+    clippedSpatialFilter.geometry,
+    cellResolution
+  );
+  return new Set(cells);
+}
+var BBOX_WEST = [-180, -90, 0, 90];
+var BBOX_EAST = [0, -90, 180, 90];
+function intersectTileH3(cellResolution, spatialFilter) {
+  if (!spatialFilter) {
+    return true;
+  }
+  const spatialFilterFeature = feature(spatialFilter);
+  const cellsWest = (0, import_h3_js.polygonToCells)(
+    turf_bbox_clip_default(spatialFilterFeature, BBOX_WEST).geometry.coordinates,
+    cellResolution,
+    true
+  );
+  const cellsEast = (0, import_h3_js.polygonToCells)(
+    turf_bbox_clip_default(spatialFilterFeature, BBOX_EAST).geometry.coordinates,
+    cellResolution,
+    true
+  );
+  return new Set(cellsWest.concat(cellsEast));
 }
 
 // src/filters/tileFeaturesGeometries.ts
@@ -5160,55 +5340,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
@@ -5226,7 +5396,7 @@ function processTileFeatureProperties({
   tileFormat,
   uniqueIdProperty,
   storeGeometry,
-  geometryIntersection
+  spatialFilter
 }) {
   const tileProps = getPropertiesFromTile(data, startIndex);
   const uniquePropertyValue = getUniquePropertyValue(
@@ -5238,7 +5408,7 @@ function processTileFeatureProperties({
     return;
   }
   let geometry = null;
-  if (storeGeometry || geometryIntersection) {
+  if (storeGeometry || spatialFilter) {
     const { positions } = data;
     const ringCoordinates = getRingCoordinatesFor(
       startIndex,
@@ -5247,7 +5417,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);
@@ -5259,7 +5429,7 @@ function processTileFeatureProperties({
 function addIntersectedFeaturesInTile({
   map,
   data,
-  geometryIntersection,
+  spatialFilter,
   type,
   bbox: bbox2,
   tileFormat,
@@ -5281,7 +5451,7 @@ function addIntersectedFeaturesInTile({
       tileFormat,
       uniqueIdProperty,
       storeGeometry,
-      geometryIntersection
+      spatialFilter
     });
   }
 }
@@ -5363,8 +5533,7 @@ function getRingCoordinatesFor(startIndex, endIndex, positions) {
 }
 function calculateFeatures({
   map,
-  tileIsFullyVisible,
-  geometryIntersection,
+  spatialFilter,
   data,
   type,
   bbox: bbox2,
@@ -5375,7 +5544,7 @@ function calculateFeatures({
   if (!data?.properties.length) {
     return;
   }
-  if (tileIsFullyVisible) {
+  if (!spatialFilter) {
     addAllFeaturesInTile({
       map,
       data,
@@ -5389,7 +5558,7 @@ function calculateFeatures({
     addIntersectedFeaturesInTile({
       map,
       data,
-      geometryIntersection,
+      spatialFilter,
       type,
       bbox: bbox2,
       tileFormat,
@@ -5440,129 +5609,8 @@ function createIndicesForPoints(data) {
 
 // src/filters/tileFeaturesSpatialIndex.ts
 init_cjs_shims();
-var import_quadbin = require("quadbin");
-
-// node_modules/@turf/bbox-clip/dist/esm/index.js
-init_cjs_shims();
-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
-var import_h3_js = require("h3-js");
+var import_quadbin2 = require("quadbin");
+var import_h3_js2 = require("h3-js");
 function tileFeaturesSpatialIndex({
   tiles,
   spatialFilter,
@@ -5571,58 +5619,52 @@ 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 [];
+  let intersection3;
+  if (spatialIndex === "h3" /* H3 */) {
+    intersection3 = intersectTileH3(cellResolution, spatialFilter);
   }
-  const cellsSet = new Set(cells);
   for (const tile of tiles) {
     if (tile.isVisible === false || !tile.data) {
       continue;
     }
+    if (spatialIndex === "quadbin" /* QUADBIN */) {
+      const parent = getTileIndex(tile, spatialIndex);
+      intersection3 = intersectTileQuadbin(
+        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) {
     return;
   }
   if (spatialIndex === "quadbin" /* QUADBIN */) {
-    return Number((0, import_quadbin.getResolution)(data[0].id));
-  }
-  if (spatialIndex === "h3" /* H3 */) {
-    return (0, import_h3_js.getResolution)(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 (0, import_quadbin.geometryToCells)(geometry, resolution);
+    return Number((0, import_quadbin2.getResolution)(data[0].id));
   }
   if (spatialIndex === "h3" /* H3 */) {
-    return (0, import_h3_js.polygonToCells)(
-      turf_bbox_clip_default(geometry, bboxWest).geometry.coordinates,
-      resolution,
-      true
-    ).concat(
-      (0, import_h3_js.polygonToCells)(
-        turf_bbox_clip_default(geometry, bboxEast).geometry.coordinates,
-        resolution,
-        true
-      )
-    );
+    return (0, import_h3_js2.getResolution)(data[0].id);
   }
 }
 function getSpatialIndex(spatialDataType) {
@@ -5650,7 +5692,7 @@ var DEFAULT_AGGREGATION_EXP = `1 AS ${DEFAULT_AGGREGATION_EXP_ALIAS}`;
 
 // src/filters/tileFeaturesRaster.ts
 init_cjs_shims();
-var import_quadbin2 = require("quadbin");
+var import_quadbin3 = require("quadbin");
 function tileFeaturesRaster({
   tiles,
   ...options
@@ -5661,21 +5703,21 @@ function tileFeaturesRaster({
   }
   tiles = tiles.filter(isRasterTileVisible);
   if (tiles.length === 0) return [];
-  const tileResolution = (0, import_quadbin2.getResolution)(tiles[0].index.q);
+  const tileResolution = (0, import_quadbin3.getResolution)(tiles[0].index.q);
   const tileBlockSize = tiles[0].data.blockSize;
   const cellResolution = tileResolution + BigInt(Math.log2(tileBlockSize));
   const data = /* @__PURE__ */ new Map();
   for (const tile of tiles) {
     const parent = tile.index.q;
-    const tilePolygon = (0, import_quadbin2.cellToBoundary)(parent);
-    const tileFilter = turf_intersect_default(
-      featureCollection([feature(tilePolygon), feature(options.spatialFilter)])
+    const intersection3 = intersectTileRaster(
+      parent,
+      cellResolution,
+      options.spatialFilter
     );
-    const needsFilter = tileFilter ? !turf_boolean_within_default(tilePolygon, options.spatialFilter) : false;
-    const tileFilterCells = needsFilter ? new Set((0, import_quadbin2.geometryToCells)(tileFilter.geometry, cellResolution)) : null;
+    if (intersection3 === false) continue;
     const tileSortedCells = cellToChildrenSorted(parent, cellResolution);
     for (let i = 0; i < tileSortedCells.length; i++) {
-      if (needsFilter && !tileFilterCells.has(tileSortedCells[i])) {
+      if (intersection3 !== true && !intersection3.has(tileSortedCells[i])) {
         continue;
       }
       const cellData = {};
@@ -5702,10 +5744,10 @@ function isRasterTileVisible(tile) {
   return !!(tile.isVisible && tile.data?.cells?.numericProps);
 }
 function cellToChildrenSorted(parent, resolution) {
-  return (0, import_quadbin2.cellToChildren)(parent, resolution).sort(
+  return (0, import_quadbin3.cellToChildren)(parent, resolution).sort(
     (cellA, cellB) => {
-      const tileA = (0, import_quadbin2.cellToTile)(cellA);
-      const tileB = (0, import_quadbin2.cellToTile)(cellB);
+      const tileA = (0, import_quadbin3.cellToTile)(cellA);
+      const tileB = (0, import_quadbin3.cellToTile)(cellB);
       if (tileA.y !== tileB.y) {
         return tileA.y > tileB.y ? 1 : -1;
       }
@@ -7466,7 +7508,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({
@@ -7706,7 +7748,6 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
    * INTERNAL
    */
   _getFilteredFeatures(spatialFilter, filters, filterOwner) {
-    assert2(spatialFilter, "spatialFilter required for tilesets");
     this._extractTileFeatures(spatialFilter);
     return applyFilters(
       this._features,
@@ -7730,6 +7771,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 {