mapshaper 0.6.40 → 0.6.42

package/bin/mapshaper-gui

@@ -9,7 +9,7 @@ var defaultPort = 5555,
       .option('-q, --quick-view', 'load files with default options, bypassing import dialog')
       .option('-s, --direct-save', 'save files outside the browser\'s download folder')
       .option('-f, --force-save', 'allow overwriting input files with output files')
-      .option('-a, --display-all', 'turn on visibility of all layers')
+      .option('-a, --display-all', 'turn on initial visibility of all layers')
       .option('-n, --name <name(s)>', 'rename input layer or layers')
       .option('-c, --commands <string>', 'console commands to run initially')
       .option('-t, --target <name>', 'name of layer to select initially')

package/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.6.40";
+  var VERSION = "0.6.42";
 
 
   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,
@@ -10877,7 +10910,8 @@
     pack: pack,
     exportDatasetsToPack: exportDatasetsToPack,
     applyCompression: applyCompression,
-    exportDataset: exportDataset
+    exportDataset: exportDataset,
+    exportInfo: exportInfo
   });
 
   // Guess the type of a data file from file extension, or return null if not sure
@@ -11204,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) {}
 
@@ -23386,6 +23443,10 @@ ${svg}
         describe: '[TopoJSON] export coordinates without quantization',
         type: 'flag'
       })
+      .option('metadata', {
+        // describe: '[TopoJSON] Add a metadata object containing CRS information',
+        type: 'flag'
+      })
       .option('no-point-quantization', {
         // describe: '[TopoJSON] export point coordinates without quantization',
         type: 'flag'
@@ -27562,6 +27623,7 @@ ${svg}
     var separator = path.indexOf('/') > 0 ? '/' : '.';
     var parts = path.split(separator);
     var subpath, array, match;
+
     while (parts.length > 0) {
       subpath = parts.shift();
       match = arrayRxp.exec(subpath);
@@ -28233,20 +28295,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;
     };
 
@@ -28339,6 +28404,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) {
@@ -36244,31 +36333,6 @@ ${svg}
 
   var externalCommands = {};
 
-  cmd.external = function(opts) {
-    // TODO: remove duplication with -require command
-    var _module, moduleFile, moduleName;
-    if (!opts.module) {
-      stop('Missing required "module" parameter');
-    }
-    if (cli.isFile(opts.module)) {
-      moduleFile = opts.module;
-    } else if (cli.isFile(opts.module + '.js')) {
-      moduleFile = opts.module + '.js';
-    } else {
-      moduleName = opts.module;
-    }
-    if (moduleFile) {
-      moduleFile = require$1('path').join(process.cwd(), moduleFile);
-    }
-    try {
-      _module = require$1(moduleFile || moduleName);
-      _module(coreAPI);
-    } catch(e) {
-      // stop(e);
-      stop('Unable to load external module:', e.message);
-    }
-  };
-
   cmd.registerCommand = function(name, params) {
     var defn = {name: name, options: params.options || []};
     // Add definitions of options common to all commands (TODO: remove duplication)
@@ -36278,13 +36342,25 @@ ${svg}
     externalCommands[name] = defn;
   };
 
+  function isValidExternalCommand(defn) {
+    try {
+      validateExternalCommand(defn);
+      return true;
+    } catch(e) {}
+    return false;
+  }
+
   function validateExternalCommand(defn) {
+    var targetTypes = ['layer', 'layers'];
     if (typeof defn.command != 'function') {
       stop('Expected "command" parameter function');
     }
     if (!defn.target) {
       stop('Missing required "target" parameter');
     }
+    if (!targetTypes.includes(defn.target)) {
+      stop('Unrecognized command target type:', defn.target);
+    }
   }
 
   cmd.runExternalCommand = function(cmdOpts, catalog) {
@@ -36297,6 +36373,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');
     }
@@ -36307,12 +36384,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);
@@ -40624,6 +40723,7 @@ ${svg}
     return outputLayers;
   };
 
+
   function getPolygonDataset(pointLyr, gridBBox, opts) {
     var points = getPointsInLayer(pointLyr);
     var cellSize = opts.interval;
@@ -40726,21 +40826,27 @@ ${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
+  //   within a given distance of the cell.
   function getPointIndex(points, grid, radius) {
     var Flatbush = require$1('flatbush');
     var gridIndex = new IdTestIndex(grid.cells());
     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;
@@ -40860,12 +40966,27 @@ ${svg}
         xmin + (c + 1) * interval, ymin + (r + 1) * interval
       ];
     }
+
     return {
       size, cells, pointToCol, pointToRow, colRowToIdx, pointToIdx,
       idxToCol, idxToRow, idxToBBox, idxToPoint
     };
   }
 
+  var PointToGrid = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getPointCircleRadius: getPointCircleRadius,
+    calcCellProperties: calcCellProperties,
+    calcWeights: calcWeights,
+    twoCircleIntersection: twoCircleIntersection,
+    makeCellPolygon: makeCellPolygon,
+    makeCircleCoords: makeCircleCoords,
+    getPointIndex: getPointIndex,
+    getAlignedGridBounds: getAlignedGridBounds,
+    getCenteredGridBounds: getCenteredGridBounds,
+    getGridData: getGridData
+  });
+
   function closeUndershoots(lyr, dataset, opts) {
     var maxGapLen = opts.gap_tolerance ? convertIntervalParam(opts.gap_tolerance, getDatasetCRS(dataset)) : 0;
     var arcs = dataset.arcs;
@@ -41180,8 +41301,15 @@ ${svg}
     }
     try {
       mod = require$1(moduleFile || moduleName);
+      if (typeof mod == 'function') {
+        // -require now includes the functionality of the old -external command
+        var retn = mod(api);
+        if (retn && isValidExternalCommand(retn)) {
+          cmd.registerCommand(retn.name, retn);
+        }
+      }
     } catch(e) {
-      stop(e);
+      stop('Unable to load external module:', e.message, getErrorDetail(e));
     }
     if (moduleName || opts.alias) {
       defs[opts.alias || moduleName] = mod;
@@ -42212,9 +42340,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()) {
@@ -43347,9 +43476,9 @@ ${svg}
   }
 
   function commandAcceptsMultipleTargetDatasets(name) {
-    return name == 'rotate' || name == 'info' || name == 'proj' ||
+    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) {
@@ -43431,6 +43560,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: []};
@@ -43505,7 +43638,8 @@ ${svg}
         outputLayers = applyCommandToEachLayer(cmd.explodeFeatures, targetLayers, arcs, opts);
 
       } else if (name == 'external') {
-        cmd.external(opts);
+        // -require now incorporates -external
+        cmd.require(targets, opts);
 
       } else if (name == 'filter') {
         outputLayers = applyCommandToEachLayer(cmd.filterFeatures, targetLayers, arcs, opts);
@@ -43537,6 +43671,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);
@@ -43608,9 +43745,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);
 
@@ -43674,7 +43808,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);
@@ -43765,9 +43900,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);
     }
@@ -43789,20 +43927,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)
@@ -44130,14 +44254,6 @@ ${svg}
     runAndRemoveInfoCommands: runAndRemoveInfoCommands
   });
 
-  // the mapshaper public api only has 4 functions
-  var coreAPI = {
-    runCommands,
-    applyCommands,
-    runCommandsXL,
-    enableLogging
-  };
-
   // Return an array containing points from a path iterator, clipped to a bounding box
   // Currently using this function for clipping styled polygons in the GUI to speed up layer rendering.
   // Artifacts along the edges make this unsuitable for clipping datasets
@@ -44454,6 +44570,7 @@ ${svg}
     editArcs,
     GeoJSONReader,
     Heap,
+    IdLookupIndex,
     NodeCollection,
     parseDMS,
     formatDMS,
@@ -44534,6 +44651,7 @@ ${svg}
     PixelTransform,
     PointPolygonJoin,
     Points,
+    PointToGrid,
     PointUtils,
     PolygonDissolve,
     PolygonDissolve2,
@@ -44581,16 +44699,26 @@ ${svg}
     Zip
   );
 
-  // The entry point for the core mapshaper module
+  // the mapshaper public api only has 4 functions
+  var api = {
+    runCommands,
+    applyCommands,
+    runCommandsXL,
+    enableLogging
+  };
 
-  var moduleAPI = Object.assign({
+  // Add some namespaces, for easier testability and
+  // to expose internal functions to the web UI
+  Object.assign(api, {
     cli, cmd, geom, utils, internal,
-  }, coreAPI);
+  });
+
+  // The entry point for the core mapshaper module
 
   if (typeof module === "object" && module.exports) {
-    module.exports = moduleAPI;
+    module.exports = api;
   } else if (typeof window === "object" && window) {
-    window.mapshaper = moduleAPI;
+    window.mapshaper = api;
   }
 
 })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mapshaper",
-  "version": "0.6.40",
+  "version": "0.6.42",
   "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>