mapshaper 0.7.11 → 0.7.13

package/mapshaper.js

@@ -17490,7 +17490,7 @@
   // higher-level mapshaper-svg.mjs (which would otherwise form a cycle).
 
   function featureHasSvgSymbol(d) {
-    return !!(d && (d['svg-symbol'] || d.r));
+    return !!(d && (d['svg-symbol'] || d.r || d.icon || d['icon-size']));
   }
 
   function featureHasLabel(d) {
@@ -17763,6 +17763,9 @@
     'font-style': null,
     'font-stretch': null,
     'font-weight': null,
+    icon: null,
+    'icon-color': 'color',
+    'icon-size': 'number',
     'label-text': null,  // leaving this null
     'letter-spacing': 'measure',
     'line-height': 'measure',
@@ -18110,12 +18113,44 @@
     if (d['svg-symbol']) {
       return renderComplexSymbol(d['svg-symbol']);
     }
+    if (featureHasIcon(d)) {
+      return renderIcon(d);
+    }
     if (d.r > 0) {
       return circle(d);
     }
     return empty();
   }
 
+  function featureHasIcon(d) {
+    return !!(d && (d.icon || d['icon-size'] || (d['icon-color'] && d.r > 0)));
+  }
+
+  function renderIcon(d) {
+    var type = d.icon || 'circle';
+    var r = getIconRadius(d);
+    if (r > 0 === false) return empty();
+    if (type == 'circle') return circle(getIconStyleData(d, r));
+    if (type == 'square') return square(getIconStyleData(d, r), 0, 0);
+    if (type == 'ring') return ring(getIconStyleData(d, r), 0, 0);
+    if (type == 'star') return star(getIconStyleData(d, r));
+    message('Unknown icon type: ' + type);
+    return empty();
+  }
+
+  function getIconRadius(d) {
+    if (d['icon-size'] > 0) return d['icon-size'] / 2;
+    if (d.r > 0) return d.r;
+    return 5;
+  }
+
+  function getIconStyleData(d, r) {
+    var o = utils.extend({}, d);
+    o.r = r;
+    o.fill = d['icon-color'] || d.fill || 'black';
+    return o;
+  }
+
   function renderComplexSymbol(sym, x, y) {
     if (utils.isString(sym)) {
       sym = JSON.parse(sym);
@@ -18190,10 +18225,44 @@
         height: r * 2
       }
     };
-    applyStyleAttributes(o, 'point', d);
+    applyStyleAttributes(o, 'point', d, nonCirclePointFilter);
+    return o;
+  }
+
+  function ring(d, x, y) {
+    var o = circle(d, x, y);
+    o.properties.fill = 'none';
+    o.properties.stroke = d.fill;
+    if (!o.properties['stroke-width']) {
+      o.properties['stroke-width'] = 1;
+    }
+    return o;
+  }
+
+  function star(d) {
+    var coords = getStarCoords$1(d.r);
+    var o = importPolygon([coords]);
+    applyStyleAttributes(o, 'point', d, nonCirclePointFilter);
     return o;
   }
 
+  function nonCirclePointFilter(k) {
+    return k != 'r';
+  }
+
+  function getStarCoords$1(r) {
+    var coords = [];
+    var innerR = r * 0.42;
+    var angle, len;
+    for (var i=0; i<10; i++) {
+      len = i % 2 === 0 ? r : innerR;
+      angle = -Math.PI / 2 + i * Math.PI / 5;
+      coords.push([roundToTenths(Math.cos(angle) * len), roundToTenths(Math.sin(angle) * len)]);
+    }
+    coords.push(coords[0].concat());
+    return coords;
+  }
+
   function line(d, x, y) {
     var coords, o;
     coords = [[x, y], [x + (d.dx || 0), y + (d.dy || 0)]];
@@ -18899,7 +18968,7 @@
 
   // just a dot, no label or icon
   function isSimpleCircle(rec) {
-    return rec && (rec.r > 0 && !rec['svg-symbol'] && !rec['label-text']);
+    return rec && (rec.r > 0 && !rec['svg-symbol'] && !rec['label-text'] && !rec.icon && !rec['icon-size'] && !rec['icon-color']);
   }
 
   function importMultiPoint(coords, rec) {
@@ -18927,6 +18996,8 @@
     importPolygon: importPolygon
   });
 
+  var ILLUSTRATOR_PATH_VERTEX_LIMIT = 32000;
+
   //
   function exportSVG(dataset, opts) {
     var namespace = 'xmlns="http://www.w3.org/2000/svg"';
@@ -19091,6 +19162,7 @@ ${svg}
     var d = utils.defaults({layers: [lyr]}, dataset);
     var geojson = exportDatasetAsGeoJSON(d, opts);
     var features = geojson.features || geojson.geometries || (geojson.type ? [geojson] : []);
+    warnIfIllustratorPathLimitExceeded(lyr, features);
     var children = importGeoJSONFeatures(features, opts);
     // Drop empty placeholder <g/> elements (features whose geometry was null in the
     // source data, collapsed during simplification, or otherwise produced no
@@ -19109,6 +19181,53 @@ ${svg}
     return children;
   }
 
+  function warnIfIllustratorPathLimitExceeded(lyr, features) {
+    var count = 0;
+    var max = 0;
+    if (lyr.geometry_type != 'polygon' && lyr.geometry_type != 'polyline') return;
+    features.forEach(function(feature) {
+      var geom = feature.geometry || feature;
+      var n = countSvgPathVertices(geom);
+      if (n > ILLUSTRATOR_PATH_VERTEX_LIMIT) {
+        count++;
+        max = Math.max(max, n);
+      }
+    });
+    if (count > 0) {
+      warn(utils.format(
+        '%,d SVG path%s in layer "%s" contain%s more than %,d vertices; Adobe Illustrator may not import %s. The largest path has %,d vertices.',
+        count,
+        utils.pluralSuffix(count),
+        lyr.name || '[unnamed]',
+        count == 1 ? 's' : '',
+        ILLUSTRATOR_PATH_VERTEX_LIMIT,
+        count == 1 ? 'it' : 'them',
+        max
+      ));
+    }
+  }
+
+  function countSvgPathVertices(geom) {
+    var coords = geom && geom.coordinates;
+    if (!coords) return 0;
+    if (geom.type == 'LineString') return coords.length;
+    if (geom.type == 'MultiLineString' || geom.type == 'Polygon') {
+      return sumPathLengths(coords);
+    }
+    if (geom.type == 'MultiPolygon') {
+      return coords.reduce(function(sum, polygon) {
+        return sum + sumPathLengths(polygon);
+      }, 0);
+    }
+    return 0;
+  }
+
+  function sumPathLengths(paths) {
+    return paths.reduce(function(sum, path) {
+      return sum + path.length;
+    }, 0);
+  }
+
   function isEmptyPlaceholder(o) {
     return o.tag == 'g' && (!o.children || o.children.length === 0);
   }
@@ -19206,7 +19325,7 @@ ${svg}
     // TODO: set fill="none" in SVG symbols, not on the container
     //   (setting fill=none on the container overrides the default black fill
     //   on paths, which may alter the appearance of SVG icons loaded from external URLs).
-    if (lyr.geometry_type == 'polyline' || layerHasSvgSymbols(lyr)) {
+    if (lyr.geometry_type == 'polyline' || layerHasSvgSymbolField(lyr)) {
       layerObj.properties.fill = 'none';
     }
 
@@ -19229,6 +19348,15 @@ ${svg}
   }
 
   function layerHasSvgSymbols(lyr) {
+    return lyr.geometry_type == 'point' && lyr.data && (
+      lyr.data.fieldExists('svg-symbol') ||
+      lyr.data.fieldExists('icon') ||
+      lyr.data.fieldExists('icon-size') ||
+      (lyr.data.fieldExists('icon-color') && lyr.data.fieldExists('r'))
+    );
+  }
+
+  function layerHasSvgSymbolField(lyr) {
     return lyr.geometry_type == 'point' && lyr.data && lyr.data.fieldExists('svg-symbol');
   }
 
@@ -28250,7 +28378,7 @@ ${svg}
 
     };
 
-    this.getHelpMessage = function(cmdName) {
+    this.getHelpLines = function(cmdName) {
       var helpCommands, singleCommand, lines;
       if (cmdName) {
         singleCommand = findCommandDefn(cmdName, getCommands());
@@ -28262,113 +28390,115 @@ ${svg}
         helpCommands = getCommands().filter(function(cmd) {return cmd.name && cmd.describe || cmd.title;});
         lines = getMultiCommandLines(helpCommands);
       }
+      return lines;
+    };
 
-      return formatLines(lines);
-
-      function formatLines(lines) {
-        var colWidth = calcColWidth(lines);
-        var gutter = '  ';
-        var indent = runningInBrowser() ? '' : '  ';
-        var helpStr = lines.map(function(line) {
-          if (Array.isArray(line)) {
-            line = indent + utils.rpad(line[0], colWidth, ' ') + gutter + line[1];
-          }
-          return line;
-        }).join('\n');
-        return helpStr;
-      }
-
-      function getSingleCommandLines(cmd) {
-        var lines = [];
-        var options = [];
-        cmd.options.forEach(function(opt) {
-          options = options.concat(getOptionLines(opt));
-        });
+    this.getHelpMessage = function(cmdName) {
+      return formatLines(this.getHelpLines(cmdName));
+    };
 
-        lines.push('COMMAND', getCommandLine(cmd));
-        if (options.length > 0) {
-          lines.push('', 'OPTIONS');
-          lines = lines.concat(options);
+    function formatLines(lines) {
+      var colWidth = calcColWidth(lines);
+      var gutter = '  ';
+      var indent = runningInBrowser() ? '' : '  ';
+      var helpStr = lines.map(function(line) {
+        if (Array.isArray(line)) {
+          line = indent + utils.rpad(line[0], colWidth, ' ') + gutter + line[1];
         }
+        return line;
+      }).join('\n');
+      return helpStr;
+    }
 
-        // examples
-        if (cmd.examples) {
-          lines.push('', 'EXAMPLE' + (cmd.examples.length > 1 ? 'S' : ''));
-          cmd.examples.forEach(function(ex, i) {
-            if (i > 0) lines.push('');
-            ex.split('\n').forEach(function(line, i) {
-              lines.push('  ' + line);
-            });
-          });
-        }
-        return lines;
+    function getSingleCommandLines(cmd) {
+      var lines = [];
+      var options = [];
+      cmd.options.forEach(function(opt) {
+        options = options.concat(getOptionLines(opt));
+      });
+
+      lines.push('COMMAND', getCommandLine(cmd));
+      if (options.length > 0) {
+        lines.push('', 'OPTIONS');
+        lines = lines.concat(options);
       }
 
-      function getOptionLines(opt, cmd) {
-        var lines = [];
-        var description = opt.describe;
-        var label;
-        if (!description) ; else if (opt.label) {
-          lines.push([opt.label, description]);
-        } else if (opt.DEFAULT) {
-          label = opt.name + '=';
-          lines.push(['<' + opt.name + '>', 'shortcut for ' + label]);
-          lines.push([label, description]);
-        } else {
-          label = opt.name;
-          if (opt.alias) label += ', ' + opt.alias;
-          if (opt.type != 'flag' && !opt.assign_to) label += '=';
-          lines.push([label, description]);
-        }
-        return lines;
+      // examples
+      if (cmd.examples) {
+        lines.push('', 'EXAMPLE' + (cmd.examples.length > 1 ? 'S' : ''));
+        cmd.examples.forEach(function(ex, i) {
+          if (i > 0) lines.push('');
+          ex.split('\n').forEach(function(line, i) {
+            lines.push('  ' + line);
+          });
+        });
       }
+      return lines;
+    }
 
-      function getCommandLine(cmd) {
-        var name = cmd.name ? "-" + cmd.name : '';
-        if (cmd.alias) name += ', -' + cmd.alias;
-        return [name, cmd.describe || '(undocumented command)'];
+    function getOptionLines(opt, cmd) {
+      var lines = [];
+      var description = opt.describe;
+      var label;
+      if (!description) ; else if (opt.label) {
+        lines.push([opt.label, description]);
+      } else if (opt.DEFAULT) {
+        label = opt.name + '=';
+        lines.push(['<' + opt.name + '>', 'shortcut for ' + label]);
+        lines.push([label, description]);
+      } else {
+        label = opt.name;
+        if (opt.alias) label += ', ' + opt.alias;
+        if (opt.type != 'flag' && !opt.assign_to) label += '=';
+        lines.push([label, description]);
       }
+      return lines;
+    }
 
-      function getMultiCommandLines(commands) {
-        var lines = [];
-        // usage
-        if (_usage) lines.push(_usage);
+    function getCommandLine(cmd) {
+      var name = cmd.name ? "-" + cmd.name : '';
+      if (cmd.alias) name += ', -' + cmd.alias;
+      return [name, cmd.describe || '(undocumented command)'];
+    }
 
-        // list of commands
-        commands.forEach(function(cmd) {
-          if (cmd.title) {
-            lines.push('', cmd.title);
-          } else {
-            lines.push(getCommandLine(cmd));
-          }
-        });
+    function getMultiCommandLines(commands) {
+      var lines = [];
+      // usage
+      if (_usage) lines.push(_usage);
 
-        // examples
-        if (_examples.length > 0) {
-          lines.push('', 'Examples');
-          _examples.forEach(function(str) {
-            lines.push('', str);
-          });
+      // list of commands
+      commands.forEach(function(cmd) {
+        if (cmd.title) {
+          lines.push('', cmd.title);
+        } else {
+          lines.push(getCommandLine(cmd));
         }
+      });
 
-        // note
-        if (_note) {
-          lines.push('', _note);
-        }
-        return lines;
+      // examples
+      if (_examples.length > 0) {
+        lines.push('', 'Examples');
+        _examples.forEach(function(str) {
+          lines.push('', str);
+        });
       }
 
-
-      function calcColWidth(lines) {
-        var w = 0;
-        lines.forEach(function(line) {
-          if (Array.isArray(line)) {
-            w = Math.max(w, line[0].length);
-          }
-        });
-        return w;
+      // note
+      if (_note) {
+        lines.push('', _note);
       }
-    };
+      return lines;
+    }
+
+    function calcColWidth(lines) {
+      var w = 0;
+      lines.forEach(function(line) {
+        if (Array.isArray(line)) {
+          w = Math.max(w, line[0].length);
+        }
+      });
+      return w;
+    }
 
     function getCommands() {
       return _commands.map(function(cmd) {
@@ -30488,6 +30618,15 @@ ${svg}
       .option('r', {
         describe: 'symbol radius (set this to export points as circles)',
       })
+      .option('icon', {
+        describe: 'point icon shape; one of: circle, square, ring, star'
+      })
+      .option('icon-size', {
+        describe: 'point icon size in pixels'
+      })
+      .option('icon-color', {
+        describe: 'point icon color (defaults to fill color, then black)'
+      })
       .option('label-text', {
         describe: 'label text (set this to export points as labels)'
       })
@@ -44055,7 +44194,14 @@ ${svg}
         }]
       };
     }
-    message(formatInfo(arr));
+    if (runningInBrowser()) {
+      message({
+        type: 'mapshaper-console-info',
+        layers: arr
+      });
+    } else {
+      message(formatInfo(arr));
+    }
   };
 
   cmd.printInfo = cmd.info; // old name
@@ -48764,7 +48910,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;
@@ -48803,13 +48949,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) {
@@ -48820,29 +48974,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());
   }
 
-  // Converts a Proj.4 projection name (e.g. lcc, tmerc) to a Proj.4 string
+  function getInternalClipOpts() {
+    return {no_cleanup: true, no_warn: true};
+  }
+
+  // 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}"`);
     }
@@ -48858,7 +49021,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"
@@ -48877,11 +49110,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) {
@@ -49280,8 +49523,15 @@ ${svg}
   }
 
   cmd.printHelp = function(opts) {
-    var str = getOptionParser().getHelpMessage(opts.command);
-    print(str);
+    var parser = getOptionParser();
+    if (runningInBrowser()) {
+      message({
+        type: 'mapshaper-console-help',
+        lines: parser.getHelpLines(opts.command)
+      });
+    } else {
+      print(parser.getHelpMessage(opts.command));
+    }
   };
 
   function stopJob(job) {
@@ -55431,7 +55681,7 @@ ${svg}
     });
   }
 
-  var version = "0.7.11";
+  var version = "0.7.13";
 
   // 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mapshaper",
-  "version": "0.7.11",
+  "version": "0.7.13",
   "description": "A tool for editing vector datasets for mapping and GIS.",
   "keywords": [
     "shapefile",
@@ -28,10 +28,10 @@
     "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": [