mapshaper 0.7.10 → 0.7.12

package/mapshaper.js

@@ -17021,7 +17021,8 @@
     var groups = groupPolygonRings(obj.pathData, arcs, opts.invert_y);
     // invert_y is used internally for SVG generation
     // mapshaper's internal winding order is the opposite of RFC 7946
-    var reverse = opts.rfc7946 && !opts.invert_y;
+    var rfc7946 = opts.rfc7946 === true;
+    var reverse = rfc7946 !== !!opts.reverse_winding && !opts.invert_y;
     var coords = groups.map(function(paths) {
       return paths.map(function(path) {
         if (reverse) path.points.reverse();
@@ -26408,37 +26409,25 @@ ${svg}
   async function loadZstdLib() {
     var mod;
     if (runningInBrowser()) {
-      mod = require$1('zstd-codec');
+      mod = require$1('@bokuweb/zstd-wasm');
     } else {
       if (!zstdPromise) {
-        zstdPromise = dynamicImportModule$1('zstd-codec');
+        zstdPromise = dynamicImportModule$1('@bokuweb/zstd-wasm');
       }
       mod = await zstdPromise;
     }
-    if (mod && mod.default && !mod.ZstdCodec) {
+    if (mod && mod.default && !mod.compress) {
       mod = mod.default;
     }
-    if (!mod || !mod.ZstdCodec || typeof mod.ZstdCodec.run != 'function') {
+    if (!mod || typeof mod.init != 'function' || typeof mod.compress != 'function') {
       stop$1('GeoParquet ZSTD compressor is not loaded');
     }
-    return initZstdCodec(mod.ZstdCodec);
+    await mod.init();
+    return initZstdCodec(mod);
   }
 
   function initZstdCodec(codec) {
-    return new Promise(function(resolve, reject) {
-      try {
-        codec.run(function(zstd) {
-          var simple = new zstd.Simple();
-          resolve({
-            compress: function(bytes, level) {
-              return simple.compress(bytes, level);
-            }
-          });
-        });
-      } catch (e) {
-        reject(e);
-      }
-    });
+    return codec;
   }
 
   function getOutputFormat(dataset, opts) {
@@ -29145,6 +29134,10 @@ ${svg}
         describe: '[GeoJSON] use original GeoJSON spec (not RFC 7946)',
         type: 'flag'
       })
+      .option('reverse-winding', {
+        describe: '[GeoJSON] reverse polygon winding order',
+        type: 'flag'
+      })
       .option('rfc7946', {
         // dummy option so old commands do not break
         type: 'flag'
@@ -34623,8 +34616,8 @@ ${svg}
     var candidates = getGeoParquetCrsStrings(crs);
     for (var i = 0; i < candidates.length; i++) {
       try {
-        parseCrsString$1(candidates[i]);
         await initProjLibrary({crs: candidates[i]});
+        parseCrsString$1(candidates[i]);
         return candidates[i];
       } catch (e) {
         // Keep trying candidates; if none initialize, caller will warn.
@@ -48771,7 +48764,7 @@ ${svg}
       return layerHasGeometry(lyr) && !layerIsFullyEnclosed(lyr, dataset, clipData);
     });
     if (layers.length > 0) {
-      clipLayersInPlace(layers, clipData, dataset, 'clip');
+      clipLayersInPlace(layers, clipData, dataset, 'clip', getInternalClipOpts());
       return true;
     }
     return false;
@@ -48810,13 +48803,21 @@ ${svg}
   }
 
   function datasetCrossesLon(dataset, lon) {
-    var crosses = 0;
-    dataset.arcs.forEachSegment(function(i, j, xx, yy) {
-      var ax = xx[i],
-          bx = xx[j];
-      if (ax <= lon && bx >= lon || ax >= lon && bx <= lon) crosses++;
+    var crosses = false;
+    dataset.layers.filter(layerHasPaths).forEach(function(lyr) {
+      if (crosses) return;
+      lyr.shapes.forEach(function(shp) {
+        if (crosses || !shp) return;
+        forEachSegmentInShape(shp, dataset.arcs, function(i, j, xx, yy) {
+          var ax = xx[i],
+              bx = xx[j];
+          if (ax <= lon && bx >= lon || ax >= lon && bx <= lon) {
+            crosses = true;
+          }
+        });
+      });
     });
-    return crosses > 0;
+    return crosses;
   }
 
   function insertVerticalCut(dataset, lon) {
@@ -48827,29 +48828,38 @@ ${svg}
     // densify (so cut line can curve, e.g. Cupola projection)
     var geojson = bboxToPolygon(bbox, {interval: 0.5});
     var clip = importGeoJSON(geojson);
-    clipLayersInPlace(pathLayers, clip, dataset, 'erase');
+    clipLayersInPlace(pathLayers, clip, dataset, 'erase', getInternalClipOpts());
+  }
+
+  function getInternalClipOpts() {
+    return {no_cleanup: true, no_warn: true};
   }
 
-  // Converts a Proj.4 projection name (e.g. lcc, tmerc) to a Proj.4 string
+  // Converts a Proj.4 projection name (e.g. lcc, tmerc, utm) to a Proj.4 string
   // by picking parameters that are appropriate to the extent of the dataset
   // being projected (e.g. standard parallels, longitude of origin)
-  // Works for lcc, aea, tmerc, etc.
+  // Works for lcc, aea, tmerc, utm, etc.
   // TODO: add more projections
   //
   function expandProjDefn(str, dataset, targetLayers) {
     var mproj = require$1('mproj');
-    var proj4, params, bbox, isConic2SP, isCentered, decimals;
+    var proj4, params, bbox, isConic2SP, isCentered, isUtm, decimals;
     if (str in mproj.internal.pj_list === false) {
       // not a bare projection code -- assume valid projection string in other format
       return str;
     }
     isConic2SP = ['lcc', 'aea'].includes(str);
     isCentered = ['tmerc', 'etmerc'].includes(str);
+    isUtm = str == 'utm';
     proj4 = '+proj=' + str;
-    if (isConic2SP || isCentered) {
+    if (isConic2SP || isCentered || isUtm) {
       bbox = getBBox(dataset, targetLayers); // TODO: support projected datasets
       decimals = getBoundsPrecisionForDisplay(bbox);
-      params = isCentered ? getCenterParams(bbox, decimals) : getConicParams(bbox, decimals);
+      if (isUtm) {
+        params = getUtmParams(bbox);
+      } else {
+        params = isCentered ? getCenterParams(bbox, decimals) : getConicParams(bbox, decimals);
+      }
       proj4 += ' ' + params;
       message(`Converted "${str}" to "${proj4}"`);
     }
@@ -48865,7 +48875,77 @@ ${svg}
     if (!isLatLngCRS(getDatasetCRS(dataset))) {
       stop$1('Expected unprojected data');
     }
-    return getDatasetBounds(source).toArray();
+    return getAutoFitBBox(source);
+  }
+
+  function getAutoFitBBox(dataset) {
+    var bbox = getDatasetBounds(dataset).toArray();
+    if (bbox[2] - bbox[0] > 180) {
+      bbox = getWrappedBBox(dataset, bbox) || bbox;
+    }
+    return bbox;
+  }
+
+  function getWrappedBBox(dataset, bbox) {
+    var xmaxW = -Infinity,
+        xminE = Infinity, xmaxE = -Infinity,
+        ymin = bbox[1], ymax = bbox[3],
+        gap;
+
+    // Detect dateline clustering with a streaming east/west split. The gap
+    // between the two boxes can only shrink as more coordinates are scanned.
+    forEachDatasetCoord(dataset, function(x) {
+      if (x < 0) {
+        if (x > xmaxW) xmaxW = x;
+      } else {
+        if (x < xminE) xminE = x;
+        if (x > xmaxE) xmaxE = x;
+      }
+      if (xmaxW > -Infinity && xmaxE > -Infinity) {
+        gap = xminE - xmaxW;
+        return gap > 180;
+      }
+    });
+
+    if (xmaxW == -Infinity || xmaxE == -Infinity) return null;
+    if (xminE - xmaxW <= 180) return null;
+    return [xminE, ymin, xmaxW + 360, ymax];
+  }
+
+  function forEachDatasetCoord(dataset, cb) {
+    var arcs = dataset.arcs;
+    var usedArcs = arcs ? new Uint8Array(arcs.size()) : null;
+    var keepGoing = true;
+    dataset.layers.forEach(function(lyr) {
+      if (!keepGoing) return;
+      if (lyr.geometry_type == 'point') {
+        keepGoing = scanPointCoords(lyr.shapes, cb);
+      } else if (arcs && (lyr.geometry_type == 'polygon' || lyr.geometry_type == 'polyline')) {
+        forEachArcId(lyr.shapes, function(id) {
+          var absId, iter;
+          if (!keepGoing) return;
+          absId = id < 0 ? ~id : id;
+          if (usedArcs[absId]) return;
+          usedArcs[absId] = 1;
+          iter = arcs.getArcIter(absId);
+          while (keepGoing && iter.hasNext()) {
+            keepGoing = cb(iter.x, iter.y) !== false;
+          }
+        });
+      }
+    });
+  }
+
+  function scanPointCoords(shapes, cb) {
+    var shp, p;
+    for (var i=0, n=shapes.length; i<n; i++) {
+      shp = shapes[i];
+      for (var j=0, m=shp ? shp.length : 0; j<m; j++) {
+        p = shp[j];
+        if (cb(p[0], p[1]) === false) return false;
+      }
+    }
+    return true;
   }
 
   // See: Savric & Jenny, "Automating the selection of standard parallels for conic map projections"
@@ -48884,11 +48964,21 @@ ${svg}
     return `+lon_0=${ cx.toFixed(decimals) } +lat_0=${ cy.toFixed(decimals) }`;
   }
 
+  function getUtmParams(bbox) {
+    var cx = (bbox[0] + bbox[2]) / 2;
+    var cy = (bbox[1] + bbox[3]) / 2;
+    var zone = Math.floor((cx + 180) / 6) + 1;
+    zone = Math.max(1, Math.min(60, zone));
+    return `+zone=${ zone }` + (cy < 0 ? ' +south' : '');
+  }
+
   var ProjectionParams = /*#__PURE__*/Object.freeze({
     __proto__: null,
     expandProjDefn: expandProjDefn,
+    getAutoFitBBox: getAutoFitBBox,
     getCenterParams: getCenterParams,
-    getConicParams: getConicParams
+    getConicParams: getConicParams,
+    getUtmParams: getUtmParams
   });
 
   cmd.proj = function(dataset, catalog, opts, targetLayers) {
@@ -55438,7 +55528,7 @@ ${svg}
     });
   }
 
-  var version = "0.7.10";
+  var version = "0.7.12";
 
   // Parse command line args into commands and run them
   // Function takes an optional Node-style callback. A Promise is returned if no callback is given.
@@ -55496,8 +55586,10 @@ ${svg}
     var child = require$1('child_process').exec(command, {}, function(err, stdout, stderr) {
       opts.callback(err);
     });
-    child.stdout.pipe(process.stdout);
-    child.stderr.pipe(process.stderr);
+    if (loggingEnabled()) {
+      child.stdout.pipe(process.stdout);
+      child.stderr.pipe(process.stderr);
+    }
     if (opts.promise) return opts.promise;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mapshaper",
-  "version": "0.7.10",
+  "version": "0.7.12",
   "description": "A tool for editing vector datasets for mapping and GIS.",
   "keywords": [
     "shapefile",
@@ -23,15 +23,15 @@
     "node": ">=20.11.0"
   },
   "scripts": {
-    "test": "mocha test",
+    "test": "mocha --require test/mocha-hooks.mjs test",
     "build": "rollup --config",
     "docs": "node build-docs.mjs",
     "roadmap": "node build-roadmap.mjs",
     "lint": "eslint --ext mjs src/",
-    "prepublishOnly": "npm test; ./pre-publish",
+    "prepublishOnly": "npm test && npm run test:browser && ./pre-publish",
     "postpublish": "./release_web_ui; ./release_github_version",
     "dev": "rollup --config --watch",
-    "test:browser": "playwright test"
+    "test:browser": "playwright test --fully-parallel --workers=6"
   },
   "main": "./mapshaper.js",
   "files": [
@@ -45,6 +45,7 @@
     "!/www/ai-config.js"
   ],
   "dependencies": {
+    "@bokuweb/zstd-wasm": "^0.0.27",
     "@ngageoint/geopackage": "^4.2.6",
     "@placemarkio/tokml": "^0.3.3",
     "@tmcw/togeojson": "^5.6.0",
@@ -72,8 +73,7 @@
     "msgpackr": "^1.10.1",
     "open": "^11.0.0",
     "rw": "~1.3.3",
-    "tinyqueue": "^2.0.3",
-    "zstd-codec": "^0.1.5"
+    "tinyqueue": "^2.0.3"
   },
   "devDependencies": {
     "@playwright/test": "^1.59.1",