mapshaper 0.7.68 → 0.7.69

package/www/mapshaper.js

@@ -25424,6 +25424,9 @@
   // type/data accessors -- doesn't form an import cycle with the
   // scalebar-aware renderer registry that lives in furniture.mjs.
 
+  // Must match the renderers registered in mapshaper-furniture.mjs
+  var furnitureTypes = ['scalebar'];
+
   // @lyr dataset layer
   function getFurnitureLayerType(lyr) {
     var rec = lyr.data && lyr.data.getReadOnlyRecordAt(0);
@@ -25434,6 +25437,12 @@
     return lyr.data && lyr.data.getReadOnlyRecordAt(0);
   }
 
+  // A data-only layer holding the settings of a map element such as a scalebar
+  function layerIsFurniture(lyr) {
+    return !!lyr && !lyr.geometry_type &&
+      furnitureTypes.includes(getFurnitureLayerType(lyr));
+  }
+
   /*
   {
     width: size[0],
@@ -25629,6 +25638,27 @@
     });
   }
 
+  // Furniture (scalebars, etc.) belongs to a frame by sharing its dataset.
+  // Furniture in a dataset without a frame is an ordinary standalone layer.
+  function getFrameFurnitureLayers(dataset) {
+    if (!dataset || !findFrameLayerInDataset(dataset)) return [];
+    return dataset.layers.filter(layerIsFurniture);
+  }
+
+  function findFrameFurnitureLayer(dataset, type) {
+    return getFrameFurnitureLayers(dataset).find(function(lyr) {
+      return getFurnitureLayerType(lyr) == type;
+    }) || null;
+  }
+
+  // True for a map frame and for the furniture that belongs to it: layers that
+  // describe the map layout rather than holding map content.
+  function isFrameComponentLayer(lyr, dataset) {
+    if (!dataset) return false;
+    if (isFrameLayer(lyr, dataset.arcs)) return true;
+    return layerIsFurniture(lyr) && !!findFrameLayerInDataset(dataset);
+  }
+
   function findFrames(catalog) {
     return catalog.getLayers().filter(function(o) {
       return isFrameLayer(o.layer, o.dataset.arcs);
@@ -25855,6 +25885,7 @@
     demoteFrameLayer: demoteFrameLayer,
     findFrame: findFrame,
     findFrameDataset: findFrameDataset,
+    findFrameFurnitureLayer: findFrameFurnitureLayer,
     findFrameLayer: findFrameLayer,
     findFrameLayerInDataset: findFrameLayerInDataset,
     findFrames: findFrames,
@@ -25863,11 +25894,13 @@
     frameReservedFields: frameReservedFields,
     getActiveFrame: getActiveFrame,
     getFrameData: getFrameData,
+    getFrameFurnitureLayers: getFrameFurnitureLayers,
     getFrameLayerBounds: getFrameLayerBounds,
     getFrameLayerData: getFrameLayerData,
     getFrameSize: getFrameSize,
     getMapFrameMetersPerPixel: getMapFrameMetersPerPixel,
     getSingleFrameRecord: getSingleFrameRecord,
+    isFrameComponentLayer: isFrameComponentLayer,
     isFrameLayer: isFrameLayer,
     isFrameReservedField: isFrameReservedField,
     parseFrameSize: parseFrameSize,
@@ -25875,12 +25908,53 @@
     resolveExportFrame: resolveExportFrame
   });
 
+  // Adds a furniture layer as a standalone dataset, without changing the
+  // default target (so a following -o still exports the content layers)
   function addFurnitureLayer(lyr, catalog) {
     var o = {
       info: {},
       layers: [lyr]
     };
+    catalog.captureCatalogBefore({operation: 'addFurnitureLayer'});
     catalog.getDatasets().push(o);
+    catalog.markCatalogChanged({operation: 'addFurnitureLayer'});
+  }
+
+  // Adds a furniture layer to a frame's dataset, replacing any existing
+  // furniture of the same type. Passing a null layer removes it.
+  // Returns the replaced or removed layer, if any
+  function setFrameFurnitureLayer(frameDataset, type, lyr) {
+    var layers = frameDataset.layers;
+    var idx = layers.findIndex(function(o) {
+      return layerIsFurniture(o) && getFurnitureLayerType(o) == type;
+    });
+    var prev = idx > -1 ? layers[idx] : null;
+    if (!prev && !lyr) return null;
+    noteDatasetWillChange(frameDataset, {operation: 'setFrameFurniture', unit: 'layers'});
+    layers = layers.slice();
+    if (prev && lyr) {
+      lyr.name = prev.name;
+      layers[idx] = lyr;
+    } else if (prev) {
+      layers.splice(idx, 1);
+    } else {
+      layers.push(lyr);
+    }
+    frameDataset.layers = layers;
+    markDatasetChanged(frameDataset, {operation: 'setFrameFurniture', unit: 'layers'});
+    return prev;
+  }
+
+  // Moves a replaced frame's furniture into the dataset of the frame replacing it
+  function moveFrameFurniture(fromDataset, toDataset) {
+    var furniture = fromDataset.layers.filter(layerIsFurniture);
+    if (furniture.length === 0) return;
+    noteDatasetWillChange(fromDataset, {operation: 'moveFrameFurniture', unit: 'layers'});
+    fromDataset.layers = fromDataset.layers.filter(function(lyr) {
+      return !furniture.includes(lyr);
+    });
+    markDatasetChanged(fromDataset, {operation: 'moveFrameFurniture', unit: 'layers'});
+    toDataset.layers = toDataset.layers.concat(furniture);
   }
 
   // Pure geometry-to-SVG-path primitives. Extracted from geojson-to-svg.mjs
@@ -28425,22 +28499,60 @@
     symbolRenderers: symbolRenderers
   });
 
+  // Command options that are stored in the scalebar's data record
+  var scalebarFields = ['label', 'units', 'style', 'font_size', 'font_family',
+    'font_style', 'font_weight', 'color', 'tic_length', 'bar_width', 'label_offset',
+    'position', 'label_position', 'dual_units', 'margin'];
+
+  // With a map frame, the scalebar belongs to the frame, and running the
+  // command again replaces it. Without a frame, each run adds a standalone
+  // scalebar layer, which is exported if it is included in the output layers.
   cmd.scalebar = function(catalog, opts) {
+    var frame = getActiveFrame(catalog);
+    if (opts.remove) {
+      if (!frame || !setFrameFurnitureLayer(frame.dataset, 'scalebar', null)) {
+        stop$1('The map frame has no scalebar to remove');
+      }
+      return;
+    }
+    validateScalebarOpts(opts);
     var lyr = getScalebarLayer(opts);
-    if (opts.label && !parseScalebarUnits(opts.label)) {
-      stop$1(`Expected units of km or miles in scalebar label (received ${opts.label})`);
+    if (frame) {
+      setFrameFurnitureLayer(frame.dataset, 'scalebar', lyr);
+    } else {
+      addFurnitureLayer(lyr, catalog);
     }
-    addFurnitureLayer(lyr, catalog);
   };
 
   function getScalebarLayer(opts) {
-    var obj = utils.defaults({type: 'scalebar'}, opts);
+    var rec = {type: 'scalebar'};
+    scalebarFields.forEach(function(k) {
+      if (opts[k] !== undefined && opts[k] !== null && opts[k] !== '') {
+        rec[k] = opts[k];
+      }
+    });
     return {
-      name: opts.name || 'scalebar',
-      data: new DataTable([obj])
+      name: 'scalebar',
+      data: new DataTable([rec])
     };
   }
 
+  function validateScalebarOpts(opts) {
+    if (opts.label) {
+      splitScalebarLabel(opts.label).forEach(function(str) {
+        if (!parseScalebarUnits(str) && !isBareDistance(str)) {
+          stop$1(`Expected a distance or units of km, meters, miles or feet in scalebar label (received ${str})`);
+        }
+      });
+    }
+    if (opts.units && !parseLabelUnits(opts.units)) {
+      stop$1('Unsupported scalebar units:', opts.units);
+    }
+    if (opts.style && !/^[ab]$/i.test(opts.style)) {
+      stop$1('Unsupported scalebar style:', opts.style);
+    }
+  }
+
   function renderScalebar(d, frame) {
     if (!frame.crs) {
       message('Unable to render scalebar: unknown CRS.');
@@ -28453,14 +28565,15 @@
     var opts = getScalebarOpts(d);
     var metersPerPx = getMapFrameMetersPerPixel(frame);
     var frameWidthPx = frame.width;
-    var labels = d.label ? d.label.split(',') : null;
-    var label1 = labels && labels[0] || null;
-    var props1 = parseScalebarLabel(label1 || getAutoScalebarLabel(frameWidthPx, metersPerPx, 'mile'));
-    var label2 = opts.style == 'b' && labels && labels[1] || null;
+    var labels = d.label ? splitScalebarLabel(d.label) : [];
+    var units = parseLabelUnits(d.units) || 'mile';
+    var label1 = getScalebarLabel(labels[0], frameWidthPx, metersPerPx, units);
+    var props1 = parseScalebarLabel(label1);
+    var label2 = null;
     var props2, length2;
 
     if (props1.km > 0 === false) {
-      message('Unusable scalebar label:', label1);
+      message('Unusable scalebar label:', labels[0] || '');
       return [];
     }
 
@@ -28469,6 +28582,11 @@
       stop$1("Null scalebar length");
     }
 
+    if (opts.style == 'b' && labels[1]) {
+      label2 = completeLabel(labels[1], getOtherUnits(props1.units));
+    } else if (opts.style == 'b' && opts.dual_units) {
+      label2 = getAutoSecondLabel(length1, metersPerPx, getOtherUnits(props1.units));
+    }
     if (label2) {
       props2 = parseScalebarLabel(label2);
       length2 = Math.round(props2.km / metersPerPx * 1000);
@@ -28521,8 +28639,13 @@
   };
 
   function getScalebarOpts(d) {
-    var style = d.style == 'b' || d.style == 'B' ? 'b' : 'a';
-    return Object.assign({}, defaultOpts, styleOpts[style], d, {style: style});
+    var style = d.style == 'b' || d.style == 'B' || !d.style && d.dual_units ? 'b' : 'a';
+    var opts = Object.assign({}, defaultOpts, styleOpts[style]);
+    Object.keys(d).forEach(function(k) {
+      if (d[k] !== undefined && d[k] !== null && d[k] !== '') opts[k] = d[k];
+    });
+    opts.style = style;
+    return opts;
   }
 
   function renderAsSvg(length, text, length2, text2, opts) {
@@ -28540,12 +28663,11 @@
     };
   }
 
-  // TODO: generalize to other kinds of furniture as they are developed
   function getScalebarPosition(opts) {
     var pos = opts.position || 'top-left';
     return {
-      ypos: pos.includes('top') ? 'top' : 'bottom',
-      xpos: pos.includes('left') ? 'left' : 'right'
+      ypos: pos.includes('bottom') ? 'bottom' : 'top',
+      xpos: pos.includes('right') ? 'right' : 'left'
     };
   }
 
@@ -28559,12 +28681,16 @@
         'label-text': text,
         'font-size': opts.font_size,
         'text-anchor': labelPos.anchor,
-        'dominant-baseline': labelPos.ypos == 'top' ? 'auto' : 'hanging'
+        'dominant-baseline': labelPos.ypos == 'top' ? 'auto' : 'hanging',
         //// 'dominant-baseline': labelPos == 'top' ? 'text-after-edge' : 'text-before-edge'
         // 'text-after-edge' is buggy in Safari and unsupported by Illustrator,
         // so I'm using 'hanging' and 'auto', which seem to be well supported.
         // downside: requires a kludgy multiplier to calculate scalebar height (see above)
       };
+    if (opts.color) labelOpts.fill = opts.color;
+    if (opts.font_family) labelOpts['font-family'] = opts.font_family;
+    if (opts.font_style) labelOpts['font-style'] = opts.font_style;
+    if (opts.font_weight) labelOpts['font-weight'] = opts.font_weight;
     return symbolRenderers.label(labelOpts, anchorX, anchorY);
   }
 
@@ -28624,7 +28750,7 @@
     }
     var bar = importMultiLineString(coords);
     Object.assign(bar.properties, {
-      stroke: 'black',
+      stroke: opts.color || 'black',
       fill: 'none',
       'stroke-width': opts.bar_width,
       'stroke-linecap': 'butt',
@@ -28633,35 +28759,132 @@
     return bar;
   }
 
-  // unit: 'km' || 'mile'
+  // Kilometers per unit
+  var unitSizes = {
+    km: 1,
+    m: 0.001,
+    mile: 1.60934,
+    ft: 0.0003048
+  };
+
+  // Candidate lengths for automatic labels, in ascending order of distance
+  var autoLengths = {
+    imperial: [
+      ['ft', '10 20 25 50 100 200 250 500'],
+      // note: removed 1.5 12 and 1,200
+      ['mile', '1/8 1/5 1/4 1/2 1 2 3 4 5 8 10 15 20 25 30 40 50 75 100 150 200 250 ' +
+        '300 350 400 500 750 1,000 1,500 2,000 2,500 3,000 4,000 5,000']
+    ],
+    metric: [
+      ['m', '5 10 20 25 50 100 200 250 500'],
+      ['km', '1 2 3 4 5 8 10 15 20 25 30 40 50 75 100 150 200 250 300 350 ' +
+        '400 500 750 1,000 1,500 2,000 2,500 3,000 4,000 5,000']
+    ]
+  };
+
+  function getAutoLabels(system) {
+    return autoLengths[system].reduce(function(memo, group) {
+      return memo.concat(group[1].split(' ').map(function(str) {
+        return formatDistanceLabel(str, group[0]);
+      }));
+    }, []);
+  }
+
+  function getUnitSystem(units) {
+    return units == 'km' || units == 'm' ? 'metric' : 'imperial';
+  }
+
+  function getOtherUnits(units) {
+    return getUnitSystem(units) == 'metric' ? 'mile' : 'km';
+  }
+
+  // The unit system of the units= option: returns 'km', 'mile' or ''
+  function parseUnitsOption(str) {
+    var units = parseLabelUnits(str);
+    return units ? (getUnitSystem(units) == 'metric' ? 'km' : 'mile') : '';
+  }
+
+  // Accepts the units= option, which also gives the units of a label that is a
+  // bare number; returns 'km', 'm', 'mile', 'ft' or ''
+  function parseLabelUnits(str) {
+    var s = String(str || '').toLowerCase();
+    if (/^(km|kilomet(er|re)s?|metric)$/.test(s)) return 'km';
+    if (/^(m|meters?|metres?)$/.test(s)) return 'm';
+    if (/^(mi|miles?|imperial)$/.test(s)) return 'mile';
+    if (/^(ft|feet)$/.test(s)) return 'ft';
+    return '';
+  }
+
+  // Splits a dual-unit label like "100 km,50 miles". Only a comma after the units
+  // separates two distances, so "1,000 km" and a bare "1,500" stay whole.
+  function splitScalebarLabel(label) {
+    return String(label).split(/(?<=[^\d\s]),\s*/).map(function(str) {
+      return str.trim();
+    }).filter(Boolean);
+  }
+
+  // A distance with no units, e.g. "150" or "1/2" or "1,000"
+  function isBareDistance(str) {
+    return /^[\d\s.,/]+$/.test(str) && parseScalebarNumber(str) > 0;
+  }
+
+  // Adds units to a label that is a bare number
+  function completeLabel(label, units) {
+    return isBareDistance(label) ? formatDistanceLabel(label.trim(), units) : label;
+  }
+
+  // label: a label from the label= option, or empty for an automatic label
+  function getScalebarLabel(label, frameWidthPx, metersPerPx, defaultUnits) {
+    var units;
+    if (label && parseScalebarNumber(label) > 0) return completeLabel(label, defaultUnits);
+    // A label with units but no number gets an automatic length in those units
+    units = label && parseScalebarUnits(label) || defaultUnits;
+    return getAutoScalebarLabel(frameWidthPx, metersPerPx, units);
+  }
+
+  // unit: 'km' || 'mile' (or 'm', 'ft' for the same systems)
+  // The longest length that fits within 20% of the map's width, or the shortest
+  // that is at least 70px long if the map is too narrow for that
   function getAutoScalebarLabel(mapWidth, metersPerPx, unit) {
-    var minWidth = 70; // 100; // TODO: vary min size based on map width
-    var minKm = metersPerPx * minWidth / 1000;
-    // note: removed 1.5 12 and 1,200
-    var options = ('1/8 1/5 1/4 1/2 1 2 3 4 5 8 10 15 20 25 30 40 50 75 ' +
-      '100 150 200 250 300 350 400 500 750 1,000 1,500 2,000 ' +
-      '2,500 3,000 4,000 5,000').split(' ');
-    return options.reduce(function(memo, str) {
-      if (memo) return memo;
-      var label = formatDistanceLabel(str, unit);
-      if (parseScalebarLabelToKm(label) > minKm) {
-         return label;
-      }
-    }, null) || '';
+    var minKm = metersPerPx * 70 / 1000;
+    var maxKm = metersPerPx * mapWidth * 0.2 / 1000;
+    var labels = getAutoLabels(getUnitSystem(unit));
+    var longest = labels.filter(function(label) {
+      var km = parseScalebarLabelToKm(label);
+      return km >= minKm && km <= maxKm;
+    }).pop();
+    return longest || labels.find(function(label) {
+      return parseScalebarLabelToKm(label) >= minKm;
+    }) || '';
+  }
+
+  // The longest automatic length in the given units that fits within the
+  // first part of a dual-unit scalebar
+  function getAutoSecondLabel(maxPx, metersPerPx, unit) {
+    var maxKm = maxPx * metersPerPx / 1000;
+    var minKm = maxKm / 4;
+    var labels = getAutoLabels(getUnitSystem(unit)).filter(function(label) {
+      var km = parseScalebarLabelToKm(label);
+      return km <= maxKm && km >= minKm;
+    });
+    return labels.pop() || null;
   }
 
   function formatDistanceLabel(numStr, unit) {
     var num = parseScalebarNumber(numStr);
-    var unitStr = unit == 'km' && 'KM' || num > 1 && 'MILES' || 'MILE';
+    var unitStr = unit == 'km' && 'KM' ||
+      unit == 'm' && (num > 1 ? 'METERS' : 'METER') ||
+      unit == 'ft' && (num > 1 ? 'FEET' : 'FOOT') ||
+      num > 1 && 'MILES' || 'MILE';
     return numStr + ' ' + unitStr;
   }
 
-  // See test/mapshaper-scalebar.js for examples of supported formats
+  // See test/scalebar-test.mjs for examples of supported formats
   function parseScalebarLabelToKm(str) {
     var units = parseScalebarUnits(str);
     var value = parseScalebarNumber(str);
     if (!units || !value) return NaN;
-    return units == 'mile' ? value * 1.60934 : value;
+    return value * unitSizes[units];
   }
 
   function parseScalebarLabel(label) {
@@ -28669,7 +28892,7 @@
     var units = label ? parseScalebarUnits(label) : 'mile';
     var km = NaN;
     if (units && num) {
-      km =  units == 'mile' ? num * 1.60934 : num;
+      km = num * unitSizes[units];
     }
     return {
       number: num,
@@ -28678,11 +28901,14 @@
     };
   }
 
+  // Returns 'km', 'm', 'mile', 'ft' or ''
   function parseScalebarUnits(str) {
-    var isMiles = /(miles?|mi[.]?|英里)$/.test(str.toLowerCase());
-    var isKm = /(k\.m\.|km|kilometers?|kilom.tres?|公里)$/.test(str.toLowerCase());
-    var units = isMiles && 'mile' || isKm && 'km' || '';
-    return units;
+    var s = String(str).trim().toLowerCase();
+    if (/(miles?|mi[.]?|英里)$/.test(s)) return 'mile';
+    if (/(k\.m\.|km|kilomet(er|re)s?|kilom.tres?|公里)$/.test(s)) return 'km';
+    if (/(^|[\d\s.])(feet|foot|ft[.]?|英尺)$/.test(s)) return 'ft';
+    if (/(^|[\d\s.])(m|m\.|meters?|metres?|mètres?|米)$/.test(s)) return 'm';
+    return '';
   }
 
   function parseScalebarNumber(str) {
@@ -28702,8 +28928,12 @@
     __proto__: null,
     formatDistanceLabel: formatDistanceLabel,
     getScalebarLayer: getScalebarLayer,
+    parseLabelUnits: parseLabelUnits,
     parseScalebarLabelToKm: parseScalebarLabelToKm,
-    renderScalebar: renderScalebar
+    parseScalebarUnits: parseScalebarUnits,
+    parseUnitsOption: parseUnitsOption,
+    renderScalebar: renderScalebar,
+    splitScalebarLabel: splitScalebarLabel
   });
 
   var furnitureRenderers = {
@@ -28725,24 +28955,33 @@
   function renderFurnitureLayer(lyr, frame) {
     var d = getFurnitureLayerData(lyr);
     var renderer = furnitureRenderers[d.type];
+    var problem;
     if (!renderer) {
       stop$1('Missing renderer for', d.type, 'element');
     }
-    if (!frame.crs) {
-      stop$1(`Unable to render ${d.type} (unknown map projection)`);
-    }
-    if (!isProjectedCRS(frame.crs)) {
-      stop$1(`Unable to render ${d.type} (map is unprojected)`);
+    problem = getFurnitureFrameProblem(frame);
+    if (problem) {
+      stop$1(`Unable to render ${d.type} (${problem})`);
     }
     return renderer(d, frame) || [];
   }
 
+  // Returns a reason why furniture can't be drawn in a frame, or null
+  function getFurnitureFrameProblem(frame) {
+    if (!frame) return 'missing map frame';
+    if (!frame.crs) return 'unknown map projection';
+    if (!isProjectedCRS(frame.crs)) return 'map is unprojected';
+    return null;
+  }
+
   var Furniture = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    getFurnitureFrameProblem: getFurnitureFrameProblem,
     getFurnitureLayerData: getFurnitureLayerData,
     getFurnitureLayerType: getFurnitureLayerType,
     isFurnitureLayer: isFurnitureLayer,
     layerHasFurniture: layerHasFurniture,
+    layerIsFurniture: layerIsFurniture,
     renderFurnitureLayer: renderFurnitureLayer
   });
 
@@ -39199,6 +39438,9 @@ ${svg}
   async function exportDatasets(datasets, opts) {
     var format = getOutputFormat(datasets[0], opts);
     var files;
+    if (format != 'svg' && format != PACKAGE_EXT) {
+      datasets = removeFurnitureLayers(datasets);
+    }
     validateRasterExportFormat(datasets, format);
     if (format != 'geoparquet' && opts.level !== undefined) {
       error('The level= option only applies to GeoParquet output');
@@ -39274,6 +39516,25 @@ ${svg}
     return files;
   }
 
+  // Scalebars and other map furniture only have a meaning in SVG output
+  function removeFurnitureLayers(datasets) {
+    var hasFurniture = datasets.some(function(dataset) {
+      return dataset.layers.some(layerIsFurniture);
+    });
+    if (!hasFurniture) return datasets;
+    datasets = datasets.map(function(dataset) {
+      return utils.defaults({
+        layers: dataset.layers.filter(function(lyr) { return !layerIsFurniture(lyr); })
+      }, dataset);
+    }).filter(function(dataset) {
+      return dataset.layers.length > 0;
+    });
+    if (datasets.length === 0) {
+      stop$1('Map furniture layers (e.g. scalebars) can only be exported as SVG');
+    }
+    return datasets;
+  }
+
   function validateRasterExportFormat(datasets, format) {
     if (format == 'geotiff') {
       if (datasetsHaveVectorLayers(datasets)) {
@@ -44131,10 +44392,13 @@ ${svg}
       .option('target', targetOpt);
 
     parser.command('scalebar')
-      .describe('add a simple scale bar to SVG output')
+      .describe('add a scale bar to the map frame and SVG output')
       .option('label', {
         DEFAULT: true,
-        describe: 'distance label, e.g. "35 miles"'
+        describe: 'distance label, e.g. "35 miles" (default is automatic)'
+      })
+      .option('units', {
+        describe: 'units of a bare-number or automatic label: km, meters, miles or feet (default is miles)'
       })
       .option('style', {
         describe: 'two options: a or b'
@@ -44142,6 +44406,18 @@ ${svg}
       .option('font-size', {
         type: 'number'
       })
+      .option('font-family', {
+        describe: 'font family of labels'
+      })
+      .option('font-style', {
+        describe: 'font style of labels, e.g. italic'
+      })
+      .option('font-weight', {
+        describe: 'font weight of labels, e.g. bold'
+      })
+      .option('color', {
+        describe: 'color of bar and labels (default is black)'
+      })
       .option('tic-length', {
         describe: 'length of tic marks (style b)',
         type: 'number'
@@ -44154,18 +44430,22 @@ ${svg}
         type: 'number'
       })
       .option('position', {
-        describe: 'e.g. bottom-right (default is top-left)'
+        describe: 'top-left (default), top-right, bottom-left or bottom-right'
       })
       .option('label-position', {
         describe: 'top, bottom, top-center (style a), etc'
       })
       .option('dual-units', {
-        // describe: 'display both metric and imperial units',
+        describe: 'show both metric and imperial units (style b)',
         type: 'flag'
       })
       .option('margin', {
         describe: 'offset in pixels from edge of map',
         type: 'number'
+      })
+      .option('remove', {
+        describe: 'remove the scale bar from the map frame',
+        type: 'flag'
       });
 
     parser.command('shape')
@@ -52161,8 +52441,10 @@ ${svg}
   //            May return NaN for a bbox the frame can't be fitted to.
   // @opts.ignore_symbols  fit to the coordinates alone
   function getFrameContentBbox(targets, getScale, opts) {
+    // a data-only layer has no bounds
     var bounds = targets.reduce(function(memo, o) {
-      return memo.mergeBounds(getLayerBounds(o.layer, o.dataset.arcs));
+      var b = getLayerBounds(o.layer, o.dataset.arcs);
+      return b ? memo.mergeBounds(b) : memo;
     }, new Bounds());
     var raw, items, bbox;
     if (!bounds.hasBounds()) return null;
@@ -52309,6 +52591,11 @@ ${svg}
         var extent = getFrameExtent(contentBbox, widthPx, heightPx, opts);
         return getFrameScale(extent.bbox, extent.width, getFixedAspect$1(extent, opts));
       }, opts);
+      if (!bbox && !expandCommandTargets(targets).some(function(o) {
+        return layerHasGeometry$1(o.layer);
+      })) {
+        stop$1('Unable to fit a frame to a layer with no geometry. Target a layer containing shapes, or use the bbox= option.');
+      }
       if (!bbox) {
         stop$1('Command target is missing geographical bounds');
       }
@@ -52332,14 +52619,17 @@ ${svg}
       var crsInfo = getDatasetCrsInfo(targets[0].dataset);
       setDatasetCrsInfo(frameDataset, crsInfo);
     }
-    frameDataset.layers[0].name = opts.name || 'frame';
+    var frameLyr = frameDataset.layers[0];
+    frameLyr.name = opts.name || 'frame';
     if (existingFrame) {
       if (!opts.replace) {
         stop$1('A map frame already exists:', existingFrame.layer.name || '[unnamed frame]');
       }
+      moveFrameFurniture(existingFrame.dataset, frameDataset);
       demoteFrameLayer(existingFrame.layer);
     }
-    catalog.addDataset(frameDataset);
+    // target the frame, not any furniture that came with it
+    catalog.setDefaultTarget([frameLyr], frameDataset);
   };
 
   // The frame's extent and nominal size, from the extent of its content and the
@@ -84111,7 +84401,7 @@ ${svg}
     return name == 'rectangle' || name == 'rectangles' || name == 'filter' && opts.cleanup;
   }
 
-  var version = "0.7.68";
+  var version = "0.7.69";
 
   // 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.