Update charted to 0.4.8 and roll

packages/charted/lib/charts/src/cartesian_area_impl.dart

 //
 // Copyright 2014 Google Inc. All rights reserved.
 //
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file or at
 // https://developers.google.com/open-source/licenses/bsd
 //
 
 part of charted.charts;
 
@@ skipping 66 matching lines @@
   ChartConfig _config;
   bool _autoUpdate = false;
 
   SelectionScope _scope;
   Selection _svg;
   Selection visualization;
 
   Iterable<ChartSeries> _series;
 
   bool _pendingLegendUpdate = false;
+  bool _pendingAxisConfigUpdate = false;
   List<ChartBehavior> _behaviors = new List<ChartBehavior>();
   Map<ChartSeries, _ChartSeriesInfo> _seriesInfoCache = new Map();
 
   StreamController<ChartEvent> _valueMouseOverController;
   StreamController<ChartEvent> _valueMouseOutController;
   StreamController<ChartEvent> _valueMouseClickController;
   StreamController<ChartArea> _chartAxesUpdatedController;
 
   DefaultCartesianAreaImpl(
       this.host,
@@ skipping 31 matching lines @@
       _valueMouseOutController = null;
     }
     if (_valueMouseClickController != null) {
       _valueMouseClickController.close();
       _valueMouseClickController = null;
     }
     if (_chartAxesUpdatedController != null) {
       _chartAxesUpdatedController.close();
       _chartAxesUpdatedController = null;
     }
+    if (_behaviors.isNotEmpty) {
+      _behaviors.forEach((behavior) => behavior.dispose());
+    }
   }
 
   static bool isNotInline(Element e) =>
       e != null && e.getComputedStyle().display != 'inline';
 
   /// Set new data for this chart. If [value] is [Observable], subscribes to
   /// changes and updates the chart when data changes.
   @override
   set data(ChartData value) {
     _data = value;
@@ skipping 11 matching lines @@
   @override
   ChartData get data => _data;
 
   /// Set new config for this chart. If [value] is [Observable], subscribes to
   /// changes and updates the chart when series or dimensions change.
   @override
   set config(ChartConfig value) {
     _config = value;
     _configEventsDisposer.dispose();
     _pendingLegendUpdate = true;
+    _pendingAxisConfigUpdate = true;
 
     if (_config != null && _config is Observable) {
       _configEventsDisposer.add((_config as Observable).changes.listen((_) {
+        _pendingAxisConfigUpdate = true;
         _pendingLegendUpdate = true;
         draw();
       }));
     }
   }
 
   @override
   ChartConfig get config => _config;
 
   @override
@@ skipping 11 matching lines @@
   /// Gets measure axis from cache - creates a new instance of _ChartAxis
   /// if one was not already created for the given [axisId].
   DefaultChartAxisImpl _getMeasureAxis(String axisId) {
     _measureAxes.putIfAbsent(axisId, () {
       var axisConf = config.getMeasureAxis(axisId),
           axis = axisConf != null
               ? new DefaultChartAxisImpl.withAxisConfig(this, axisConf)
               : new DefaultChartAxisImpl(this);
       return axis;
     });
+
     return _measureAxes[axisId];
   }
 
   /// Gets a dimension axis from cache - creates a new instance of _ChartAxis
   /// if one was not already created for the given dimension [column].
   DefaultChartAxisImpl _getDimensionAxis(int column) {
     _dimensionAxes.putIfAbsent(column, () {
       var axisConf = config.getDimensionAxis(column),
           axis = axisConf != null
               ? new DefaultChartAxisImpl.withAxisConfig(this, axisConf)
@@ skipping 97 matching lines @@
           'translate(${layout.renderArea.x},${layout.renderArea.y})';
 
       selection.each((ChartSeries s, _, Element group) {
         _ChartSeriesInfo info = _seriesInfoCache[s];
         if (info == null) {
           info = _seriesInfoCache[s] = new _ChartSeriesInfo(this, s);
         }
         info.check();
         group.attributes['transform'] = transform;
         (s.renderer as CartesianRenderer)
-            .draw(group, schedulePostRender: schedulePostRender);
+            ?.draw(group, schedulePostRender: schedulePostRender);
       });
 
       // A series that was rendered earlier isn't there anymore, remove it
       selection.exit
         ..each((ChartSeries s, _, __) {
           var info = _seriesInfoCache.remove(s);
           if (info != null) {
             info.dispose();
           }
         })
         ..remove();
 
       // Notify on the stream that the chart has been updated.
       isReady = true;
       if (_chartAxesUpdatedController != null) {
         _chartAxesUpdatedController.add(this);
       }
     });
 
     // Save the list of valid series and initialize axes.
     _series = series;
+    _updateAxisConfig();
     _initAxes(preRender: preRender);
 
     // Render the chart, now that the axes layer is already in DOM.
     axesDomainCompleter.complete();
 
     // Updates the legend if required.
     _updateLegend();
   }
 
   String _orientRTL(String orientation) => orientation;
 
   /// Initialize the axes - required even if the axes are not being displayed.
   _initAxes({bool preRender: false}) {
     Map measureAxisUsers = <String, Iterable<ChartSeries>>{};
+    var keysToRemove = _measureAxes.keys.toList();
 
     // Create necessary measures axes.
     // If measure axes were not configured on the series, default is used.
     _series.forEach((ChartSeries s) {
       var measureAxisIds =
           isNullOrEmpty(s.measureAxisIds) ? MEASURE_AXIS_IDS : s.measureAxisIds;
       measureAxisIds.forEach((axisId) {
+        if (keysToRemove.contains(axisId)) {
+          keysToRemove.remove(axisId);
+        }
         _getMeasureAxis(axisId); // Creates axis if required
         var users = measureAxisUsers[axisId];
         if (users == null) {
           measureAxisUsers[axisId] = [s];
         } else {
           users.add(s);
         }
       });
     });
 
+    for (var key in keysToRemove) {
+      _measureAxes.remove(key);
+    }
+
     // Now that we know a list of series using each measure axis, configure
     // the input domain of each axis.
     measureAxisUsers.forEach((id, listOfSeries) {
       var sampleCol = listOfSeries.first.measures.first,
           sampleColSpec = data.columns.elementAt(sampleCol),
           axis = _getMeasureAxis(id);
       List domain;
 
       if (sampleColSpec.useOrdinalScale) {
         throw new UnsupportedError(
@@ skipping 189 matching lines @@
           index: i,
           label: data.columns.elementAt(i).label,
           series: s,
           color: theme.getColorForKey(i)));
     });
 
     _config.legend.update(legend, this);
     _pendingLegendUpdate = false;
   }
 
+  // Updates the AxisConfig, if configuration chagned since the last time the
+  // AxisConfig was updated.
+  _updateAxisConfig() {
+    if (!_pendingAxisConfigUpdate) return;
+    _series.forEach((ChartSeries s) {
+      var measureAxisIds =
+          isNullOrEmpty(s.measureAxisIds) ? MEASURE_AXIS_IDS : s.measureAxisIds;
+      measureAxisIds.forEach((axisId) {
+        var axis = _getMeasureAxis(axisId); // Creates axis if required
+        axis.config = config.getMeasureAxis(axisId);
+      });
+    });
+
+    int dimensionAxesCount = useTwoDimensionAxes ? 2 : 1;
+    config.dimensions.take(dimensionAxesCount).forEach((int column) {
+      var axis = _getDimensionAxis(column);
+      axis.config = config.getDimensionAxis(column);
+    });
+
+    _pendingAxisConfigUpdate = false;
+  }
+
   @override
   Stream<ChartEvent> get onMouseUp =>
       host.onMouseUp.map((MouseEvent e) => new DefaultChartEventImpl(e, this));
 
   @override
   Stream<ChartEvent> get onMouseDown => host.onMouseDown
       .map((MouseEvent e) => new DefaultChartEventImpl(e, this));
 
   @override
   Stream<ChartEvent> get onMouseOver => host.onMouseOver
@@ skipping 141 matching lines @@
       }
     }
     _renderer = _series.renderer;
   }
 
   dispose() {
     _renderer?.dispose();
     _disposer.dispose();
   }
 }