Add events in barback to bubble up the dirty bit.

pkg/barback/lib/src/transform_node.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library barback.transform_node;
 
 import 'dart:async';
 
 import 'asset.dart';
 import 'asset_id.dart';
@@ skipping 27 matching lines @@
   /// began running.
   bool get isDirty => _isDirty;
   var _isDirty = true;
 
   /// The subscriptions to each input's [AssetNode.onStateChange] stream.
   var _inputSubscriptions = new Map<AssetId, StreamSubscription>();
 
   /// The controllers for the asset nodes emitted by this node.
   var _outputControllers = new Map<AssetId, AssetNodeController>();
 
+  /// A stream that emits an event whenever this transform becomes dirty and
+  /// needs to be re-run.
+  ///
+  /// This may emit events when the transform was already dirty or while
+  /// processing transforms. Events are emitted synchronously to ensure that the
+  /// dirty state is thoroughly propagated as soon as any assets are changed.
+  Stream get onDirty => _onDirtyController.stream;
+  final _onDirtyController = new StreamController.broadcast(sync: true);
+
   TransformNode(this.phase, this.transformer, this.primary) {
     _primarySubscription = primary.onStateChange.listen((state) {
       if (state.isRemoved) {
         remove();
       } else {
         _dirty();
       }
     });
   }
 
   /// Marks this transform as removed.
   ///
   /// This causes all of the transform's outputs to be marked as removed as
   /// well. Normally this will be automatically done internally based on events
   /// from the primary input, but it's possible for a transform to no longer be
   /// valid even if its primary input still exists.
   void remove() {
     _isDirty = true;
+    _onDirtyController.close();
     _primarySubscription.cancel();
     for (var subscription in _inputSubscriptions.values) {
       subscription.cancel();
     }
     for (var controller in _outputControllers.values) {
       controller.setRemoved();
     }
   }
 
   /// Marks this transform as dirty.
   ///
   /// This causes all of the transform's outputs to be marked as dirty as well.
   void _dirty() {
     _isDirty = true;
     for (var controller in _outputControllers.values) {
       controller.setDirty();
     }
+    _onDirtyController.add(null);
   }
 
   /// Applies this transform.
   ///
   /// Returns a set of asset nodes representing the outputs from this transform
   /// that weren't emitted last time it was run.
   Future<Set<AssetNode>> apply() {
     var newOutputs = new AssetSet();
     var transform = createTransform(this, newOutputs);
 
@@ skipping 80 matching lines @@
       } else {
         var controller = new AssetNodeController.available(asset);
         _outputControllers[asset.id] = controller;
         brandNewOutputs.add(controller.node);
       }
     }
 
     return brandNewOutputs;
   }
 }