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

package/build/worker-compat.js

@@ -5452,8 +5452,8 @@
     }
     if (ring && y === ring[0][1]) ring.pop();
   }
-  function appendHashTiles(hash2, tiles2) {
-    var keys = Object.keys(hash2);
+  function appendHashTiles(hash, tiles2) {
+    var keys = Object.keys(hash);
     for (var i = 0; i < keys.length; i++) {
       tiles2.push(fromID(+keys[i]));
     }
@@ -5468,6 +5468,26 @@
   }
   var B2 = [0x5555555555555555n, 0x3333333333333333n, 0x0f0f0f0f0f0f0f0fn, 0x00ff00ff00ff00ffn, 0x0000ffff0000ffffn, 0x00000000ffffffffn];
   var S = [0n, 1n, 2n, 4n, 8n, 16n];
+  var TILE_SIZE2 = 512;
+  function cellToOffset(quadbin) {
+    const {
+      x,
+      y,
+      z
+    } = cellToTile(quadbin);
+    const scale2 = TILE_SIZE2 / (1 << z);
+    return [x * scale2, TILE_SIZE2 - y * scale2, scale2];
+  }
+  function cellToWorldBounds(quadbin, coverage) {
+    const [xOffset, yOffset, scale2] = cellToOffset(quadbin);
+    return [[xOffset, yOffset], [xOffset + coverage * scale2, yOffset - coverage * scale2]];
+  }
+  function getCellPolygon(quadbin, coverage = 1) {
+    const [topLeft, bottomRight] = cellToWorldBounds(quadbin, coverage);
+    const [w, n] = worldToLngLat(topLeft);
+    const [e, s] = worldToLngLat(bottomRight);
+    return [e, n, e, s, w, s, w, n, e, n];
+  }
   function tileToCell(tile) {
     if (tile.z < 0 || tile.z > 26) {
       throw new Error("Wrong zoom");
@@ -5540,6 +5560,14 @@
       z
     }));
   }
+  function cellToBoundary(cell) {
+    const bbox2 = getCellPolygon(cell);
+    const boundary = [[bbox2[0], bbox2[1]], [bbox2[2], bbox2[3]], [bbox2[4], bbox2[5]], [bbox2[6], bbox2[7]], [bbox2[0], bbox2[1]]];
+    return {
+      type: "Polygon",
+      coordinates: [boundary]
+    };
+  }
 
   // node_modules/@turf/bbox-clip/dist/esm/index.js
   function lineclip(points, bbox2, result) {
@@ -19756,62 +19784,6 @@
   var DEFAULT_AGGREGATION_EXP_ALIAS = "__aggregationValue";
   var DEFAULT_AGGREGATION_EXP = `1 AS ${DEFAULT_AGGREGATION_EXP_ALIAS}`;
 
-  // 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;
-  }
-
   // src/filters/tileFeaturesRaster.ts
   function tileFeaturesRaster({
     tiles: tiles2,
@@ -19826,15 +19798,20 @@
     const tileResolution = getResolution(tiles2[0].index.q);
     const tileBlockSize = tiles2[0].data.blockSize;
     const cellResolution = tileResolution + BigInt(Math.log2(tileBlockSize));
-    const spatialFilterCells = new CellSet(
-      geometryToCells(options.spatialFilter, cellResolution)
-    );
     const data = /* @__PURE__ */ new Map();
     for (const tile of tiles2) {
       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 tilePolygon = cellToBoundary(parent);
+      const tileFilter = turf_intersect_default(
+        featureCollection([feature(tilePolygon), feature(options.spatialFilter)])
+      );
+      const needsFilter = tileFilter ? !turf_boolean_within_default(tilePolygon, options.spatialFilter) : false;
+      const tileFilterCells = needsFilter ? new Set(geometryToCells(tileFilter.geometry, cellResolution)) : null;
+      const tileSortedCells = cellToChildrenSorted(parent, cellResolution);
+      for (let i = 0; i < tileSortedCells.length; i++) {
+        if (needsFilter && !tileFilterCells.has(tileSortedCells[i])) {
+          continue;
+        }
         const cellData = {};
         let cellDataExists = false;
         for (const band in tile.data.cells.numericProps) {
@@ -19846,7 +19823,7 @@
           }
         }
         if (cellDataExists) {
-          data.set(children[i], cellData);
+          data.set(tileSortedCells[i], cellData);
         }
       }
     }