Update how map-feature / mapmlvectors calculates FeatureLayer.layerBounds

Update FeatureLayer to dynamically update .layerBounds if initialized
without a options.extent bounds

Apply temporary patch to get multipleExtents.test.js working in debug mode

Change FeatureLayer, no longer extend / shrink layerBounds as features
are added.

Pass layerBounds to M.featureLayer initialize via option during
initialization; use M.getBounds(mapml) to derive bounds from map-meta
in the MapMLLayer._content (in the case of MapMLLayer._mapmlvectors),
pass the derived bounds (from TemplatedFeaturesLayer.extentBounds and
TemplatedTileLayer.extentBounds) when creating a FeatureLayer in those
contexts. (templated layers' extentBounds property is derived from
their child map-input axis min/max values, with the M._extractInputBounds
utility).

Author: prushforth

src/mapml/layers/FeatureLayer.js

@@ -13,6 +13,11 @@ export var FeatureLayer = L.FeatureGroup.extend({
         2. for static templated feature: null
         3. for non-templated feature: layer- (with no src) or mapml file (with src)
       */
+    // options.extent: when you use a FeatureLayer, you can either get it to calculate the
+    // .layerBounds dynamically (the default), based on adds/removes of features from the layer/
+    // or you can construct it with a bounds (via options.extent),
+    // which will then remain static for the lifetime of the layer
+
     L.setOptions(this, options);
     if (this.options.static) {
       this._container = L.DomUtil.create(
@@ -47,13 +52,15 @@ export var FeatureLayer = L.FeatureGroup.extend({
         this._staticFeature = true;
         this.isVisible = true; //placeholder for when this actually gets updated in the future
         this.zoomBounds = M.getZoomBounds(mapml, native.zoom);
-        this.layerBounds = M.getLayerBounds(mapml);
+        this.layerBounds = M.getBounds(mapml);
         L.extend(this.options, this.zoomBounds);
       }
       this.addData(mapml, native.cs, native.zoom);
     } else if (!mapml) {
       this.isVisible = false;
-      this.layerBounds = this.options.extent;
+      this.layerBounds = this.options.layerBounds
+        ? this.options.layerBounds
+        : null;
       this.zoomBounds = this.options.zoomBounds;
     }
   },

src/mapml/layers/MapMLLayer.js

@@ -1515,7 +1515,10 @@ export var MapMLLayer = L.Layer.extend({
           pane: layer._container,
           opacity: layer.options.opacity,
           projection: layer._properties.projection,
-          extent: M.getBounds(layer._content),
+          layerBounds: M.getBounds(layer._content),
+          // by NOT passing options.extent, we are asking the FeatureLayer
+          // to dynamically update its .layerBounds property as features are
+          // added or removed from it
           native: native,
           zoomBounds: M.getZoomBounds(layer._content, native.zoom),
           // each owned child layer gets a reference to the root layer

src/mapml/layers/TemplatedFeaturesLayer.js

@@ -35,6 +35,8 @@ export var TemplatedFeaturesLayer = L.Layer.extend({
         // pass the vector layer the container for the parent into which
         // it will append its own container for rendering into
         pane: container,
+        // the bounds will be static, fixed, constant for the lifetime of the layer
+        layerBounds: this.extentBounds,
         opacity: opacity,
         projection: map.options.projection,
         static: true,

src/mapml/layers/TemplatedTileLayer.js

@@ -166,6 +166,7 @@ export var TemplatedTileLayer = L.TileLayer.extend({
     let tileFeatures = M.featureLayer(null, {
       projection: this._map.options.projection,
       static: false,
+      layerBounds: this.extentBounds,
       interactive: false
     });