@carto/api-client 0.5.7-alpha-optional-spatial-filter.0 → 0.5.7-alpha-others-orderby.1

package/build/worker.js

@@ -1505,110 +1505,6 @@ 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 assert2(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;
-  assert2(Number.isFinite(lng));
-  assert2(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]);
@@ -1927,7 +1823,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 clone2(configObject) {
+function clone(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,
@@ -2053,7 +1949,7 @@ function clone2(configObject) {
       x.c = [x.e = 0];
     }
   }
-  BigNumber2.clone = clone2;
+  BigNumber2.clone = clone;
   BigNumber2.ROUND_UP = 0;
   BigNumber2.ROUND_DOWN = 1;
   BigNumber2.ROUND_CEIL = 2;
@@ -3256,7 +3152,7 @@ function toFixedPoint(str, e, z) {
   }
   return str;
 }
-var BigNumber = clone2();
+var BigNumber = clone();
 var bignumber_default = BigNumber;
 
 // node_modules/splaytree-ts/dist/esm/index.js
@@ -4825,7 +4721,117 @@ 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 assert2(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;
+  assert2(Number.isFinite(lng));
+  assert2(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
+};
+function transformToTileCoords(geometry, bbox2) {
+  const [west, south, east, north] = bbox2;
+  const nw = projectFlat([west, north]);
+  const se = projectFlat([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 = 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 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));
+}
+function projectFlat(xyz) {
+  return lngLatToWorld(xyz);
+}
+function inverseLerp(a, b, x) {
+  return (x - a) / (b - a);
+}
+
+// src/utils/transformTileCoordsToWGS84.ts
 var TRANSFORM_FN2 = {
   Point: transformPoint2,
   MultiPoint: transformMultiPoint2,
@@ -4834,10 +4840,10 @@ var TRANSFORM_FN2 = {
   Polygon: transformPolygon2,
   MultiPolygon: transformMultiPolygon2
 };
-function transformToTileCoords(geometry, bbox2) {
+function transformTileCoordsToWGS84(geometry, bbox2) {
   const [west, south, east, north] = bbox2;
-  const nw = projectFlat([west, north]);
-  const se = projectFlat([east, south]);
+  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");
@@ -4847,12 +4853,12 @@ function transformToTileCoords(geometry, bbox2) {
   return { ...geometry, coordinates };
 }
 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];
+  const x = lerp(nw[0], se[0], pointX);
+  const y = lerp(nw[1], se[1], pointY);
+  return worldToLngLat([x, y]);
 }
 function getPoints2(geometry, bbox2) {
-  return geometry.map((g) => transformPoint2(projectFlat(g), bbox2));
+  return geometry.map((g) => transformPoint2(g, bbox2));
 }
 function transformMultiPoint2(multiPoint, bbox2) {
   return getPoints2(multiPoint, bbox2);
@@ -4871,203 +4877,6 @@ function transformPolygon2(polygon2, bbox2) {
 function transformMultiPolygon2(multiPolygon2, bbox2) {
   return multiPolygon2.map((polygon2) => transformPolygon2(polygon2, bbox2));
 }
-function projectFlat(xyz) {
-  return lngLatToWorld(xyz);
-}
-function inverseLerp(a, b, x) {
-  return (x - a) / (b - a);
-}
-
-// 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;
-  }
-  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/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 intersectTileRaster(parent, cellResolution, spatialFilter) {
-  return intersectTileQuadbin(parent, cellResolution, spatialFilter);
-}
-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
 var FEATURE_GEOM_PROPERTY = "__geomValue";
@@ -5083,45 +4892,55 @@ function tileFeaturesGeometries({
     if (tile.isVisible === false || !tile.data) {
       continue;
     }
-    const tileBbox = [
+    const bbox2 = [
       tile.bbox.west,
       tile.bbox.south,
       tile.bbox.east,
       tile.bbox.north
     ];
-    const intersection3 = intersectTileGeometry(
-      tileBbox,
-      tileFormat,
-      spatialFilter
+    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])
     );
-    if (intersection3 === false) continue;
-    const transformedSpatialFilter = intersection3 === true ? void 0 : intersection3;
+    if (!clippedGeometryToIntersect) {
+      continue;
+    }
+    const transformedGeometryToIntersect = tileFormat === "mvt" /* MVT */ ? transformToTileCoords(clippedGeometryToIntersect.geometry, bbox2) : clippedGeometryToIntersect.geometry;
     calculateFeatures({
       map,
-      spatialFilter: transformedSpatialFilter,
+      tileIsFullyVisible,
+      geometryIntersection: transformedGeometryToIntersect,
       data: tile.data.points,
       type: "Point",
-      bbox: tileBbox,
+      bbox: bbox2,
       tileFormat,
       uniqueIdProperty,
       options
     });
     calculateFeatures({
       map,
-      spatialFilter: transformedSpatialFilter,
+      tileIsFullyVisible,
+      geometryIntersection: transformedGeometryToIntersect,
       data: tile.data.lines,
       type: "LineString",
-      bbox: tileBbox,
+      bbox: bbox2,
       tileFormat,
       uniqueIdProperty,
       options
     });
     calculateFeatures({
       map,
-      spatialFilter: transformedSpatialFilter,
+      tileIsFullyVisible,
+      geometryIntersection: transformedGeometryToIntersect,
       data: tile.data.polygons,
       type: "Polygon",
-      bbox: tileBbox,
+      bbox: bbox2,
       tileFormat,
       uniqueIdProperty,
       options
@@ -5139,7 +4958,7 @@ function processTileFeatureProperties({
   tileFormat,
   uniqueIdProperty,
   storeGeometry,
-  spatialFilter
+  geometryIntersection
 }) {
   const tileProps = getPropertiesFromTile(data, startIndex);
   const uniquePropertyValue = getUniquePropertyValue(
@@ -5151,7 +4970,7 @@ function processTileFeatureProperties({
     return;
   }
   let geometry = null;
-  if (storeGeometry || spatialFilter) {
+  if (storeGeometry || geometryIntersection) {
     const { positions } = data;
     const ringCoordinates = getRingCoordinatesFor(
       startIndex,
@@ -5160,7 +4979,7 @@ function processTileFeatureProperties({
     );
     geometry = getFeatureByType(ringCoordinates, type);
   }
-  if (geometry && spatialFilter && !turf_boolean_intersects_default(geometry, spatialFilter)) {
+  if (geometry && geometryIntersection && !turf_boolean_intersects_default(geometry, geometryIntersection)) {
     return;
   }
   const properties = parseProperties(tileProps);
@@ -5172,7 +4991,7 @@ function processTileFeatureProperties({
 function addIntersectedFeaturesInTile({
   map,
   data,
-  spatialFilter,
+  geometryIntersection,
   type,
   bbox: bbox2,
   tileFormat,
@@ -5194,7 +5013,7 @@ function addIntersectedFeaturesInTile({
       tileFormat,
       uniqueIdProperty,
       storeGeometry,
-      spatialFilter
+      geometryIntersection
     });
   }
 }
@@ -5276,7 +5095,8 @@ function getRingCoordinatesFor(startIndex, endIndex, positions) {
 }
 function calculateFeatures({
   map,
-  spatialFilter,
+  tileIsFullyVisible,
+  geometryIntersection,
   data,
   type,
   bbox: bbox2,
@@ -5287,7 +5107,7 @@ function calculateFeatures({
   if (!data?.properties.length) {
     return;
   }
-  if (!spatialFilter) {
+  if (tileIsFullyVisible) {
     addAllFeaturesInTile({
       map,
       data,
@@ -5301,7 +5121,7 @@ function calculateFeatures({
     addIntersectedFeaturesInTile({
       map,
       data,
-      spatialFilter,
+      geometryIntersection,
       type,
       bbox: bbox2,
       tileFormat,
@@ -5351,8 +5171,128 @@ function createIndicesForPoints(data) {
 }
 
 // src/filters/tileFeaturesSpatialIndex.ts
-import { getResolution as quadbinGetResolution } from "quadbin";
-import { getResolution as h3GetResolution } from "h3-js";
+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";
 function tileFeaturesSpatialIndex({
   tiles,
   spatialFilter,
@@ -5361,40 +5301,28 @@ function tileFeaturesSpatialIndex({
 }) {
   const map = /* @__PURE__ */ new Map();
   const spatialIndex = getSpatialIndex(spatialDataType);
-  const cellResolution = getResolution(tiles, spatialIndex);
+  const resolution = getResolution(tiles, spatialIndex);
   const spatialIndexIDName = spatialDataColumn ? spatialDataColumn : spatialIndex;
-  if (!cellResolution) {
+  if (!resolution) {
+    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 (intersection3 === true || intersection3.has(d.id)) {
+      if (cellsSet.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) {
@@ -5407,6 +5335,26 @@ 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":
@@ -5426,7 +5374,9 @@ var DEFAULT_AGGREGATION_EXP = `1 AS ${DEFAULT_AGGREGATION_EXP_ALIAS}`;
 // src/filters/tileFeaturesRaster.ts
 import {
   cellToChildren as _cellToChildren,
+  cellToBoundary,
   cellToTile,
+  geometryToCells as geometryToCells2,
   getResolution as getResolution2
 } from "quadbin";
 function tileFeaturesRaster({
@@ -5445,15 +5395,15 @@ function tileFeaturesRaster({
   const data = /* @__PURE__ */ new Map();
   for (const tile of tiles) {
     const parent = tile.index.q;
-    const intersection3 = intersectTileRaster(
-      parent,
-      cellResolution,
-      options.spatialFilter
+    const tilePolygon = cellToBoundary(parent);
+    const tileFilter = turf_intersect_default(
+      featureCollection([feature(tilePolygon), feature(options.spatialFilter)])
     );
-    if (intersection3 === false) continue;
+    const needsFilter = tileFilter ? !turf_boolean_within_default(tilePolygon, options.spatialFilter) : false;
+    const tileFilterCells = needsFilter ? new Set(geometryToCells2(tileFilter.geometry, cellResolution)) : null;
     const tileSortedCells = cellToChildrenSorted(parent, cellResolution);
     for (let i = 0; i < tileSortedCells.length; i++) {
-      if (intersection3 !== true && !intersection3.has(tileSortedCells[i])) {
+      if (needsFilter && !tileFilterCells.has(tileSortedCells[i])) {
         continue;
       }
       const cellData = {};
@@ -5688,16 +5638,21 @@ function normalizeSortByOptions({
   });
 }
 
+// src/widget-sources/constants.ts
+var OTHERS_CATEGORY_NAME = "_carto_others";
+
 // src/operations/groupBy.ts
 function groupValuesByColumn({
   data,
   valuesColumns,
   joinOperation,
   keysColumn,
-  operation: operation2
+  operation: operation2,
+  othersThreshold,
+  orderBy = "frequency_desc"
 }) {
   if (Array.isArray(data) && data.length === 0) {
-    return null;
+    return { rows: null };
   }
   const groups = data.reduce((accumulator, item) => {
     const group = item[keysColumn];
@@ -5712,13 +5667,44 @@ function groupValuesByColumn({
     return accumulator;
   }, /* @__PURE__ */ new Map());
   const targetOperation = aggregationFunctions[operation2];
-  if (targetOperation) {
-    return Array.from(groups).map(([name, value]) => ({
-      name,
-      value: targetOperation(value)
-    }));
+  if (!targetOperation) {
+    return { rows: [] };
+  }
+  const allCategories = Array.from(groups).map(([name, value]) => ({
+    name,
+    value: targetOperation(value)
+  })).sort(getSorter(orderBy));
+  if (othersThreshold && allCategories.length > othersThreshold) {
+    const otherValue = allCategories.slice(othersThreshold).flatMap(({ name }) => groups.get(name));
+    allCategories.push({
+      name: OTHERS_CATEGORY_NAME,
+      value: targetOperation(otherValue)
+    });
+    return {
+      rows: allCategories,
+      metadata: {
+        others: targetOperation(otherValue)
+      }
+    };
+  }
+  return {
+    rows: allCategories
+  };
+}
+function getSorter(orderBy) {
+  switch (orderBy) {
+    case "frequency_asc":
+      return (a, b) => a.value - b.value || localeCompare(a.name, b.name);
+    case "frequency_desc":
+      return (a, b) => b.value - a.value || localeCompare(a.name, b.name);
+    case "alphabetical_asc":
+      return (a, b) => localeCompare(a.name, b.name) || b.value - a.value;
+    case "alphabetical_desc":
+      return (a, b) => localeCompare(b.name, a.name) || b.value - a.value;
   }
-  return [];
+}
+function localeCompare(a, b) {
+  return (a ?? "null").localeCompare(b ?? "null");
 }
 
 // src/utils/dateUtils.ts
@@ -6248,7 +6234,7 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
   }
   _extractTileFeatures(spatialFilter) {
     const prevInputs = this._tileFeatureExtractPreviousInputs;
-    if (this._features.length && spatialFilterEquals(prevInputs.spatialFilter, spatialFilter)) {
+    if (this._features.length && prevInputs.spatialFilter && booleanEqual(prevInputs.spatialFilter, spatialFilter)) {
       return;
     }
     this._features = tileFeatures({
@@ -6337,7 +6323,10 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
     joinOperation,
     filters,
     filterOwner,
-    spatialFilter
+    spatialFilter,
+    othersThreshold,
+    orderBy = "frequency_desc",
+    rawResult
   }) {
     const filteredFeatures = this._getFilteredFeatures(
       spatialFilter,
@@ -6348,14 +6337,25 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
       return [];
     }
     assertColumn(this._features, column, operationColumn);
-    const groups = groupValuesByColumn({
+    const result = groupValuesByColumn({
       data: filteredFeatures,
       valuesColumns: normalizeColumns(operationColumn || column),
       joinOperation,
       keysColumn: column,
-      operation: operation2
+      operation: operation2,
+      othersThreshold,
+      orderBy
     });
-    return groups || [];
+    if (rawResult) {
+      return result;
+    }
+    if (!othersThreshold) {
+      return result?.rows || [];
+    }
+    return [
+      ...result?.rows || [],
+      { name: OTHERS_CATEGORY_NAME, value: result?.metadata?.others }
+    ];
   }
   async getScatter({
     xAxisColumn,
@@ -6488,6 +6488,7 @@ var WidgetTilesetSourceImpl = class extends WidgetSource {
    * INTERNAL
    */
   _getFilteredFeatures(spatialFilter, filters, filterOwner) {
+    assert(spatialFilter, "spatialFilter required for tilesets");
     this._extractTileFeatures(spatialFilter);
     return applyFilters(
       this._features,
@@ -6511,11 +6512,6 @@ 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/workers/widget-tileset-worker.ts
 var source;