mapshaper 0.6.41 → 0.6.43

package/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.6.41";
+  var VERSION = "0.6.43";
 
 
   var utils = /*#__PURE__*/Object.freeze({
@@ -1267,6 +1267,26 @@
     _stop = stop;
   }
 
+  // get detailed error information from error stack (if available)
+  // Example stack string (Node.js):
+  /*
+  /Users/someuser/somescript.js:226
+      opacity: Math.round(weight * 5 / 5 // 0.2 0.4 0.6 etc
+                                       ^
+
+  SyntaxError: missing ) after argument list
+      at internalCompileFunction (node:internal/vm:73:18)
+      at wrapSafe (node:internal/modules/cjs/loader:1149:20)
+      at Module._compile (node:internal/modules/cjs/loader:1190:27)
+      ...
+  */
+  function getErrorDetail(e) {
+    var parts = (typeof e.stack == 'string') ? e.stack.split(/\n\s*\n/) : [];
+    if (parts.length > 1 || true) {
+      return '\nError details:\n' + parts[0];
+    }
+    return '';
+  }
 
   // print a message to stdout
   function print() {
@@ -1389,6 +1409,7 @@
     interrupt: interrupt,
     message: message,
     setLoggingFunctions: setLoggingFunctions,
+    getErrorDetail: getErrorDetail,
     print: print,
     verbose: verbose,
     debug: debug,
@@ -6359,9 +6380,10 @@
   function mergeDatasets(arr) {
     var arcSources = [],
         arcCount = 0,
-        mergedLayers = [],
-        mergedInfo = {},
-        mergedArcs;
+        merged = {
+          info: {},
+          layers: []
+        };
 
     // Error if incompatible CRS
     requireDatasetsHaveCompatibleCRS(arr);
@@ -6372,38 +6394,35 @@
         arcSources.push(dataset.arcs);
       }
 
-      mergeDatasetInfo(mergedInfo, dataset);
+      mergeDatasetInfo$1(merged, dataset);
       dataset.layers.forEach(function(lyr) {
         if (lyr.geometry_type == 'polygon' || lyr.geometry_type == 'polyline') {
           forEachArcId(lyr.shapes, function(id) {
             return id < 0 ? id - arcCount : id + arcCount;
           });
         }
-        mergedLayers.push(lyr);
+        merged.layers.push(lyr);
       });
       arcCount += n;
     });
 
     if (arcSources.length > 0) {
-      mergedArcs = mergeArcs(arcSources);
-      if (mergedArcs.size() != arcCount) {
+      merged.arcs = mergeArcs(arcSources);
+      if (merged.arcs.size() != arcCount) {
         error("[mergeDatasets()] Arc indexing error");
       }
     }
 
-    return {
-      info: mergedInfo,
-      arcs: mergedArcs,
-      layers: mergedLayers
-    };
+    return merged;
   }
 
-  function mergeDatasetInfo(merged, dataset) {
-    var info = dataset.info || {};
-    merged.input_files = utils.uniq((merged.input_files || []).concat(info.input_files || []));
-    merged.input_formats = utils.uniq((merged.input_formats || []).concat(info.input_formats || []));
+  function mergeDatasetInfo$1(merged, dataset) {
+    var src = dataset.info || {};
+    var dest = merged.info || (merged.info = {});
+    dest.input_files = utils.uniq((dest.input_files || []).concat(src.input_files || []));
+    dest.input_formats = utils.uniq((dest.input_formats || []).concat(src.input_formats || []));
     // merge other info properties (e.g. input_geojson_crs, input_delimiter, prj, crs)
-    utils.defaults(merged, info);
+    utils.defaults(dest, src);
   }
 
   function mergeArcs(arr) {
@@ -6450,6 +6469,7 @@
     mergeDatasetsForExport: mergeDatasetsForExport,
     mergeCommandTargets: mergeCommandTargets,
     mergeDatasets: mergeDatasets,
+    mergeDatasetInfo: mergeDatasetInfo$1,
     mergeArcs: mergeArcs
   });
 
@@ -6900,6 +6920,18 @@
     });
   }
 
+  // dest: destination dataset
+  // src: source dataset
+  function mergeDatasetInfo(dest, src) {
+    var srcInfo = src.info || {};
+    var destInfo = dest.info || (dest.info = {});
+    destInfo.input_files = utils.uniq((destInfo.input_files || []).concat(srcInfo.input_files || []));
+    destInfo.input_formats = utils.uniq((destInfo.input_formats || []).concat(srcInfo.input_formats || []));
+    // merge other info properties (e.g. input_geojson_crs, input_delimiter, prj, crs)
+    utils.defaults(destInfo, srcInfo);
+  }
+
+
   function splitApartLayers(dataset, layers) {
     var datasets = [];
     dataset.layers = dataset.layers.filter(function(lyr) {
@@ -7064,6 +7096,7 @@
   var DatasetUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     splitDataset: splitDataset,
+    mergeDatasetInfo: mergeDatasetInfo,
     splitApartLayers: splitApartLayers,
     copyDataset: copyDataset,
     copyDatasetForExport: copyDatasetForExport,
@@ -11205,20 +11238,43 @@
     return dest;
   };
 
+  // Receives a directory path, in which the final subdirectory may include the
+  //   "*" wildcard, e.g. '.' 'data' '*' 'data/*' '2023-*'
+  // Returns an array of expanded directory names
+  // TODO: add support for wildcards in other subdirectories
+  cli.expandDirectoryName = function(name) {
+    var info = parseLocalPath(name);
+    // final directory name is parsed as info.filename
+    if (!info.filename.includes('*')) {
+      return [name];
+    }
+    var rxp = utils.wildcardToRegExp(info.filename);
+    var dirs = [];
+    require$1('fs').readdirSync(info.directory || '.').forEach(function(item) {
+      var path = info.directory ? require$1('path').join(info.directory, item) : item;
+      if (rxp.test(item) && cli.isDirectory(path)) {
+        dirs.push(path);
+      }
+    });
+    return dirs;
+  };
+
   // Expand any "*" wild cards in file name
   // (For the Windows command line; unix shells do this automatically)
   cli.expandFileName = function(name) {
     var info = parseLocalPath(name),
         rxp = utils.wildcardToRegExp(info.filename),
-        dir = info.directory || '.',
+        dirs = cli.expandDirectoryName(info.directory || '.'),
         files = [];
 
     try {
-      require$1('fs').readdirSync(dir).forEach(function(item) {
-        var path = require$1('path').join(dir, item);
-        if (rxp.test(item) && cli.isFile(path)) {
-          files.push(path);
-        }
+      dirs.forEach(function(dir) {
+        require$1('fs').readdirSync(dir).forEach(function(item) {
+          var path = require$1('path').join(dir, item);
+          if (rxp.test(item) && cli.isFile(path)) {
+            files.push(path);
+          }
+        });
       });
     } catch(e) {}
 
@@ -16382,19 +16438,40 @@
     buildPolygonMosaic: buildPolygonMosaic
   });
 
+  // Map non-negative integers to non-negative integer ids
+  function IdLookupIndex(n) {
+    var index = new Uint32Array(n);
+
+    this.setId = function(id, val) {
+      if (id >= 0 && val >= 0 && val < n - 1) {
+        index[id] = val + 1;
+      } else {
+        error('Invalid value');
+      }
+    };
+
+    this.hasId = function(id) {
+      return this.getId(id) > -1;
+    };
+
+    this.getId = function(id) {
+      if (id >= 0 && id < n) {
+        return index[id] - 1;
+      } else {
+        error('Invalid index');
+      }
+    };
+  }
+
+
   // Map positive or negative integer ids to non-negative integer ids
-  function IdLookupIndex(n, clearable) {
+  function ArcLookupIndex(n) {
     var fwdIndex = new Int32Array(n);
     var revIndex = new Int32Array(n);
-    var index = this;
-    var setList = [];
     utils.initializeArray(fwdIndex, -1);
     utils.initializeArray(revIndex, -1);
 
     this.setId = function(id, val) {
-      if (clearable && !index.hasId(id)) {
-        setList.push(id);
-      }
       if (id < 0) {
         revIndex[~id] = val;
       } else {
@@ -16402,25 +16479,8 @@
       }
     };
 
-    this.clear = function() {
-      if (!clearable) {
-        error('Index is not clearable');
-      }
-      setList.forEach(function(id) {
-        index.setId(id, -1);
-      });
-      setList = [];
-    };
-
-    this.clearId = function(id) {
-      if (!index.hasId(id)) {
-        error('Tried to clear an unset id');
-      }
-      index.setId(id, -1);
-    };
-
     this.hasId = function(id) {
-      var val = index.getId(id);
+      var val = this.getId(id);
       return val > -1;
     };
 
@@ -16433,6 +16493,36 @@
     };
   }
 
+  // Support clearing the index (for efficient reuse)
+  function ClearableArcLookupIndex(n) {
+    var setList = [];
+    var idx = new ArcLookupIndex(n);
+    var _setId = idx.setId;
+
+    idx.setId = function(id, val) {
+      if (!idx.hasId(id)) {
+        setList.push(id);
+      }
+      _setId(id, val);
+    };
+
+    idx.clear = function() {
+      setList.forEach(function(id) {
+        _setId(id, -1);
+      });
+      setList = [];
+    };
+
+    this.clearId = function(id) {
+      if (!idx.hasId(id)) {
+        error('Tried to clear an unset id');
+      }
+      _setId(id, -1);
+    };
+
+    return idx;
+  }
+
   // Associate mosaic tiles with shapes (i.e. identify the groups of tiles that
   //   belong to each shape)
   //
@@ -16684,7 +16774,7 @@
   // Supports looking up a shape id using an arc id.
   function ShapeArcIndex(shapes, arcs) {
     var n = arcs.size();
-    var index = new IdLookupIndex(n);
+    var index = new ArcLookupIndex(n);
     var shapeId;
     shapes.forEach(onShape);
 
@@ -16836,7 +16926,7 @@
     var arcs = dataset.arcs;
     var filter = getArcPresenceTest(lyr.shapes, arcs);
     var nodes = new NodeCollection(arcs, filter);
-    var arcIndex = new IdLookupIndex(arcs.size(), true);
+    var arcIndex = new ClearableArcLookupIndex(arcs.size());
     lyr.shapes = lyr.shapes.map(function(shp, i) {
       if (!shp) return null;
       // split parts at nodes (where multiple arcs intersect)
@@ -28239,20 +28329,23 @@ ${svg}
     };
 
     this.setDefaultTarget = function(layers, dataset) {
-      if (datasets.indexOf(dataset) == -1) {
-        datasets.push(dataset);
-      }
-      defaultTargets = [{
+      this.setDefaultTargets([{
         // Copy layers array, in case layers is a reference to dataset.layers.
         // This prevents layers that are added to the dataset inside a command from
         //  being added to the next command's target, e.g. debugging layers added
         //  by '-join unmatched unjoined'.
         layers: layers.concat(),
         dataset: dataset
-      }];
+      }]);
     };
 
+    // arr: array of target objects {layers:[], dataset:{}}
     this.setDefaultTargets = function(arr) {
+      arr.forEach(function(target) {
+        if (datasets.indexOf(target.dataset) == -1) {
+          datasets.push(target.dataset);
+        }
+      });
       defaultTargets = arr;
     };
 
@@ -28345,6 +28438,30 @@ ${svg}
     stashVar('input_files', job.input_files);
   }
 
+  // Apply a command to an array of target layers
+  function applyCommandToEachLayer(func, targetLayers) {
+    var args = utils.toArray(arguments).slice(2);
+    return targetLayers.reduce(function(memo, lyr) {
+      var result = func.apply(null, [lyr].concat(args));
+      if (utils.isArray(result)) { // some commands return an array of layers
+        memo = memo.concat(result);
+      } else if (result) { // assuming result is a layer
+        memo.push(result);
+      }
+      return memo;
+    }, []);
+  }
+
+  function applyCommandToEachTarget(func, targets) {
+    var args = utils.toArray(arguments).slice(2);
+    targets.forEach(function(target) {
+      var result = func.apply(null, [target].concat(args));
+      if (result) {
+        error('Unexpected output from command');
+      }
+    });
+  }
+
   cmd.addShape = addShape;
 
   function addShape(targetLayers, targetDataset, opts) {
@@ -36290,6 +36407,7 @@ ${svg}
     var opts = parseExternalCommand(name, cmdDefn, cmdOpts._);
     var targets = catalog.findCommandTargets(opts.target || '*');
     var target = targets[0];
+    var output;
     if (!target) {
       stop('Missing a target');
     }
@@ -36300,12 +36418,34 @@ ${svg}
       stop("Targetting layers from multiple datasets is not supported");
     }
     if (targetType == 'layer') {
-      cmdDefn.command(target.layers[0], target.dataset, opts.options);
+      output = cmdDefn.command(target.layers[0], target.dataset, opts.options);
     } else if (targetType == 'layers') {
-      cmdDefn.command(target.layers, target.dataset, opts.options);
+      output = cmdDefn.command(target.layers, target.dataset, opts.options);
+    }
+    if (output) {
+      integrateOutput(output, target, catalog, opts);
     }
   };
 
+  // TODO: remove restrictions on output data
+  function integrateOutput(output, input, catalog, opts) {
+    if (!output.dataset || !output.layers || output.layers.length > 0 === false) {
+      stop('Invalid command output');
+    }
+    if (output.dataset == input.dataset) {
+      stop('External commands are not currently allowed to modify input datasets');
+    }
+    if (output.dataset.layers.length != output.layers.length) {
+      stop('Currently not supported: targetting a subset of output layers');
+    }
+    if (!opts.no_replace) {
+      input.layers.forEach(function(lyr) {
+        catalog.deleteLayer(lyr, input.dataset);
+      });
+    }
+    catalog.addDataset(output.dataset);
+  }
+
   function parseExternalCommand(name, cmdDefn, tokens) {
     var parser = new CommandParser();
     var cmd = parser.command(name);
@@ -38156,7 +38296,7 @@ ${svg}
     // polygon layer, @clipData). This avoids performing unnecessary intersection
     // tests on each line segment.
     var layers = dataset.layers.filter(function(lyr) {
-      return !layerIsFullyEnclosed(lyr, dataset, clipData);
+      return layerHasGeometry(lyr) && !layerIsFullyEnclosed(lyr, dataset, clipData);
     });
     if (layers.length > 0) {
       clipLayersInPlace(layers, clipData, dataset, 'clip');
@@ -40720,7 +40860,8 @@ ${svg}
   function makeCircleCoords(center, opts) {
     var margin = opts.cell_margin > 0 ? opts.cell_margin : 1e-6;
     var radius = opts.interval / 2 * (1 - margin);
-    return getPointBufferCoordinates(center, radius, 20, getPlanarSegmentEndpoint);
+    var vertices = opts.vertices || 20;
+    return getPointBufferCoordinates(center, radius, vertices, getPlanarSegmentEndpoint);
   }
 
   // Returns a function that receives a cell index and returns indices of points
@@ -40731,12 +40872,15 @@ ${svg}
     var bboxIndex = new Flatbush(points.length);
     var empty = [];
     points.forEach(function(p) {
+      var bbox = getPointBounds(p, radius);
       addPointToGridIndex(p, gridIndex, grid);
-      bboxIndex.add.apply(bboxIndex, getPointBounds(p, radius));
+      bboxIndex.add.apply(bboxIndex, bbox);
     });
     bboxIndex.finish();
     return function(i) {
-      if (!gridIndex.hasId(i)) return empty;
+      if (!gridIndex.hasId(i)) {
+        return empty;
+      }
       var bbox = grid.idxToBBox(i);
       var indices = bboxIndex.search.apply(bboxIndex, bbox);
       return indices;
@@ -40870,6 +41014,7 @@ ${svg}
     calcWeights: calcWeights,
     twoCircleIntersection: twoCircleIntersection,
     makeCellPolygon: makeCellPolygon,
+    makeCircleCoords: makeCircleCoords,
     getPointIndex: getPointIndex,
     getAlignedGridBounds: getAlignedGridBounds,
     getCenteredGridBounds: getCenteredGridBounds,
@@ -41198,8 +41343,7 @@ ${svg}
         }
       }
     } catch(e) {
-      // stop(e);
-      stop('Unable to load external module:', e.message);
+      stop('Unable to load external module:', e.message, getErrorDetail(e));
     }
     if (moduleName || opts.alias) {
       defs[opts.alias || moduleName] = mod;
@@ -42230,9 +42374,10 @@ ${svg}
     }
   };
 
-  cmd.snap = function(dataset, opts) {
+  cmd.snap = function(target, opts) {
     var interval = 0;
     var snapCount = 0;
+    var dataset = target.dataset;
     var arcs = dataset.arcs;
     var arcBounds = arcs && arcs.getBounds();
     if (!arcBounds || !arcBounds.hasBounds()) {
@@ -43367,7 +43512,7 @@ ${svg}
   function commandAcceptsMultipleTargetDatasets(name) {
     return name == 'rotate' || name == 'info' || name == 'proj' || name == 'require' ||
       name == 'drop' || name == 'target' || name == 'if' || name == 'elif' ||
-      name == 'else' || name == 'endif' || name == 'run' || name == 'i';
+      name == 'else' || name == 'endif' || name == 'run' || name == 'i' || name == 'snap';
   }
 
   function commandAcceptsEmptyTarget(name) {
@@ -43449,6 +43594,10 @@ ${svg}
         source = findCommandSource(convertSourceName(opts.source, targets), job.catalog, opts);
       }
 
+      // identify command target/input (for postprocessing)
+      // TODO: support commands with multiple target datasets
+      // target = name == 'i' ? null : targets[0];
+
       if (name == 'add-shape') {
         if (!targetDataset) {
           targetDataset = {info: {}, layers: []};
@@ -43556,6 +43705,9 @@ ${svg}
       } else if (name == 'graticule') {
         job.catalog.addDataset(cmd.graticule(targetDataset, opts));
 
+      } else if (name == 'grid') {
+        outputDataset = cmd.polygonGrid(targetLayers, targetDataset, opts);
+
       } else if (name == 'help') {
         // placing help command here to handle errors from invalid command names
         cmd.printHelp(command.options);
@@ -43627,9 +43779,6 @@ ${svg}
       } else if (name == 'point-to-grid') {
         outputLayers = cmd.pointToGrid(targetLayers, targetDataset, opts);
 
-      } else if (name == 'grid') {
-        outputDataset = cmd.polygonGrid(targetLayers, targetDataset, opts);
-
       } else if (name == 'points') {
         outputLayers = applyCommandToEachLayer(cmd.createPointLayer, targetLayers, targetDataset, opts);
 
@@ -43693,7 +43842,8 @@ ${svg}
         outputLayers = cmd.sliceLayers(targetLayers, source, targetDataset, opts);
 
       } else if (name == 'snap') {
-        cmd.snap(targetDataset, opts);
+        // cmd.snap(targetDataset, opts);
+        applyCommandToEachTarget(targets, opts);
 
       } else if (name == 'sort') {
         applyCommandToEachLayer(cmd.sortFeatures, targetLayers, arcs, opts);
@@ -43784,9 +43934,12 @@ ${svg}
 
       // delete arcs if no longer needed (e.g. after -points command)
       // (after output layers have been integrated)
+      // TODO: be more selective (e.g. -i command doesn't need cleanup)
+      //   or: detect if arcs have been changed
       if (targetDataset) {
         cleanupArcs(targetDataset);
       }
+
     } catch(e) {
       return done(e);
     }
@@ -43808,20 +43961,6 @@ ${svg}
     });
   }
 
-  // Apply a command to an array of target layers
-  function applyCommandToEachLayer(func, targetLayers) {
-    var args = utils.toArray(arguments).slice(2);
-    return targetLayers.reduce(function(memo, lyr) {
-      var result = func.apply(null, [lyr].concat(args));
-      if (utils.isArray(result)) { // some commands return an array of layers
-        memo = memo.concat(result);
-      } else if (result) { // assuming result is a layer
-        memo.push(result);
-      }
-      return memo;
-    }, []);
-  }
-
   // 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.
   //   function(argv[, input], callback)
@@ -44465,6 +44604,7 @@ ${svg}
     editArcs,
     GeoJSONReader,
     Heap,
+    IdLookupIndex,
     NodeCollection,
     parseDMS,
     formatDMS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mapshaper",
-  "version": "0.6.41",
+  "version": "0.6.43",
   "description": "A tool for editing vector datasets for mapping and GIS.",
   "keywords": [
     "shapefile",

package/www/index.html

@@ -172,7 +172,7 @@ precision=0.001. Click to see all options.</div></div></div></a>
 
 		<!-- <div class="cancel-btn btn dialog-btn">Cancel</div> -->
 		<div class="save-btn btn dialog-btn">Export</div>
-		<span id="save-preference"><input type="checkbox"/>choose directory</span>
+		<span id="save-preference" class="inline-checkbox" style="display: none;"><input type="checkbox"/>choose directory</span>
 
 	</div>
 </div>