@maplibre/geojson-vt 6.0.4 → 6.0.5

package/dist/geojson-vt.mjs

@@ -95,27 +95,35 @@ function createFeature(id, type, geom, tags) {
     switch (data.type) {
         case 'Point':
         case 'MultiPoint':
-        case 'LineString':
             calcLineBBox(feature, data.geom);
             break;
+        case 'LineString':
+            calcLineBBox(feature, data.geom.points);
+            break;
         case 'Polygon':
             // the outer ring (ie [0]) contains all inner rings
-            calcLineBBox(feature, data.geom[0]);
+            calcLineBBox(feature, data.geom[0].points);
             break;
         case 'MultiLineString':
             for (const line of data.geom) {
-                calcLineBBox(feature, line);
+                calcLineBBox(feature, line.points);
             }
             break;
         case 'MultiPolygon':
             for (const polygon of data.geom) {
                 // the outer ring (ie [0]) contains all inner rings
-                calcLineBBox(feature, polygon[0]);
+                calcLineBBox(feature, polygon[0].points);
             }
             break;
     }
     return feature;
 }
+function optimizeLineMemory(line) {
+    const lineImmutable = line;
+    if (line.points.length > 64) {
+        lineImmutable.points = new Float64Array(line.points);
+    }
+}
 function calcLineBBox(feature, geom) {
     for (let i = 0; i < geom.length; i += 3) {
         feature.minX = Math.min(feature.minX, geom[i]);
@@ -213,7 +221,7 @@ function convertMultiPointFeature(features, id, geom, properties) {
     features.push(createFeature(id, 'MultiPoint', out, properties));
 }
 function convertLineStringFeature(features, id, geom, tolerance, properties) {
-    const out = [];
+    const out = { points: [] };
     convertLine(geom.coordinates, out, tolerance, false);
     features.push(createFeature(id, 'LineString', out, properties));
 }
@@ -221,7 +229,7 @@ function convertMultiLineStringFeature(features, id, geom, tolerance, options, p
     if (options.lineMetrics) {
         // explode into linestrings to be able to track metrics
         for (const line of geom.coordinates) {
-            const out = [];
+            const out = { points: [] };
             convertLine(line, out, tolerance, false);
             features.push(createFeature(id, 'LineString', out, properties));
         }
@@ -252,7 +260,7 @@ function convertLine(ring, out, tolerance, isPolygon) {
     for (let j = 0; j < ring.length; j++) {
         const x = projectX(ring[j][0]);
         const y = projectY(ring[j][1]);
-        out.push(x, y, 0);
+        out.points.push(x, y, 0);
         if (j > 0) {
             if (isPolygon) {
                 size += (x0 * y - x * y0) / 2; // area
@@ -264,18 +272,19 @@ function convertLine(ring, out, tolerance, isPolygon) {
         x0 = x;
         y0 = y;
     }
-    const last = out.length - 3;
-    out[2] = 1;
+    const last = out.points.length - 3;
+    out.points[2] = 1;
     if (tolerance > 0)
-        simplify(out, 0, last, tolerance);
-    out[last + 2] = 1;
+        simplify(out.points, 0, last, tolerance);
+    out.points[last + 2] = 1;
+    optimizeLineMemory(out);
     out.size = Math.abs(size);
     out.start = 0;
     out.end = out.size;
 }
 function convertLines(rings, out, tolerance, isPolygon) {
     for (let i = 0; i < rings.length; i++) {
-        const geom = [];
+        const geom = { points: [] };
         convertLine(rings[i], geom, tolerance, isPolygon);
         out.push(geom);
     }
@@ -331,21 +340,25 @@ function geometryToGeoJSON(feature) {
                 coordinates: unprojectPoint(geometry[0], geometry[1])
             };
         case 'MultiPoint':
-        case 'LineString':
             return {
                 type: type,
                 coordinates: unprojectPoints(geometry)
             };
+        case 'LineString':
+            return {
+                type: type,
+                coordinates: unprojectPoints(geometry.points)
+            };
         case 'MultiLineString':
         case 'Polygon':
             return {
                 type: type,
-                coordinates: geometry.map(ring => unprojectPoints(ring))
+                coordinates: geometry.map(ring => unprojectPoints(ring.points))
             };
         case 'MultiPolygon':
             return {
                 type: type,
-                coordinates: geometry.map(polygon => polygon.map(ring => unprojectPoints(ring)))
+                coordinates: geometry.map(polygon => polygon.map(ring => unprojectPoints(ring.points)))
             };
     }
 }
@@ -510,12 +523,12 @@ function clipLine(geom, newGeom, start, end, axis, isPolygon, trackMetrics) {
     const intersect = axis === AxisType.X ? intersectX : intersectY;
     let len = geom.start;
     let segLen, t;
-    for (let i = 0; i < geom.length - 3; i += 3) {
-        const ax = geom[i];
-        const ay = geom[i + 1];
-        const az = geom[i + 2];
-        const bx = geom[i + 3];
-        const by = geom[i + 4];
+    for (let i = 0; i < geom.points.length - 3; i += 3) {
+        const ax = geom.points[i];
+        const ay = geom.points[i + 1];
+        const az = geom.points[i + 2];
+        const bx = geom.points[i + 3];
+        const by = geom.points[i + 4];
         const a = axis === AxisType.X ? ax : ay;
         const b = axis === AxisType.X ? bx : by;
         let exited = false;
@@ -538,7 +551,7 @@ function clipLine(geom, newGeom, start, end, axis, isPolygon, trackMetrics) {
             }
         }
         else {
-            addPoint(slice, ax, ay, az);
+            addPoint(slice.points, ax, ay, az);
         }
         if (b < start && a >= start) {
             // <--|---  | or <--|-----|--- (line exits the clip region on the left)
@@ -560,29 +573,31 @@ function clipLine(geom, newGeom, start, end, axis, isPolygon, trackMetrics) {
             len += segLen;
     }
     // add the last point
-    let last = geom.length - 3;
-    const ax = geom[last];
-    const ay = geom[last + 1];
-    const az = geom[last + 2];
+    let last = geom.points.length - 3;
+    const ax = geom.points[last];
+    const ay = geom.points[last + 1];
+    const az = geom.points[last + 2];
     const a = axis === AxisType.X ? ax : ay;
     if (a >= start && a <= end)
-        addPoint(slice, ax, ay, az);
+        addPoint(slice.points, ax, ay, az);
     // close the polygon if its endpoints are not the same after clipping
-    last = slice.length - 3;
-    if (isPolygon && last >= 3 && (slice[last] !== slice[0] || slice[last + 1] !== slice[1])) {
-        addPoint(slice, slice[0], slice[1], slice[2]);
+    last = slice.points.length - 3;
+    if (isPolygon && last >= 3 && (slice.points[last] !== slice.points[0] || slice.points[last + 1] !== slice.points[1])) {
+        addPoint(slice.points, slice.points[0], slice.points[1], slice.points[2]);
     }
     // add the final slice
-    if (slice.length) {
+    if (slice.points.length) {
+        optimizeLineMemory(slice);
         newGeom.push(slice);
     }
 }
 function newSlice(line) {
-    const slice = [];
-    slice.size = line.size;
-    slice.start = line.start;
-    slice.end = line.end;
-    return slice;
+    return {
+        points: [],
+        size: line.size,
+        start: line.start,
+        end: line.end
+    };
 }
 function clipLines(geom, newGeom, start, end, axis, isPolygon) {
     for (const line of geom) {
@@ -594,12 +609,12 @@ function addPoint(out, x, y, z) {
 }
 function intersectX(out, ax, ay, bx, by, x) {
     const t = (x - ax) / (bx - ax);
-    addPoint(out, x, ay + (by - ay) * t, 1);
+    addPoint(out.points, x, ay + (by - ay) * t, 1);
     return t;
 }
 function intersectY(out, ax, ay, bx, by, y) {
     const t = (y - ay) / (by - ay);
-    addPoint(out, ax + (bx - ax) * t, y, 1);
+    addPoint(out.points, ax + (bx - ax) * t, y, 1);
     return t;
 }
 
@@ -622,9 +637,13 @@ function shiftFeatureCoords(features, offset) {
     for (const feature of features) {
         switch (feature.type) {
             case 'Point':
-            case 'MultiPoint':
+            case 'MultiPoint': {
+                const newGeometry = shiftPointCoords(feature.geometry, offset);
+                newFeatures.push(createFeature(feature.id, feature.type, newGeometry, feature.tags));
+                continue;
+            }
             case 'LineString': {
-                const newGeometry = shiftCoords(feature.geometry, offset);
+                const newGeometry = shiftLineCoords(feature.geometry, offset);
                 newFeatures.push(createFeature(feature.id, feature.type, newGeometry, feature.tags));
                 continue;
             }
@@ -632,7 +651,7 @@ function shiftFeatureCoords(features, offset) {
             case 'Polygon': {
                 const newGeometry = [];
                 for (const line of feature.geometry) {
-                    newGeometry.push(shiftCoords(line, offset));
+                    newGeometry.push(shiftLineCoords(line, offset));
                 }
                 newFeatures.push(createFeature(feature.id, feature.type, newGeometry, feature.tags));
                 continue;
@@ -642,7 +661,7 @@ function shiftFeatureCoords(features, offset) {
                 for (const polygon of feature.geometry) {
                     const newPolygon = [];
                     for (const line of polygon) {
-                        newPolygon.push(shiftCoords(line, offset));
+                        newPolygon.push(shiftLineCoords(line, offset));
                     }
                     newGeometry.push(newPolygon);
                 }
@@ -653,17 +672,27 @@ function shiftFeatureCoords(features, offset) {
     }
     return newFeatures;
 }
-function shiftCoords(points, offset) {
-    const newPoints = [];
-    newPoints.size = points.size;
-    if (points.start !== undefined) {
-        newPoints.start = points.start;
-        newPoints.end = points.end;
+function shiftPointCoords(coords, offset) {
+    const newCoords = [];
+    for (let i = 0; i < coords.length; i += 3) {
+        newCoords.push(coords[i] + offset, coords[i + 1], coords[i + 2]);
     }
-    for (let i = 0; i < points.length; i += 3) {
-        newPoints.push(points[i] + offset, points[i + 1], points[i + 2]);
+    return newCoords;
+}
+function shiftLineCoords(line, offset) {
+    const newLine = {
+        points: [],
+        size: line.size
+    };
+    if (line.start !== undefined) {
+        newLine.start = line.start;
+        newLine.end = line.end;
     }
-    return newPoints;
+    for (let i = 0; i < line.points.length; i += 3) {
+        newLine.points.push(line.points[i] + offset, line.points[i + 1], line.points[i + 2]);
+    }
+    optimizeLineMemory(newLine);
+    return newLine;
 }
 
 /**
@@ -675,7 +704,7 @@ function shiftCoords(points, offset) {
  */
 function applySourceDiff(source, dataDiff, options) {
     // convert diff to sets/maps for o(1) lookups
-    const diff = diffToHashed(dataDiff);
+    const diff = diffToHashed(dataDiff, options);
     // collection for features that will be affected by this update and used to invalidate tiles
     let affected = [];
     if (diff.removeAll) {
@@ -786,7 +815,7 @@ function applyPropertyUpdates(tags, update) {
 /**
  * Convert a GeoJSON Source Diff to an idempotent hashed representation using Sets and Maps
  */
-function diffToHashed(diff) {
+function diffToHashed(diff, options) {
     if (!diff)
         return {
             remove: new Set(),
@@ -796,7 +825,7 @@ function diffToHashed(diff) {
     const hashed = {
         removeAll: diff.removeAll,
         remove: new Set(diff.remove || []),
-        add: new Map(diff.add?.map(feature => [feature.id, feature])),
+        add: new Map(diff.add?.map(feature => [options.promoteId ? feature.properties[options.promoteId] : feature.id, feature])),
         update: new Map(diff.update?.map(update => [update.id, update]))
     };
     return hashed;
@@ -1374,14 +1403,14 @@ function addMultiPolygonTileFeature(tile, feature, tolerance) {
 function addLine(result, geom, tile, tolerance, isPolygon, isOuter) {
     const sqTolerance = tolerance * tolerance;
     if (tolerance > 0 && (geom.size < (isPolygon ? sqTolerance : tolerance))) {
-        tile.numPoints += geom.length / 3;
+        tile.numPoints += geom.points.length / 3;
         return;
     }
     const ring = [];
-    for (let i = 0; i < geom.length; i += 3) {
-        if (tolerance === 0 || geom[i + 2] > sqTolerance) {
+    for (let i = 0; i < geom.points.length; i += 3) {
+        if (tolerance === 0 || geom.points[i + 2] > sqTolerance) {
             tile.numSimplified++;
-            ring.push(geom[i], geom[i + 1]);
+            ring.push(geom.points[i], geom.points[i + 1]);
         }
         tile.numPoints++;
     }