@deck.gl/carto 8.9.25 → 8.9.27

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright Vis.gl contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/dist/cartoRasterTile-worker.js

@@ -1045,7 +1045,7 @@
   }
 
   // src/layers/schema/carto-raster-tile-loader.ts
-  var VERSION = true ? "8.9.25" : "latest";
+  var VERSION = true ? "8.9.27" : "latest";
   var id = "cartoRasterTile";
   var DEFAULT_OPTIONS = {
     cartoRasterTile: {
@@ -1062,7 +1062,7 @@
     category: "geometry",
     parse: async (arrayBuffer, options) => parseCartoRasterTile(arrayBuffer, options),
     parseSync: parseCartoRasterTile,
-    worker: false,
+    worker: true,
     options: DEFAULT_OPTIONS
   };
   function parseCartoRasterTile(arrayBuffer, options) {

package/dist/cartoSpatialTile-worker.js

@@ -1432,7 +1432,7 @@
   }
 
   // src/layers/schema/carto-spatial-tile-loader.ts
-  var VERSION = true ? "8.9.25" : "latest";
+  var VERSION = true ? "8.9.27" : "latest";
   var id = "cartoSpatialTile";
   var DEFAULT_OPTIONS = {
     cartoSpatialTile: {
@@ -1450,7 +1450,7 @@
     category: "geometry",
     parse: async (arrayBuffer, options) => parseCartoSpatialTile(arrayBuffer, options),
     parseSync: parseCartoSpatialTile,
-    worker: false,
+    worker: true,
     options: DEFAULT_OPTIONS
   };
   function parseCartoSpatialTile(arrayBuffer, options) {

package/dist/cartoVectorTile-worker.js

@@ -22,6 +22,471 @@
     mod
   ));
 
+  // ../../node_modules/earcut/src/earcut.js
+  var require_earcut = __commonJS({
+    "../../node_modules/earcut/src/earcut.js"(exports, module) {
+      "use strict";
+      module.exports = earcut2;
+      module.exports.default = earcut2;
+      function earcut2(data, holeIndices, dim) {
+        dim = dim || 2;
+        var hasHoles = holeIndices && holeIndices.length, outerLen = hasHoles ? holeIndices[0] * dim : data.length, outerNode = linkedList(data, 0, outerLen, dim, true), triangles = [];
+        if (!outerNode || outerNode.next === outerNode.prev)
+          return triangles;
+        var minX, minY, maxX, maxY, x, y, invSize;
+        if (hasHoles)
+          outerNode = eliminateHoles(data, holeIndices, outerNode, dim);
+        if (data.length > 80 * dim) {
+          minX = maxX = data[0];
+          minY = maxY = data[1];
+          for (var i = dim; i < outerLen; i += dim) {
+            x = data[i];
+            y = data[i + 1];
+            if (x < minX)
+              minX = x;
+            if (y < minY)
+              minY = y;
+            if (x > maxX)
+              maxX = x;
+            if (y > maxY)
+              maxY = y;
+          }
+          invSize = Math.max(maxX - minX, maxY - minY);
+          invSize = invSize !== 0 ? 1 / invSize : 0;
+        }
+        earcutLinked(outerNode, triangles, dim, minX, minY, invSize);
+        return triangles;
+      }
+      function linkedList(data, start, end, dim, clockwise) {
+        var i, last;
+        if (clockwise === signedArea(data, start, end, dim) > 0) {
+          for (i = start; i < end; i += dim)
+            last = insertNode(i, data[i], data[i + 1], last);
+        } else {
+          for (i = end - dim; i >= start; i -= dim)
+            last = insertNode(i, data[i], data[i + 1], last);
+        }
+        if (last && equals(last, last.next)) {
+          removeNode(last);
+          last = last.next;
+        }
+        return last;
+      }
+      function filterPoints(start, end) {
+        if (!start)
+          return start;
+        if (!end)
+          end = start;
+        var p = start, again;
+        do {
+          again = false;
+          if (!p.steiner && (equals(p, p.next) || area(p.prev, p, p.next) === 0)) {
+            removeNode(p);
+            p = end = p.prev;
+            if (p === p.next)
+              break;
+            again = true;
+          } else {
+            p = p.next;
+          }
+        } while (again || p !== end);
+        return end;
+      }
+      function earcutLinked(ear, triangles, dim, minX, minY, invSize, pass) {
+        if (!ear)
+          return;
+        if (!pass && invSize)
+          indexCurve(ear, minX, minY, invSize);
+        var stop = ear, prev, next;
+        while (ear.prev !== ear.next) {
+          prev = ear.prev;
+          next = ear.next;
+          if (invSize ? isEarHashed(ear, minX, minY, invSize) : isEar(ear)) {
+            triangles.push(prev.i / dim);
+            triangles.push(ear.i / dim);
+            triangles.push(next.i / dim);
+            removeNode(ear);
+            ear = next.next;
+            stop = next.next;
+            continue;
+          }
+          ear = next;
+          if (ear === stop) {
+            if (!pass) {
+              earcutLinked(filterPoints(ear), triangles, dim, minX, minY, invSize, 1);
+            } else if (pass === 1) {
+              ear = cureLocalIntersections(filterPoints(ear), triangles, dim);
+              earcutLinked(ear, triangles, dim, minX, minY, invSize, 2);
+            } else if (pass === 2) {
+              splitEarcut(ear, triangles, dim, minX, minY, invSize);
+            }
+            break;
+          }
+        }
+      }
+      function isEar(ear) {
+        var a = ear.prev, b = ear, c = ear.next;
+        if (area(a, b, c) >= 0)
+          return false;
+        var p = ear.next.next;
+        while (p !== ear.prev) {
+          if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+            return false;
+          p = p.next;
+        }
+        return true;
+      }
+      function isEarHashed(ear, minX, minY, invSize) {
+        var a = ear.prev, b = ear, c = ear.next;
+        if (area(a, b, c) >= 0)
+          return false;
+        var minTX = a.x < b.x ? a.x < c.x ? a.x : c.x : b.x < c.x ? b.x : c.x, minTY = a.y < b.y ? a.y < c.y ? a.y : c.y : b.y < c.y ? b.y : c.y, maxTX = a.x > b.x ? a.x > c.x ? a.x : c.x : b.x > c.x ? b.x : c.x, maxTY = a.y > b.y ? a.y > c.y ? a.y : c.y : b.y > c.y ? b.y : c.y;
+        var minZ = zOrder(minTX, minTY, minX, minY, invSize), maxZ = zOrder(maxTX, maxTY, minX, minY, invSize);
+        var p = ear.prevZ, n = ear.nextZ;
+        while (p && p.z >= minZ && n && n.z <= maxZ) {
+          if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+            return false;
+          p = p.prevZ;
+          if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+            return false;
+          n = n.nextZ;
+        }
+        while (p && p.z >= minZ) {
+          if (p !== ear.prev && p !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area(p.prev, p, p.next) >= 0)
+            return false;
+          p = p.prevZ;
+        }
+        while (n && n.z <= maxZ) {
+          if (n !== ear.prev && n !== ear.next && pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y) && area(n.prev, n, n.next) >= 0)
+            return false;
+          n = n.nextZ;
+        }
+        return true;
+      }
+      function cureLocalIntersections(start, triangles, dim) {
+        var p = start;
+        do {
+          var a = p.prev, b = p.next.next;
+          if (!equals(a, b) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+            triangles.push(a.i / dim);
+            triangles.push(p.i / dim);
+            triangles.push(b.i / dim);
+            removeNode(p);
+            removeNode(p.next);
+            p = start = b;
+          }
+          p = p.next;
+        } while (p !== start);
+        return filterPoints(p);
+      }
+      function splitEarcut(start, triangles, dim, minX, minY, invSize) {
+        var a = start;
+        do {
+          var b = a.next.next;
+          while (b !== a.prev) {
+            if (a.i !== b.i && isValidDiagonal(a, b)) {
+              var c = splitPolygon(a, b);
+              a = filterPoints(a, a.next);
+              c = filterPoints(c, c.next);
+              earcutLinked(a, triangles, dim, minX, minY, invSize);
+              earcutLinked(c, triangles, dim, minX, minY, invSize);
+              return;
+            }
+            b = b.next;
+          }
+          a = a.next;
+        } while (a !== start);
+      }
+      function eliminateHoles(data, holeIndices, outerNode, dim) {
+        var queue = [], i, len, start, end, list;
+        for (i = 0, len = holeIndices.length; i < len; i++) {
+          start = holeIndices[i] * dim;
+          end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+          list = linkedList(data, start, end, dim, false);
+          if (list === list.next)
+            list.steiner = true;
+          queue.push(getLeftmost(list));
+        }
+        queue.sort(compareX);
+        for (i = 0; i < queue.length; i++) {
+          eliminateHole(queue[i], outerNode);
+          outerNode = filterPoints(outerNode, outerNode.next);
+        }
+        return outerNode;
+      }
+      function compareX(a, b) {
+        return a.x - b.x;
+      }
+      function eliminateHole(hole, outerNode) {
+        outerNode = findHoleBridge(hole, outerNode);
+        if (outerNode) {
+          var b = splitPolygon(outerNode, hole);
+          filterPoints(b, b.next);
+        }
+      }
+      function findHoleBridge(hole, outerNode) {
+        var p = outerNode, hx = hole.x, hy = hole.y, qx = -Infinity, m;
+        do {
+          if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+            var x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+            if (x <= hx && x > qx) {
+              qx = x;
+              if (x === hx) {
+                if (hy === p.y)
+                  return p;
+                if (hy === p.next.y)
+                  return p.next;
+              }
+              m = p.x < p.next.x ? p : p.next;
+            }
+          }
+          p = p.next;
+        } while (p !== outerNode);
+        if (!m)
+          return null;
+        if (hx === qx)
+          return m;
+        var stop = m, mx = m.x, my = m.y, tanMin = Infinity, tan;
+        p = m;
+        do {
+          if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+            tan = Math.abs(hy - p.y) / (hx - p.x);
+            if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+              m = p;
+              tanMin = tan;
+            }
+          }
+          p = p.next;
+        } while (p !== stop);
+        return m;
+      }
+      function sectorContainsSector(m, p) {
+        return area(m.prev, m, p.prev) < 0 && area(p.next, m, m.next) < 0;
+      }
+      function indexCurve(start, minX, minY, invSize) {
+        var p = start;
+        do {
+          if (p.z === null)
+            p.z = zOrder(p.x, p.y, minX, minY, invSize);
+          p.prevZ = p.prev;
+          p.nextZ = p.next;
+          p = p.next;
+        } while (p !== start);
+        p.prevZ.nextZ = null;
+        p.prevZ = null;
+        sortLinked(p);
+      }
+      function sortLinked(list) {
+        var i, p, q, e, tail, numMerges, pSize, qSize, inSize = 1;
+        do {
+          p = list;
+          list = null;
+          tail = null;
+          numMerges = 0;
+          while (p) {
+            numMerges++;
+            q = p;
+            pSize = 0;
+            for (i = 0; i < inSize; i++) {
+              pSize++;
+              q = q.nextZ;
+              if (!q)
+                break;
+            }
+            qSize = inSize;
+            while (pSize > 0 || qSize > 0 && q) {
+              if (pSize !== 0 && (qSize === 0 || !q || p.z <= q.z)) {
+                e = p;
+                p = p.nextZ;
+                pSize--;
+              } else {
+                e = q;
+                q = q.nextZ;
+                qSize--;
+              }
+              if (tail)
+                tail.nextZ = e;
+              else
+                list = e;
+              e.prevZ = tail;
+              tail = e;
+            }
+            p = q;
+          }
+          tail.nextZ = null;
+          inSize *= 2;
+        } while (numMerges > 1);
+        return list;
+      }
+      function zOrder(x, y, minX, minY, invSize) {
+        x = 32767 * (x - minX) * invSize;
+        y = 32767 * (y - minY) * invSize;
+        x = (x | x << 8) & 16711935;
+        x = (x | x << 4) & 252645135;
+        x = (x | x << 2) & 858993459;
+        x = (x | x << 1) & 1431655765;
+        y = (y | y << 8) & 16711935;
+        y = (y | y << 4) & 252645135;
+        y = (y | y << 2) & 858993459;
+        y = (y | y << 1) & 1431655765;
+        return x | y << 1;
+      }
+      function getLeftmost(start) {
+        var p = start, leftmost = start;
+        do {
+          if (p.x < leftmost.x || p.x === leftmost.x && p.y < leftmost.y)
+            leftmost = p;
+          p = p.next;
+        } while (p !== start);
+        return leftmost;
+      }
+      function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+        return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 && (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 && (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
+      }
+      function isValidDiagonal(a, b) {
+        return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && (locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && (area(a.prev, a, b.prev) || area(a, b.prev, b)) || equals(a, b) && area(a.prev, a, a.next) > 0 && area(b.prev, b, b.next) > 0);
+      }
+      function area(p, q, r) {
+        return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
+      }
+      function equals(p1, p2) {
+        return p1.x === p2.x && p1.y === p2.y;
+      }
+      function intersects(p1, q1, p2, q2) {
+        var o1 = sign(area(p1, q1, p2));
+        var o2 = sign(area(p1, q1, q2));
+        var o3 = sign(area(p2, q2, p1));
+        var o4 = sign(area(p2, q2, q1));
+        if (o1 !== o2 && o3 !== o4)
+          return true;
+        if (o1 === 0 && onSegment(p1, p2, q1))
+          return true;
+        if (o2 === 0 && onSegment(p1, q2, q1))
+          return true;
+        if (o3 === 0 && onSegment(p2, p1, q2))
+          return true;
+        if (o4 === 0 && onSegment(p2, q1, q2))
+          return true;
+        return false;
+      }
+      function onSegment(p, q, r) {
+        return q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) && q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y);
+      }
+      function sign(num) {
+        return num > 0 ? 1 : num < 0 ? -1 : 0;
+      }
+      function intersectsPolygon(a, b) {
+        var p = a;
+        do {
+          if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b))
+            return true;
+          p = p.next;
+        } while (p !== a);
+        return false;
+      }
+      function locallyInside(a, b) {
+        return area(a.prev, a, a.next) < 0 ? area(a, b, a.next) >= 0 && area(a, a.prev, b) >= 0 : area(a, b, a.prev) < 0 || area(a, a.next, b) < 0;
+      }
+      function middleInside(a, b) {
+        var p = a, inside = false, px = (a.x + b.x) / 2, py = (a.y + b.y) / 2;
+        do {
+          if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)
+            inside = !inside;
+          p = p.next;
+        } while (p !== a);
+        return inside;
+      }
+      function splitPolygon(a, b) {
+        var a2 = new Node(a.i, a.x, a.y), b2 = new Node(b.i, b.x, b.y), an = a.next, bp = b.prev;
+        a.next = b;
+        b.prev = a;
+        a2.next = an;
+        an.prev = a2;
+        b2.next = a2;
+        a2.prev = b2;
+        bp.next = b2;
+        b2.prev = bp;
+        return b2;
+      }
+      function insertNode(i, x, y, last) {
+        var p = new Node(i, x, y);
+        if (!last) {
+          p.prev = p;
+          p.next = p;
+        } else {
+          p.next = last.next;
+          p.prev = last;
+          last.next.prev = p;
+          last.next = p;
+        }
+        return p;
+      }
+      function removeNode(p) {
+        p.next.prev = p.prev;
+        p.prev.next = p.next;
+        if (p.prevZ)
+          p.prevZ.nextZ = p.nextZ;
+        if (p.nextZ)
+          p.nextZ.prevZ = p.prevZ;
+      }
+      function Node(i, x, y) {
+        this.i = i;
+        this.x = x;
+        this.y = y;
+        this.prev = null;
+        this.next = null;
+        this.z = null;
+        this.prevZ = null;
+        this.nextZ = null;
+        this.steiner = false;
+      }
+      earcut2.deviation = function(data, holeIndices, dim, triangles) {
+        var hasHoles = holeIndices && holeIndices.length;
+        var outerLen = hasHoles ? holeIndices[0] * dim : data.length;
+        var polygonArea = Math.abs(signedArea(data, 0, outerLen, dim));
+        if (hasHoles) {
+          for (var i = 0, len = holeIndices.length; i < len; i++) {
+            var start = holeIndices[i] * dim;
+            var end = i < len - 1 ? holeIndices[i + 1] * dim : data.length;
+            polygonArea -= Math.abs(signedArea(data, start, end, dim));
+          }
+        }
+        var trianglesArea = 0;
+        for (i = 0; i < triangles.length; i += 3) {
+          var a = triangles[i] * dim;
+          var b = triangles[i + 1] * dim;
+          var c = triangles[i + 2] * dim;
+          trianglesArea += Math.abs(
+            (data[a] - data[c]) * (data[b + 1] - data[a + 1]) - (data[a] - data[b]) * (data[c + 1] - data[a + 1])
+          );
+        }
+        return polygonArea === 0 && trianglesArea === 0 ? 0 : Math.abs((trianglesArea - polygonArea) / polygonArea);
+      };
+      function signedArea(data, start, end, dim) {
+        var sum = 0;
+        for (var i = start, j = end - dim; i < end; i += dim) {
+          sum += (data[j] - data[i]) * (data[i + 1] + data[j + 1]);
+          j = i;
+        }
+        return sum;
+      }
+      earcut2.flatten = function(data) {
+        var dim = data[0][0].length, result = { vertices: [], holes: [], dimensions: dim }, holeIndex = 0;
+        for (var i = 0; i < data.length; i++) {
+          for (var j = 0; j < data[i].length; j++) {
+            for (var d = 0; d < dim; d++)
+              result.vertices.push(data[i][j][d]);
+          }
+          if (i > 0) {
+            holeIndex += data[i - 1].length;
+            result.holes.push(holeIndex);
+          }
+        }
+        return result;
+      };
+    }
+  });
+
   // ../../node_modules/pbf/node_modules/ieee754/index.js
   var require_ieee754 = __commonJS({
     "../../node_modules/pbf/node_modules/ieee754/index.js"(exports) {
@@ -977,6 +1442,9 @@
     }, context, loader);
   }
 
+  // src/layers/schema/carto-vector-tile-loader.ts
+  var import_earcut = __toESM(require_earcut());
+
   // src/layers/schema/fast-pbf.ts
   function readPackedTypedArray(TypedArray, pbf, obj) {
     const end = pbf.type === 2 ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
@@ -1194,7 +1662,7 @@
   }
 
   // src/layers/schema/carto-vector-tile-loader.ts
-  var VERSION = true ? "8.9.25" : "latest";
+  var VERSION = true ? "8.9.27" : "latest";
   var id = "cartoVectorTile";
   var DEFAULT_OPTIONS = {
     cartoVectorTile: {
@@ -1211,13 +1679,45 @@
     category: "geometry",
     parse: async (arrayBuffer, options) => parseCartoVectorTile(arrayBuffer, options),
     parseSync: parseCartoVectorTile,
-    worker: false,
+    worker: true,
     options: DEFAULT_OPTIONS
   };
+  function triangulatePolygon(polygons, target, {
+    startPosition,
+    endPosition,
+    indices
+  }) {
+    const coordLength = polygons.positions.size;
+    const start = startPosition * coordLength;
+    const end = endPosition * coordLength;
+    const polygonPositions = polygons.positions.value.subarray(start, end);
+    const holes = indices.slice(1).map((n) => n - startPosition);
+    const triangles = (0, import_earcut.default)(polygonPositions, holes, coordLength);
+    for (let t = 0, tl = triangles.length; t < tl; ++t) {
+      target.push(startPosition + triangles[t]);
+    }
+  }
+  function triangulate(polygons) {
+    const { polygonIndices, positions, primitivePolygonIndices } = polygons;
+    const triangles = [];
+    let rangeStart = 0;
+    for (let i = 0; i < polygonIndices.value.length - 1; i++) {
+      const startPosition = polygonIndices.value[i];
+      const endPosition = polygonIndices.value[i + 1];
+      const rangeEnd = primitivePolygonIndices.value.indexOf(endPosition);
+      const indices = primitivePolygonIndices.value.subarray(rangeStart, rangeEnd);
+      rangeStart = rangeEnd;
+      triangulatePolygon(polygons, triangles, { startPosition, endPosition, indices });
+    }
+    polygons.triangles = { value: new Uint32Array(triangles), size: 1 };
+  }
   function parseCartoVectorTile(arrayBuffer, options) {
     if (!arrayBuffer)
       return null;
     const tile = parsePbf(arrayBuffer, TileReader);
+    if (tile.polygons && !tile.polygons.triangles) {
+      triangulate(tile.polygons);
+    }
     return tile;
   }
   var carto_vector_tile_loader_default = CartoVectorTileLoader;