mapshaper 0.5.86 → 0.5.91

package/www/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.5.85";
+  var VERSION = "0.5.88";
 
 
   var utils = /*#__PURE__*/Object.freeze({
@@ -1240,7 +1240,8 @@
   // print a message to stdout
   function print() {
     STDOUT = true; // tell logArgs() to print to stdout, not stderr
-    message.apply(null, arguments);
+    // calling message() adds the "[command name]" prefix
+    _message(utils.toArray(arguments));
     STDOUT = false;
   }
 
@@ -4895,6 +4896,11 @@
     };
   }
 
+  function MultiShapeIter(arcs) {
+    var iter = new ShapeIter(arcs);
+
+  }
+
   // Iterate along a path made up of one or more arcs.
   //
   function ShapeIter(arcs) {
@@ -4945,6 +4951,7 @@
     PointIter: PointIter,
     ArcIter: ArcIter,
     FilteredArcIter: FilteredArcIter,
+    MultiShapeIter: MultiShapeIter,
     ShapeIter: ShapeIter
   });
 
@@ -8222,10 +8229,21 @@
     return +n.toPrecision(d);
   }
 
+
   function roundToDigits(n, d) {
     return +n.toFixed(d); // string conversion makes this slow
   }
 
+  // Used in mapshaper-expression-utils.js
+  // TODO: choose between this and the above function
+  function roundToDigits2(n, d) {
+    var k = 1;
+    if (!n && n !== 0) return n; // don't coerce null to 0
+    d = d | 0;
+    while (d-- > 0) k *= 10;
+    return Math.round(n * k) / k;
+  }
+
   function roundToTenths(n) {
     return (Math.round(n * 10)) / 10;
   }
@@ -8300,6 +8318,7 @@
     __proto__: null,
     roundToSignificantDigits: roundToSignificantDigits,
     roundToDigits: roundToDigits,
+    roundToDigits2: roundToDigits2,
     roundToTenths: roundToTenths,
     getRoundingFunction: getRoundingFunction,
     getBoundsPrecisionForDisplay: getBoundsPrecisionForDisplay,
@@ -8938,15 +8957,15 @@
     });
   }
 
-  function addUtils(env) {
+  function cleanExpression(exp) {
+    // workaround for problem in GNU Make v4: end-of-line backslashes inside
+    // quoted strings are left in the string (other shell environments remove them)
+    return exp.replace(/\\\n/g, ' ');
+  }
+
+  function addFeatureExpressionUtils(env) {
     Object.assign(env, {
-      round: function(val, dig) {
-        var k = 1;
-        if (!val && val !== 0) return val; // don't coerce null to 0
-        dig = dig | 0;
-        while(dig-- > 0) k *= 10;
-        return Math.round(val * k) / k;
-      },
+      round: roundToDigits2,
       int_median: interpolated_median,
       sprintf: utils.format,
       blend: blend
@@ -9325,6 +9344,47 @@
     };
   }
 
+  // Returns an object representing a layer in a JS expression
+  function getLayerProxy(lyr, arcs) {
+    var obj = {};
+    var records = lyr.data ? lyr.data.getRecords() : null;
+    var getters = {
+      name: lyr.name,
+      data: records,
+      type: lyr.geometry_type,
+      size: getFeatureCount(lyr),
+      empty: getFeatureCount(lyr) === 0
+    };
+    addGetters(obj, getters);
+    addBBoxGetter(obj, lyr, arcs);
+    obj.field_exists = function(name) {
+      return lyr.data && lyr.data.fieldExists(name) ? true : false;
+    };
+    obj.field_type = function(name) {
+      return lyr.data && getColumnType(name, lyr.data.getRecords()) || null;
+    };
+    obj.field_includes = function(name, val) {
+      if (!lyr.data) return false;
+      return lyr.data.getRecords().some(function(rec) {
+        return rec && (rec[name] === val);
+      });
+    };
+    return obj;
+  }
+
+  function addLayerGetters(ctx, lyr, arcs) {
+    var layerProxy;
+    addGetters(ctx, {
+      layer_name: lyr.name || '', // consider removing this
+      layer: function() {
+        // init on first access (to avoid overhead if not used)
+        if (!layerProxy) layerProxy = getLayerProxy(lyr, arcs);
+        return layerProxy;
+      }
+    });
+    return ctx;
+  }
+
   function addBBoxGetter(obj, lyr, arcs) {
     var bbox;
     addGetters(obj, {
@@ -9354,32 +9414,6 @@
     return bbox;
   }
 
-  // Returns an object representing a layer in a JS expression
-  function getLayerProxy(lyr, arcs) {
-    var obj = {};
-    var records = lyr.data ? lyr.data.getRecords() : null;
-    var getters = {
-      name: lyr.name,
-      data: records
-    };
-    addGetters(obj, getters);
-    addBBoxGetter(obj, lyr, arcs);
-    return obj;
-  }
-
-  function addLayerGetters(ctx, lyr, arcs) {
-    var layerProxy;
-    addGetters(ctx, {
-      layer_name: lyr.name || '', // consider removing this
-      layer: function() {
-        // init on first access (to avoid overhead if not used)
-        if (!layerProxy) layerProxy = getLayerProxy(lyr, arcs);
-        return layerProxy;
-      }
-    });
-    return ctx;
-  }
-
   // Returns a function to return a feature proxy by id
   // (the proxy appears as "this" or "$" in a feature expression)
   function initFeatureProxy(lyr, arcs, optsArg) {
@@ -9576,11 +9610,6 @@
     return compileFeatureExpression(exp, lyr, arcs, opts);
   }
 
-  function cleanExpression(exp) {
-    // workaround for problem in GNU Make v4: end-of-line backslashes inside
-    // quoted strings are left in the string (other shell environments remove them)
-    return exp.replace(/\\\n/g, ' ');
-  }
 
   function compileFeaturePairFilterExpression(exp, lyr, arcs) {
     var func = compileFeaturePairExpression(exp, lyr, arcs);
@@ -9716,14 +9745,19 @@
 
   function compileExpressionToFunction(exp, opts) {
     // $$ added to avoid duplication with data field variables (an error condition)
-    var functionBody = "with($$env){with($$record){ " + (opts.returns ? 'return ' : '') +
-          exp + "}}";
-    var func;
+    var functionBody, func;
+    if (opts.returns) {
+      // functionBody = 'return ' + functionBody;
+      functionBody = 'var $$retn = ' + exp + '; return $$retn;';
+    } else {
+      functionBody = exp;
+    }
+    functionBody = 'with($$env){with($$record){ ' + functionBody + '}}';
     try {
-      func = new Function("$$record,$$env",  functionBody);
+      func = new Function('$$record,$$env',  functionBody);
     } catch(e) {
       // if (opts.quiet) throw e;
-      stop(e.name, "in expression [" + exp + "]");
+      stop(e.name, 'in expression [' + exp + ']');
     }
     return func;
   }
@@ -9766,7 +9800,7 @@
     var ctx = {};
     var fields = lyr.data ? lyr.data.getFields() : [];
     opts = opts || {};
-    addUtils(env); // mix in round(), sprintf(), etc.
+    addFeatureExpressionUtils(env); // mix in round(), sprintf(), etc.
     if (fields.length > 0) {
       // default to null values, so assignments to missing data properties
       // are applied to the data record, not the global object
@@ -9821,7 +9855,6 @@
   var Expressions = /*#__PURE__*/Object.freeze({
     __proto__: null,
     compileValueExpression: compileValueExpression,
-    cleanExpression: cleanExpression,
     compileFeaturePairFilterExpression: compileFeaturePairFilterExpression,
     compileFeaturePairExpression: compileFeaturePairExpression,
     compileFeatureExpression: compileFeatureExpression,
@@ -18564,6 +18597,13 @@ ${svg}
       return this;
     };
 
+    this.options = function(o) {
+      Object.keys(o).forEach(function(key) {
+        this.option(key, o[key]);
+      }, this);
+      return this;
+    };
+
     this.done = function() {
       return _command;
     };
@@ -19527,14 +19567,6 @@ ${svg}
       .option('target', targetOpt)
       .option('no-replace', noReplaceOpt);
 
-    parser.command('ignore')
-      // .describe('stop processing if a condition is met')
-      .option('empty', {
-        describe: 'ignore empty files',
-        type: 'flag'
-      })
-      .option('target', targetOpt);
-
     parser.command('include')
       .describe('import JS data and functions for use in JS expressions')
       .option('file', {
@@ -20093,33 +20125,22 @@ ${svg}
      .option('target', targetOpt);
 
     parser.command('symbols')
-      // .describe('symbolize points as polygons, circles, stars or arrows')
+      .describe('symbolize points as arrows, circles, stars, polygons, etc.')
       .option('type', {
-        describe: 'symbol type (e.g. star, polygon, circle, arrow)'
+        describe: 'symbol type (e.g. arrow, circle, square, star, polygon, ring)'
       })
-      .option('scale', {
-        describe: 'scale symbols by a factor',
-        type: 'number'
-      })
-      .option('pixel-scale', {
-        describe: 'symbol scale in meters-per-pixel (see polygons option)',
-        type: 'number',
+      .option('stroke', {})
+      .option('stroke-width', {})
+      .option('fill', {
+        describe: 'symbol fill color'
       })
       .option('polygons', {
         describe: 'generate symbols as polygons instead of SVG objects',
         type: 'flag'
       })
-      .option('radius', {
-        describe: 'distance from center to farthest point on the symbol',
-        type: 'distance'
-      })
-      .option('sides', {
-        describe: 'number of sides of a polygon symbol',
-        type: 'number'
-      })
-      .option('orientation', {
-        // TODO: removed (replaced by flipped and rotated)
-        // describe: 'use orientation=b for a rotated or flipped orientation'
+      .option('pixel-scale', {
+        describe: 'set symbol scale in meters-per-pixel (for polygons option)',
+        type: 'number',
       })
       // .option('flipped', {
       //   type: 'flag',
@@ -20127,11 +20148,23 @@ ${svg}
       // })
       .option('rotated', {
         type: 'flag',
-        describe: 'symbol is rotated to a different orientation'
+        describe: 'symbol is rotated to an alternate orientation'
       })
       .option('rotation', {
         describe: 'rotation of symbol in degrees'
       })
+      .option('scale', {
+        describe: 'scale symbols by a multiplier',
+        type: 'number'
+      })
+      .option('radius', {
+        describe: 'distance from center to farthest point on the symbol',
+        type: 'distance'
+      })
+      .option('sides', {
+        describe: '(polygon) number of sides of a (regular) polygon symbol',
+        type: 'number'
+      })
       .option('points', {
         describe: '(star) number of points'
       })
@@ -20149,7 +20182,7 @@ ${svg}
       })
       .option('direction', {
         old_alias: 'arrow-direction',
-        describe: '(arrow) angle off vertical (-90 = left-pointing)'
+        describe: '(arrow) angle off of vertical (-90 = left-pointing)'
       })
       .option('head-angle', {
         old_alias: 'arrow-head-angle',
@@ -20184,17 +20217,12 @@ ${svg}
       })
       .option('min-stem-ratio', {
         old_alias: 'arrow-min-stem',
-        describe: '(arrow) min ratio of stem to total length',
+        describe: '(arrow) minimum ratio of stem to total length',
         type: 'number'
       })
       .option('anchor', {
         describe: '(arrow) takes one of: start, middle, end (default is start)'
       })
-      .option('stroke', {})
-      .option('stroke-width', {})
-      .option('fill', {
-        describe: 'symbol fill color'
-      })
       .option('effect', {})
       // .option('where', whereOpt)
       .option('name', nameOpt)
@@ -20497,6 +20525,49 @@ ${svg}
       })
       .option('target', targetOpt);
 
+    parser.section('Control flow commands');
+
+    var ifOpts = {
+      expression: {
+        DEFAULT: true,
+        describe: 'JS expression targeting a single layer'
+      },
+      empty: {
+        describe: 'run if layer is empty',
+        type: 'flag'
+      },
+      'not-empty': {
+        describe: 'run if layer is not empty',
+        type: 'flag'
+      },
+      layer: {
+        describe: 'name or id of layer to test (default is current target)'
+      },
+      target: targetOpt
+    };
+
+    parser.command('if')
+      .describe('run the following commands if a condition is met')
+      .options(ifOpts);
+
+    parser.command('elif')
+      .describe('test an alternate condition; used after -if')
+      .options(ifOpts);
+
+    parser.command('else')
+      .describe('run commands if all preceding -if/-elif conditions are false');
+
+    parser.command('endif')
+      .describe('mark the end of an -if sequence');
+
+    parser.command('ignore')
+      // .describe('stop processing if a condition is met')
+      .option('empty', {
+        describe: 'ignore empty files',
+        type: 'flag'
+      })
+      .option('target', targetOpt);
+
     parser.section('Informational commands');
 
     parser.command('calc')
@@ -20540,6 +20611,10 @@ ${svg}
       .option('target', targetOpt)
       .validate(validateExpressionOpt);
 
+    parser.command('print')
+      .describe('print a message to stdout')
+      .flag('multi_arg');
+
     parser.command('projections')
       .describe('print list of supported projections');
 
@@ -34169,6 +34244,141 @@ ${svg}
     };
   }
 
+  function resetControlFlow() {
+    setStateVar('control', null);
+  }
+
+  function inControlBlock() {
+    var state = getState();
+    return !!state.inControlBlock;
+  }
+
+  function enterActiveBranch() {
+    var state = getState();
+    state.inControlBlock = true;
+    state.active = true;
+    state.complete = true;
+  }
+
+  function enterInactiveBranch() {
+    var state = getState();
+    state.inControlBlock = true;
+    state.active = false;
+  }
+
+  function blockWasActive() {
+    return !!getState().complete;
+  }
+
+  function inActiveBranch() {
+    return !!getState().active;
+  }
+
+  function getState() {
+    var o = getStateVar('control') || setStateVar('control', {}) || getStateVar('control');
+    return o;
+  }
+
+  function compileLayerExpression(expr, lyr, dataset, opts) {
+    var proxy = getLayerProxy(lyr, dataset.arcs, opts);
+    var exprOpts = Object.assign({returns: true}, opts);
+    var func = compileExpressionToFunction(expr, exprOpts);
+    var ctx = proxy;
+    return function() {
+      try {
+        return func.call(proxy, {}, ctx);
+      } catch(e) {
+        // if (opts.quiet) throw e;
+        stop(e.name, "in expression [" + expr + "]:", e.message);
+      }
+    };
+  }
+
+  function skipCommand(cmdName) {
+    // allow all control commands to run
+    if (isControlFlowCommand(cmdName)) return false;
+    return inControlBlock() && !inActiveBranch();
+  }
+
+  cmd.if = function(catalog, opts) {
+    if (inControlBlock()) {
+      stop('Nested -if commands are not supported.');
+    }
+    evaluateIf(catalog, opts);
+  };
+
+  cmd.elif = function(catalog, opts) {
+    if (!inControlBlock()) {
+      stop('-elif command must be preceded by an -if command.');
+    }
+    evaluateIf(catalog, opts);
+  };
+
+  cmd.else = function() {
+    if (!inControlBlock()) {
+      stop('-else command must be preceded by an -if command.');
+    }
+    if (blockWasActive()) {
+      enterInactiveBranch();
+    } else {
+      enterActiveBranch();
+    }
+  };
+
+  cmd.endif = function() {
+    if (!inControlBlock()) {
+      stop('-endif command must be preceded by an -if command.');
+    }
+    resetControlFlow();
+  };
+
+  function isControlFlowCommand(cmd) {
+    return ['if','elif','else','endif'].includes(cmd);
+  }
+
+  function testLayer(catalog, opts) {
+    var targ = getTargetLayer(catalog, opts);
+    if (opts.expression) {
+      return compileLayerExpression(opts.expression, targ.layer, targ.dataset, opts)();
+    }
+    if (opts.empty) {
+      return layerIsEmpty(targ.layer);
+    }
+    if (opts.not_empty) {
+      return !layerIsEmpty(targ.layer);
+    }
+    return true;
+  }
+
+  function evaluateIf(catalog, opts) {
+    if (!blockWasActive() && testLayer(catalog, opts)) {
+      enterActiveBranch();
+    } else {
+      enterInactiveBranch();
+    }
+  }
+
+  // layerId: optional layer identifier
+  //
+  function getTargetLayer(catalog, opts) {
+    var layerId = opts.layer || opts.target;
+    var targets = catalog.findCommandTargets(layerId);
+    if (targets.length === 0) {
+      if (layerId) {
+        stop('Layer not found:', layerId);
+      } else {
+        stop('Missing a target layer.');
+      }
+    }
+    if (targets.length > 1 || targets[0].layers.length > 1) {
+      stop('Command requires a single target layer.');
+    }
+    return {
+      layer: targets[0].layers[0],
+      dataset: targets[0].dataset
+    };
+  }
+
   cmd.ignore = function(targetLayer, dataset, opts) {
     if (opts.empty && layerIsEmpty(targetLayer)) {
       interrupt('Layer is empty, stopping processing');
@@ -34715,6 +34925,28 @@ ${svg}
     return findVertexIds(p2.x, p2.y, arcs);
   }
 
+  // Given a location @p (e.g. corresponding to the mouse pointer location),
+  // find the midpoint of two vertices on @shp suitable for inserting a new vertex,
+  // but only if:
+  //   1. point @p is closer to the midpoint than either adjacent vertex
+  //   2. the segment containing @p is longer than a minimum distance in pixels.
+  //
+  function findInsertionPoint(p, shp, arcs, pixelSize) {
+    var p2 = findNearestVertex(p[0], p[1], shp, arcs);
+
+  }
+
+  function snapVerticesToPoint(ids, p, arcs, final) {
+    ids.forEach(function(idx) {
+      setVertexCoords(p[0], p[1], idx, arcs);
+    });
+    if (final) {
+      // kludge to get dataset to recalculate internal bounding boxes
+      arcs.transformPoints(function() {});
+    }
+  }
+
+
   // p: point to snap
   // ids: ids of nearby vertices, possibly including an arc endpoint
   function snapPointToArcEndpoint(p, ids, arcs) {
@@ -34801,6 +35033,8 @@ ${svg}
   var VertexUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     findNearestVertices: findNearestVertices,
+    findInsertionPoint: findInsertionPoint,
+    snapVerticesToPoint: snapVerticesToPoint,
     snapPointToArcEndpoint: snapPointToArcEndpoint,
     findVertexIds: findVertexIds,
     getVertexCoords: getVertexCoords,
@@ -36416,6 +36650,10 @@ ${svg}
     };
   }
 
+  cmd.print = function(msgArg) {
+    print(msgArg || '');
+  };
+
   cmd.renameLayers = function(layers, names, catalog) {
     if (names && names.join('').indexOf('=') > -1) {
       renameByAssignment(names, catalog);
@@ -38088,7 +38326,8 @@ ${svg}
   }
 
   function calcArrowSize(d) {
-    var totalLen = d.radius || d.length || d.r || 0,
+    // don't display arrows with negative length
+    var totalLen = Math.max(d.radius || d.length || d.r || 0, 0),
         scale = 1,
         o = initArrowSize(d); // calc several parameters
 
@@ -38187,7 +38426,9 @@ ${svg}
     if (d.anchor == 'end') {
       scaleAndShiftCoords(coords, 1, [-dx, -dy - headLen]);
     } else if (d.anchor == 'middle') {
-      scaleAndShiftCoords(coords, 1, [-dx/2, (-dy - headLen)/2]);
+      // shift midpoint away from the head a bit for a more balanced placement
+      // scaleAndShiftCoords(coords, 1, [-dx/2, (-dy - headLen)/2]);
+      scaleAndShiftCoords(coords, 1, [-dx * 0.5, -dy * 0.5 - headLen * 0.25]);
     }
 
     rotateCoords(coords, direction);
@@ -38864,8 +39105,13 @@ ${svg}
         targets,
         targetDataset,
         targetLayers,
+        target,
         arcs;
 
+    if (skipCommand(name)) {
+      return done(null);
+    }
+
     try { // catch errors from synchronous functions
 
       T$1.start();
@@ -38915,7 +39161,7 @@ ${svg}
         }
         if (!(name == 'graticule' || name == 'i' || name == 'help' ||
             name == 'point-grid' || name == 'shape' || name == 'rectangle' ||
-            name == 'include')) {
+            name == 'include' || name == 'print')) {
           throw new UserError("No data is available");
         }
       }
@@ -39032,6 +39278,14 @@ ${svg}
           outputLayers = targetDataset.layers; // kludge to allow layer naming below
         }
 
+      } else if (name == 'if' || name == 'elif') {
+        // target = findSingleTargetLayer(opts.layer, targets[0], catalog);
+        // cmd[name](target.layer, target.dataset, opts);
+        cmd[name](catalog, opts);
+
+      } else if (name == 'else' || name == 'endif') {
+        cmd[name]();
+
       } else if (name == 'ignore') {
         applyCommandToEachLayer(cmd.ignore, targetLayers, targetDataset, opts);
 
@@ -39092,6 +39346,9 @@ ${svg}
       } else if (name == 'polygons') {
         outputLayers = cmd.polygons(targetLayers, targetDataset, opts);
 
+      } else if (name == 'print') {
+        cmd.print(command._.join(' '));
+
       } else if (name == 'proj') {
         initProjLibrary(opts, function() {
           var err = null;
@@ -39264,6 +39521,7 @@ ${svg}
     });
   }
 
+
   // Apply a command to an array of target layers
   function applyCommandToEachLayer(func, targetLayers) {
     var args = utils.toArray(arguments).slice(2);
@@ -39522,6 +39780,8 @@ ${svg}
   }
 
   function runParsedCommands2(commands, catalog, cb) {
+    // resetting closes any unterminated -if blocks from a previous command sequence
+    resetControlFlow();
     utils.reduceAsync(commands, catalog, nextCommand, cb);
 
     function nextCommand(catalog, cmd, next) {

package/www/nacis/Makefile

@@ -0,0 +1,22 @@
+
+map:
+	mapshaper countyp010.shp name=counties \
+		-filter 'STATE_FIPS < 72' \
+		-filter 'COUNTY != ""' \
+		-dissolve FIPS copy-fields=STATE \
+		-simplify 2% \
+		-proj albersusa \
+		-points inner + name=points \
+		-i 2012-president-general-counties.csv string-fields=fips name=data \
+		-filter-fields fips,votes,obama,romney \
+		-each 'margin = obama - romney' \
+		-each 'absmargin = Math.abs(margin)' \
+		-join target=points data keys=FIPS,fips \
+		-sort absmargin descending \
+		-svg-style r='Math.sqrt(absmargin) * 0.02' \
+		-svg-style opacity=0.5 fill='margin > 0 ? "#0061aa" : "#cc0000"' \
+		-lines STATE target=counties \
+		-svg-style stroke="#ddd" where='TYPE == "inner"' \
+		-svg-style stroke="#777" where='TYPE == "outer"' \
+		-svg-style stroke="#999" where='TYPE == "STATE"' \
+		-o map.svg target=counties,points