react 0.6.1 → 0.7.1

package/.travis.yml

@@ -1,4 +1,7 @@
 language: node_js
 node_js:
-  - 0.6
-  - 0.7
+  - "0.6"
+  - "0.7"
+  - "0.8"
+  - "0.10"
+  - "0.11"

package/README.md

@@ -16,9 +16,15 @@ Also "Reactive Programming" or "Dataflow" describe defining flow which reacts to
 
 It takes inspiration from several projects including:
 
- - Tim Caswell and Elijah Insua's [conductor](https://github.com/creationix/conductor) - [Article](http://howtonode.org/step-of-conductor)
+ - Tim Caswell and Elijah Insua's [conductor](https://github.com/tmpvar/conductor) - [Article](http://howtonode.org/step-of-conductor)
  - Caolan McMahon's [async](https://github.com/caolan/async)
 
+## Example Video and Comparison
+
+Ryan Atkinson did a nice job of demonstrating some of the power of react as compared to async and native callback code. http://www.youtube.com/embed/5EDucc56UnA?rel=0
+
+You can read more and see his example site here https://github.com/ryanatkn/react-writeup
+
 
 ## Goals
 
@@ -38,9 +44,11 @@ It takes inspiration from several projects including:
  - class method calls
  - selectFirst flow where the first task that returns defined, non-null value is used
  - promise style functions - also automatic resolution of promise inputs (optionally loaded with `react.resolvePromises();`)
- - use of resulting flow function as callback style or promise style (if no callback provided) (provided via plugin corresponding to the promise library used) See https://github.com/jeffbski/react-deferred
+ - use of resulting flow function as callback style or promise style (if no callback provided) (provided via plugin corresponding to the promise library used) See https://github.com/jeffbski/react-deferred and https://github.com/jeffbski/react-q
+ - supports ES5 browsers (can work with others by using polyfills)
  - (planned) iteration on arrays, streams, sockets
  - (planned) event emitter integration
+ - tested on node 0.8, 0.10, 0.11
 
 The tasks can be mixed, meaning you can use async, sync, object method calls, class method calls, etc in the same flow.
 
@@ -156,7 +164,7 @@ var fn = react('loadRender', 'fooPath, barPath, barP2, cb -> err, renderedOut',
 
  1. **flow/function name** - string - represents the name of the flow or function that will be created. React will use the name when generating events so you can monitor progress and performance and also when errors occur.
  2. **in/out flow parameter definition** - string - the inputs and outputs for the flow function. The parameters are specified in one single string for easy typing, separated by commas. The output follows the input after being separated by a `->`. Use the parameter name `cb` or `callback` to specify the Node style callback and `err` to represent the error parameter as the first output parameter of the callback. Literal values can also be specified directly (true, false, numbers, this, null). Literal strings can simply be quoted using single or double quotes.
- 3. **optional flow options** - object - If an object is provided immediately after the in/out flow def, then these options will be provided to react to customize the flow. This is reserved for future use.
+ 3. **optional flow options** - object - If an object is provided immediately after the in/out flow def, then these options will be provided to react to customize the flow. The `locals` property can contain an object map of any local variables you want to reference in the flow (other than what is passed in as parameters). For example: `{ locals: { foo: foo, bar: bar }}` would make local vars available in the flow. Note that global variables are already available in the flow.
  4. **function reference or method string** - Specify the function to be called for this task, or if calling a method off of an object being passed in or returned by a task, use a string to specify like `'obj.method'`. These can be asynchronous Node-style callback `cb(err, ...)` functions or synchronous functions which simply return values directly.
  5. **in/out task parameter definition** - string - similar to the in/out flow parameter definition above, these are the inputs and outputs that are passed to a task function and returned from a task function. The inputs will need to match either those from the flow inputs or outputs from other tasks that will run before this task. React will use the inputs as dependencies, so it will invoke and wait for response from the tasks that provide the dependent inputs. So simply by specifying inputs and outputs for the tasks, React will prioritize and parallelize tasks to run as fast as possible. Use `cb` or `callback` along with `err` to specify asynchronous Node style `cb(err, ...)` task, or omit both to specify a synchronous task.A synchronous task can only have a single return parameter.
  6. **optional task options** - object - if an object is provided this can be used to specify additional options for this task.  Currently the valid options for a task are:
@@ -186,6 +194,10 @@ See the [Advanced React](https://github.com/jeffbski/react/blob/master/doc/advan
 
 ## Status
 
+ - 2013-05-23 - Allow use of globals without needing to specify in locals, move 'use strict' into define, upgrade amdefine@0.0.5, eventemitter@0.4.11, requirejs@2.1.6, mocha@1.10.0, chai@1.6.0, jake@0.5.15 (v0.7.0)
+ - 2013-04-12 - Update to test on node 0.8, 0.10, 0.11
+ - 2012-10-17 - Fix issue with logEvents and provide way to disable logEvents(false) (v0.6.3)
+ - 2012-09-12 - Upgrade RequireJS@2.0.6, mocha@1.4.2, chai@1.2.0, jake@0.3.16.  Update travis config to include Node 0.8 (v0.6.2)
  - 2012-04-25 - Browser compatibility issue with process check, (v0.6.1)
  - 2012-04-05 - Remove dependency on sprint, use util.format
  - 2012-03-28 - Make react AMD-enabled and compatible with ES5 browsers and node.js, provide single file dist and min, add browser tests (v0.6.0)

package/browser-test/dist.html

@@ -62,6 +62,7 @@
           "test/exec-options.mocha",
           "test/finalcb-task.mocha",
           "test/input-parser.mocha",
+          "test/log-events.mocha",
           "test/module-use.mocha",
           "test/promise-auto-resolve.mocha",
           "test/ret-task.mocha",

package/browser-test/index.html

@@ -59,6 +59,7 @@
         "test/exec-options.mocha",
         "test/finalcb-task.mocha",
         "test/input-parser.mocha",
+        "test/log-events.mocha",
         "test/module-use.mocha",
         "test/promise-auto-resolve.mocha",
         "test/ret-task.mocha",

package/browser-test/min.html

@@ -62,6 +62,7 @@
           "test/exec-options.mocha",
           "test/finalcb-task.mocha",
           "test/input-parser.mocha",
+          "test/log-events.mocha",
           "test/module-use.mocha",
           "test/promise-auto-resolve.mocha",
           "test/ret-task.mocha",

package/dist/react.js

@@ -7,21 +7,31 @@
   var defaultMaxListeners = 10;
 
   function init() {
-    this._events = new Object;
+    this._events = {};
+    if (this._conf) {
+      configure.call(this, this._conf);
+    }
   }
 
   function configure(conf) {
     if (conf) {
+      
+      this._conf = conf;
+      
       conf.delimiter && (this.delimiter = conf.delimiter);
+      conf.maxListeners && (this._events.maxListeners = conf.maxListeners);
       conf.wildcard && (this.wildcard = conf.wildcard);
+      conf.newListener && (this.newListener = conf.newListener);
+
       if (this.wildcard) {
-        this.listenerTree = new Object;
+        this.listenerTree = {};
       }
     }
   }
 
   function EventEmitter(conf) {
-    this._events = new Object;
+    this._events = {};
+    this.newListener = false;
     configure.call(this, conf);
   }
 
@@ -155,7 +165,7 @@
     while (name) {
 
       if (!tree[name]) {
-        tree[name] = new Object;
+        tree[name] = {};
       }
 
       tree = tree[name];
@@ -210,6 +220,8 @@
   EventEmitter.prototype.setMaxListeners = function(n) {
     this._events || init.call(this);
     this._events.maxListeners = n;
+    if (!this._conf) this._conf = {};
+    this._conf.maxListeners = n;
   };
 
   EventEmitter.prototype.event = '';
@@ -241,11 +253,12 @@
   };
 
   EventEmitter.prototype.emit = function() {
+    
     this._events || init.call(this);
 
     var type = arguments[0];
 
-    if (type === 'newListener') {
+    if (type === 'newListener' && !this.newListener) {
       if (!this._events.newListener) { return false; }
     }
 
@@ -547,12 +560,12 @@
 
 }(typeof process !== 'undefined' && typeof process.title !== 'undefined' && typeof exports !== 'undefined' ? exports : window);
 
-
 /*global define:true EventEmitter2:true */
 
 
 
 define('react/eventemitter',['eventemitter2'], function (EventEmitterMod) {
+  
 
   /**
      Abstract the details of getting an EventEmitter
@@ -563,8 +576,8 @@ define('react/eventemitter',['eventemitter2'], function (EventEmitterMod) {
   var EventEmitter = (EventEmitterMod) ?
     ((EventEmitterMod.EventEmitter2) ? EventEmitterMod.EventEmitter2 : EventEmitterMod) : EventEmitter2;
   return EventEmitter;
-  
-});  
+
+});
 /*global define:true */
 
 
@@ -1094,12 +1107,12 @@ exports._extend = function(origin, add) {
 };
 
 });  
-
 /*global define:true */
 
 
 
 define('react/error',['util'], function (util) {
+  
 
   function ensureStackTraceLimitSet(stackTraceLimit) {
     if (!Error.stackTraceLimit || Error.stackTraceLimit < stackTraceLimit) {
@@ -1130,7 +1143,7 @@ define('react/error',['util'], function (util) {
       errString += task.f.toString(); //TODO need to pretty print function, gets collapsed
       errString += '\n\n';
     }
-    return errString;    
+    return errString;
   }
 
   function augmentError(err, meta) {
@@ -1143,10 +1156,26 @@ define('react/error',['util'], function (util) {
 
   return {
     ensureStackTraceLimitSet: ensureStackTraceLimitSet,
-    augmentError: augmentError    
+    augmentError: augmentError
   };
 
-});  
+});
+/*global define:true sprint:true */
+
+
+
+define('react/sprintf',['util'], function (util) {
+  
+
+  /**
+     Abstract the details of getting a sprintf function.
+     Currently using the simple format capabilities of node's util.format
+    */
+
+  var sprintf = util.format;
+  return sprintf;
+
+});
 (function (root, factory) {
   /*global define:true */
 
@@ -1178,112 +1207,24 @@ define('react/error',['util'], function (util) {
 }));
 
 
-
 /*global define:true */
 
 
 
 define('react/status',[], function () {
   
+
   var STATUS = { READY: 'ready',  RUNNING: 'running', ERRORED: 'errored', COMPLETE: 'complete' };
 
   return STATUS;
 
-});  
-
-/*global define:true */
-
-
-
-define('react/vcon',[], function () {
-  
-  var LAST_RESULTS_KEY = ':LAST_RESULTS';
-
-  function VContext() {
-  }
-
-  VContext.prototype.getLastResults = function () { return this.getVar(LAST_RESULTS_KEY); };
-  VContext.prototype.setLastResults = function (args) { this.setVar(LAST_RESULTS_KEY, args); };
-
-  VContext.prototype.getVar = function (name) { //name might be simple or obj.prop, also literals
-    /*jshint regexp: false */
-    var vConValues = this.values;
-    if (typeof(name) !== 'string') return name; // literal boolean or number
-    name = name.trim();
-    // literal checks need to match what is in validate.js
-    if (name === 'true') return true;
-    if (name === 'false') return false;
-    if (name === 'null') return null;
-    if (/^-?[0-9]+$/.test(name)) return parseInt(name, 10); //int
-    if (/^-?[0-9.]+$/.test(name)) return parseFloat(name);  //float
-    var m = /^("|')([^\1]*)\1$/.exec(name);  //check for quoted string " or '
-    if (m) return m[2]; // if is quoted str, return inside of the quotes
-    var nameAndProps = name.split('.');
-    return nameAndProps.reduce(function (accObj, prop) {
-      if (accObj === undefined || accObj === null) return undefined; // prevent exception
-      return accObj[prop];
-    }, vConValues);   // vCon['foo']['bar']
-  };
-
-  /**
-     Saves all the results from a task as a unit, also sets special
-     variable :LAST_RESULTS which keeps an array of the last values
-     which can be used for chaining and testing last results, etc.
-  */
-  VContext.prototype.saveResults = function (paramArr, valuesArr) { // set values for params
-    var self = this;
-    paramArr.forEach(function (k, idx) { //save values to v context
-      self.setVar(k, (valuesArr[idx] !== undefined) ? valuesArr[idx] : null); //upgrade any undefined to null
-    });
-    this.setLastResults(valuesArr);
-  };
-
-  VContext.prototype.setVar = function (name, value) { //name might be simple or obj.prop
-    if (!name) return;  // if name is undefined or null, then discard
-    var vConValues = this.values;
-    var nameAndProps = name.split('.');
-    var lastProp = nameAndProps.pop();
-    var obj = nameAndProps.reduce(function (accObj, prop) {
-      var o = accObj[prop];
-      if (o === undefined || o === null) {  // if doesn't exist create it
-        o = accObj[prop] = { };
-      }
-      return o;
-    }, vConValues);   // vCon['foo']['bar']
-    obj[lastProp] = value;
-  };
-  
-
-  /**
-     Create Variable Context using arguments passed in.
-     Ignore extra arguments passed in. Locals can be
-     passed into seed the VContext otherwise empty {}
-     will be used
-       @param self used to pass 'this' context in
-  */
-  VContext.create = function (args, inParams, locals, self) {
-    var initValues = {};
-    if (self) initValues['this'] = self;
-    if (locals) Object.keys(locals).forEach(function (k) { initValues[k] = locals[k]; }); // copy over keys
-    var vContext = new VContext();
-    vContext.values = args.reduce(function (vcon, x, idx) { // create vCon start with input args
-      var param = inParams[idx];
-      if (param) vcon[param] = (x !== undefined) ? x : null; // upgrade undefined to null
-      return vcon;
-    }, initValues);
-    return vContext;
-  };
-
-
-  return VContext;
-
-});  
-
+});
 /*global define:true process:false*/
 
 
 
 define('react/event-manager',['./eventemitter'], function (EventEmitter) {
+  
   /*jshint regexp:false */
 
   var EVENT_EMITTER2_CONFIG = {
@@ -1356,12 +1297,15 @@ define('react/event-manager',['./eventemitter'], function (EventEmitter) {
     if (this.emitter) this.emitter.removeListener.apply(this.emitter, arguments);
   };
 
+  EventManager.prototype.removeAllListeners = function (event) {
+    if (this.emitter) this.emitter.removeAllListeners.apply(this.emitter, arguments);
+  };
+
 
   EventManager.global = EventManager.create(); // create one top level emitter
   return EventManager;
-  
-});  
 
+});
 /*global define:true */
 
 
@@ -1369,6 +1313,7 @@ define('react/event-manager',['./eventemitter'], function (EventEmitter) {
 define('react/base-task',['ensure-array', './status', './event-manager'],
        function (array, STATUS, EventManager) {
   
+
   function BaseTask() {
   }
 
@@ -1428,7 +1373,7 @@ define('react/base-task',['ensure-array', './status', './event-manager'],
      to this if they want to do this check.
   */
   BaseTask.prototype.parentExists = function (objPropStr, vCon) {
-      if (!isObjProperty(objPropStr)) return true; // NOT obj prop, just simple arg, ret true
+    if (!isObjProperty(objPropStr)) return true; // NOT obj prop, just simple arg, ret true
     var nameAndProps = objPropStr.split('.');
     nameAndProps.pop(); // pop off final prop
     var parent = nameAndProps.reduce(function (accObj, prop) {
@@ -1464,120 +1409,28 @@ define('react/base-task',['ensure-array', './status', './event-manager'],
   BaseTask.prototype.isMethodCall = function () {
     /*jshint regexp: false */
     return (typeof(this.f) === 'string' && /^.*\..*$/.test(this.f));  //str contains .
-    };
-
-    BaseTask.prototype.getMethodObj =  function (vCon) { //obj.prop.prop2, returns obj.prop or undefined
-      var name = this.f;
-      if (!name) return undefined;
-      var nameAndProps = name.split('.');
-      nameAndProps.pop(); // pop off last one
-      if (!nameAndProps.length) return undefined;
-      var result = nameAndProps.reduce(function (accObj, prop) {
-        if (accObj === undefined || accObj === null) return undefined; // prevent exception
-        return accObj[prop];
-      }, vCon.values); // vCon['foo']['bar']
-      return result;
-    };
-
-  return BaseTask;
-  
-});
-
-/*global define:true */
-
-
-
-define('react/input-parser',['./event-manager'], function (EventManager) {
-
-  var defaultExecOptions = {
-    reactExecOptions: true,
-    outputStyle: 'cb',
   };
 
-    var OUTPUT_STYLES = {
-      CALLBACK: 'cb',
-      NONE: 'none'
-    };
-
-  function isExecOptions(x) { return (x && x.reactExecOptions); }
-  function execOptionsFilter(x) { return isExecOptions(x); }
-  function nonExecOptionsFilter(x) { return !isExecOptions(x); }
-  function mergeExecOptions(accum, options) {
-    Object.keys(options).forEach(function (k) { accum[k] = options[k]; });
-    return accum;
-  }
-
-  function splitArgs(args, inParams, style) {
-    var result = { };
-    result.args = inParams.map(function (p) { return args.shift(); }); // take args for input params first
-    if (style === OUTPUT_STYLES.CALLBACK && args.length) result.cb = args.shift(); // next take the cb
-    result.extra = args; // these remaining were after the callback
+  BaseTask.prototype.getMethodObj =  function (vCon) { //obj.prop.prop2, returns obj.prop or undefined
+    var name = this.f;
+    if (!name) return undefined;
+    var nameAndProps = name.split('.');
+    nameAndProps.pop(); // pop off last one
+    if (!nameAndProps.length) return undefined;
+    var result = vCon.resolveNameArr(nameAndProps);
     return result;
-    }
-    
-  function inputParser(inputArgs, ast) {
-    var parsedInput = { };
-    var execOptionsArr = inputArgs.filter(execOptionsFilter);
-    execOptionsArr.unshift(defaultExecOptions);
-    parsedInput.options = execOptionsArr.reduce(mergeExecOptions, {});
-
-      var args = inputArgs.filter(nonExecOptionsFilter);
-    var splitResult = splitArgs(args, ast.inParams, parsedInput.options.outputStyle); 
-    parsedInput.args = splitResult.args;
-    parsedInput.cb = splitResult.cb;
-    if (splitResult.outputStyle) parsedInput.options.outputStyle = splitResult.outputStyle;
-    if (splitResult.extra) parsedInput.extraArgs = splitResult.extra;
-    EventManager.global.emit(EventManager.TYPES.EXEC_INPUT_PREPROCESS, parsedInput);  // hook
-    return parsedInput;
-  }
-
-
-  inputParser.defaultExecOptions = defaultExecOptions;
-  return inputParser;
-
-});  
-
-/*global define:true */
-
-
-
-define('react/id',[], function () {
-  
-  var startingId = 0;
-
-  function createUniqueId() {
-    startingId += 1;
-    if (startingId === Number.MAX_VALUE) startingId = 0; // if hits this start over //TODO need something better?
-    return startingId;
-  }
-
-  return {
-    createUniqueId: createUniqueId
   };
 
-});  
-
-/*global define:true sprint:true */
-
-
-
-define('react/sprintf',['util'], function (util) {
+  return BaseTask;
 
-  /**
-     Abstract the details of getting a sprintf function.
-     Currently using the simple format capabilities of node's util.format
-    */
-  
-  var sprintf = util.format;
-  return sprintf;
-  
-});  
+});
 
 /*global define:true */
 
 
 
 define('react/cb-task',['util', './sprintf', './base-task'], function (util, sprintf, BaseTask) {
+  
 
   function format_error(errmsg, obj) {
     return sprintf('%s - %s', errmsg, util.inspect(obj));
@@ -1627,7 +1480,7 @@ define('react/cb-task',['util', './sprintf', './base-task'], function (util, spr
       vCon.saveResults(self.out, args);
       self.complete(args);
       contExec();
-    };    
+    };
   };
 
   CbTask.prototype.exec = function exec(vCon, handleError, contExec) {
@@ -1645,22 +1498,22 @@ define('react/cb-task',['util', './sprintf', './base-task'], function (util, spr
       } else if (typeof(func) === 'string') {
         func = vCon.getVar(func); // we want the actual fn from this string
       }
-      func.apply(bindObj, args); 
+      func.apply(bindObj, args);
     } catch (err) { //catch and handle the task error, calling final cb
       handleError(this, err);
-    }    
+    }
   };
 
   return CbTask;
 
-});  
-
+});
 
 /*global define:true */
 
 
 
 define('react/promise-task',['util', './sprintf', './base-task'], function (util, sprintf, BaseTask) {
+  
 
   /**
      PromiseTask is a task which executes a fn that returns a promise
@@ -1697,7 +1550,7 @@ define('react/promise-task',['util', './sprintf', './base-task'], function (util
              taskDef.a.every(function (x) { return (typeof(x) === 'string'); }))) {
         errors.push(format_error(A_REQ, taskDef));
       }
-      if (! (Array.isArray(taskDef.out) && taskDef.out.length <= 1 && 
+      if (! (Array.isArray(taskDef.out) && taskDef.out.length <= 1 &&
              taskDef.out.every(function (x) { return (typeof(x) === 'string'); }))) {
         errors.push(format_error(OUT_REQ, taskDef));
       }
@@ -1740,19 +1593,19 @@ define('react/promise-task',['util', './sprintf', './base-task'], function (util
       }
     } catch (err) { //catch and handle the task error, calling final cb
       handleError(this, err);
-    }    
+    }
   };
 
   return PromiseTask;
 
-});  
-
+});
 /*global define:true */
 
 
 
 define('react/ret-task',['util', './sprintf', './base-task'], function (util, sprintf, BaseTask) {
   
+
   function format_error(errmsg, obj) {
     return sprintf('%s - %s', errmsg, util.inspect(obj));
   }
@@ -1796,7 +1649,7 @@ define('react/ret-task',['util', './sprintf', './base-task'], function (util, sp
   RetTask.prototype.exec = function exec(vCon, handleError, contExec) {
     try {
       var args = this.a.map(function (k) { return vCon.getVar(k); }); //get args from vCon
-      this.start(args); //note the start time, args    
+      this.start(args); //note the start time, args
       var func = this.f;
       var bindObj = vCon.getVar('this'); //global space or the original this
       if (this.isMethodCall()) { //if method call then reset func and bindObj
@@ -1814,14 +1667,14 @@ define('react/ret-task',['util', './sprintf', './base-task'], function (util, sp
 
   return RetTask;
 
-});  
-
+});
 /*global define:true */
 
 
 
 define('react/when-task',['util', './sprintf', './base-task'], function (util, sprintf, BaseTask) {
   
+
   /**
      When task which checks if is a promise (has a then method)
      and waits for it to resolve.
@@ -1845,19 +1698,18 @@ define('react/when-task',['util', './sprintf', './base-task'], function (util, s
   WhenTask.prototype = new BaseTask();
   WhenTask.prototype.constructor = WhenTask;
 
-  WhenTask.prototype.f = function when() { // just here to keep validations happy 
-  }
+  WhenTask.prototype.f = function when() { }; // just here to keep validations happy
 
   WhenTask.validate = function (taskDef) {
     var errors = [];
     if (!taskDef.a || !taskDef.out) {
       errors.push(format_error(REQ, taskDef));
     } else {
-      if (! (Array.isArray(taskDef.a) && taskDef.a.length === 1 && 
+      if (! (Array.isArray(taskDef.a) && taskDef.a.length === 1 &&
              taskDef.a.every(function (x) { return (typeof(x) === 'string'); }))) {
         errors.push(format_error(A_REQ, taskDef));
       }
-      if (! (Array.isArray(taskDef.out) && taskDef.out.length <= 1 && 
+      if (! (Array.isArray(taskDef.out) && taskDef.out.length <= 1 &&
              taskDef.out.every(function (x) { return (typeof(x) === 'string'); }))) {
         errors.push(format_error(OUT_REQ, taskDef));
       }
@@ -1892,25 +1744,25 @@ define('react/when-task',['util', './sprintf', './base-task'], function (util, s
       }
     } catch (err) { //catch and handle the task error, calling final cb
       handleError(this, err);
-    } 
+    }
   };
 
   return WhenTask;
 
-});  
-
+});
 /*global define:true */
 
 
 
 define('react/finalcb-task',['./sprintf', 'util', './status', './event-manager'],
        function (sprintf, util, STATUS, EventManager) {
+  
 
   var OUTTASK_A_REQ = 'ast.outTask.a should be an array of string param names';
 
   function FinalCbTask(outTaskOptions) {
-      var taskDef = outTaskOptions.taskDef;
-    if (typeof(outTaskOptions.cbFunc) !== 'function') throw new Error('callback is not a function'); 
+    var taskDef = outTaskOptions.taskDef;
+    if (typeof(outTaskOptions.cbFunc) !== 'function') throw new Error('callback is not a function');
     var self = this;
     for (var k in taskDef) {
       if (true) self[k] = taskDef[k];  // if to make jshint happy
@@ -1960,7 +1812,118 @@ define('react/finalcb-task',['./sprintf', 'util', './status', './event-manager']
 
   return FinalCbTask;
 
-});  
+});
+/*global define:true */
+
+
+
+define('react/vcon',[], function () {
+  
+
+  var LAST_RESULTS_KEY = ':LAST_RESULTS';
+
+  function VContext() {
+  }
+
+  VContext.prototype.getLastResults = function () { return this.getVar(LAST_RESULTS_KEY); };
+  VContext.prototype.setLastResults = function (args) { this.setVar(LAST_RESULTS_KEY, args); };
+
+  VContext.prototype.getVar = function (name) { //name might be simple or obj.prop, also literals
+    /*jshint regexp: false */
+    var vConValues = this.values;
+    if (typeof(name) !== 'string') return name; // literal boolean or number
+    name = name.trim();
+    // literal checks need to match what is in validate.js
+    if (name === 'true') return true;
+    if (name === 'false') return false;
+    if (name === 'null') return null;
+    if (/^-?[0-9]+$/.test(name)) return parseInt(name, 10); //int
+    if (/^-?[0-9.]+$/.test(name)) return parseFloat(name);  //float
+    var m = /^("|')([^\1]*)\1$/.exec(name);  //check for quoted string " or '
+    if (m) return m[2]; // if is quoted str, return inside of the quotes
+    var nameAndProps = name.split('.');
+    var result = this.resolveNameArr(nameAndProps);
+    return result;
+  };
+
+  VContext.prototype.resolveNameArr = function (nameAndProps) {
+    var vConValues = this.values;
+    var result = nameAndProps.reduce(function (accObj, prop) {
+      if (accObj === undefined || accObj === null) return undefined; // prevent exception
+      return accObj[prop];
+    }, vConValues);   // vCon['foo']['bar']
+    if (result === undefined && this.global !== undefined) { // see if matches any global
+      result = nameAndProps.reduce(function (accObj, prop) {
+        if (accObj === undefined || accObj === null) return undefined; // prevent exception
+        return accObj[prop];
+      }, this.global);   // global['foo']['bar']
+    }
+    return result;
+  };
+
+  /**
+     Saves all the results from a task as a unit, also sets special
+     variable :LAST_RESULTS which keeps an array of the last values
+     which can be used for chaining and testing last results, etc.
+  */
+  VContext.prototype.saveResults = function (paramArr, valuesArr) { // set values for params
+    var self = this;
+    paramArr.forEach(function (k, idx) { //save values to v context
+      self.setVar(k, (valuesArr[idx] !== undefined) ? valuesArr[idx] : null); //upgrade any undefined to null
+    });
+    this.setLastResults(valuesArr);
+  };
+
+  VContext.prototype.setVar = function (name, value) { //name might be simple or obj.prop
+    if (!name) return;  // if name is undefined or null, then discard
+    var vConValues = this.values;
+    var nameAndProps = name.split('.');
+    var lastProp = nameAndProps.pop();
+    var obj = nameAndProps.reduce(function (accObj, prop) {
+      var o = accObj[prop];
+      if (o === undefined || o === null) {  // if doesn't exist create it
+        o = accObj[prop] = { };
+      }
+      return o;
+    }, vConValues);   // vCon['foo']['bar']
+    obj[lastProp] = value;
+  };
+
+
+  /**
+     Create Variable Context using arguments passed in.
+     Ignore extra arguments passed in. Locals can be
+     passed into seed the VContext otherwise empty {}
+     will be used
+       @param self used to pass 'this' context in
+  */
+  VContext.create = function (args, inParams, locals, self) {
+    /*jshint validthis:true, evil:true */
+    var initValues = {};
+    if (self) initValues['this'] = self;
+    if (locals) Object.keys(locals).forEach(function (k) { initValues[k] = locals[k]; }); // copy over keys
+    var vContext = new VContext();
+    vContext.values = args.reduce(function (vcon, x, idx) { // create vCon start with input args
+      var param = inParams[idx];
+      if (param) vcon[param] = (x !== undefined) ? x : null; // upgrade undefined to null
+      return vcon;
+    }, initValues);
+
+    // add in global
+    if (typeof global === 'object') { // node.js and modern browsers expose global
+      vContext.global = global;
+    } else { // try to access this using Function eval of this
+      // http://stackoverflow.com/questions/3277182/how-to-get-the-global-object-in-javascript
+      vContext.global = new Function('return this')();
+    }
+
+    return vContext;
+  };
+
+
+  return VContext;
+
+});
 
 /*global define:true */
 
@@ -1968,12 +1931,13 @@ define('react/finalcb-task',['./sprintf', 'util', './status', './event-manager']
 
 define('react/finalcb-first-task',['./sprintf', 'util', './status', './vcon', './event-manager'],
        function (sprintf, util, STATUS, VContext, EventManager) {
+  
 
   var OUTTASK_A_REQ = 'ast.outTask.a should be an array of string param names';
 
   function FinalCbFirstSuccTask(outTaskOptions) {
-      var taskDef = outTaskOptions.taskDef;
-    if (typeof(outTaskOptions.cbFunc) !== 'function') throw new Error('callback is not a function'); 
+    var taskDef = outTaskOptions.taskDef;
+    if (typeof(outTaskOptions.cbFunc) !== 'function') throw new Error('callback is not a function');
     var self = this;
     for (var k in taskDef) {
       if (true) self[k] = taskDef[k];  // if to make jshint happy
@@ -2026,8 +1990,7 @@ define('react/finalcb-first-task',['./sprintf', 'util', './status', './vcon', '.
 
   return FinalCbFirstSuccTask;
 
-});  
-
+});
 /*global define:true */
 
 
@@ -2039,6 +2002,7 @@ function (util, sprintf, array, CbTask, PromiseTask,
          RetTask, WhenTask, FinalCbTask, FinalCbFirstSuccTask,
          STATUS, error, VContext, EventManager) {
   
+
   var TASK_TYPES = {
     cb: CbTask,
     ret: RetTask,
@@ -2073,13 +2037,13 @@ function (util, sprintf, array, CbTask, PromiseTask,
   */
   function setMissingType(taskDef) {
     if (taskDef.type) return taskDef; //already set, return
-    taskDef.type = 'cb'; 
+    taskDef.type = 'cb';
     return taskDef;
   }
 
   function setMissingOutTaskType(taskDef) {
     if (!taskDef.type) taskDef.type = Object.keys(OUT_TASK_TYPES)[0]; //use first outTask type as default
-  } 
+  }
 
   function ensureAfterArrStrings(taskDef) { // convert any fn to str, and make sure is array
     if (!taskDef.after) return;
@@ -2092,14 +2056,14 @@ function (util, sprintf, array, CbTask, PromiseTask,
      @returns array of errors for taskDef, could be empty
   */
   function validate(taskDef) {
-    if (!taskDef || typeof(taskDef) !== 'object') {    
+    if (!taskDef || typeof(taskDef) !== 'object') {
       return [format_error(TASKDEF_IS_OBJECT, taskDef)];
     }
     setMissingType(taskDef);
     ensureAfterArrStrings(taskDef);
     var errors = [];
     errors = errors.concat(validateTaskType(taskDef));
-    errors = errors.concat(validateTask(taskDef));  
+    errors = errors.concat(validateTask(taskDef));
     return errors;
   }
 
@@ -2126,13 +2090,13 @@ function (util, sprintf, array, CbTask, PromiseTask,
     setMissingOutTaskType(taskDef);
     var taskCons = OUT_TASK_TYPES[taskDef.type];
     errors = errors.concat(taskCons.validate(taskDef));
-    return errors;  
+    return errors;
   }
 
 
   function validateLocalFunctions(inParams, taskDefs, locals) {
     var errors = [];
-    function foo() { } //used to mock args as fns for validation check 
+    function foo() { } //used to mock args as fns for validation check
     var mock_args = inParams.map(function (p) { return foo; }); //mock args with fns
     var vCon = VContext.create(mock_args, inParams, locals);
     var tasks = taskDefs.map(create);
@@ -2205,7 +2169,7 @@ function (util, sprintf, array, CbTask, PromiseTask,
     var TaskConstructor = outTaskOptions.TaskConstructor;  // hook could have changed
     return new TaskConstructor(outTaskOptions);
   }
-  
+
   function createErrorHandler(vCon, outTask) {
     return function handleError(task, err) {
       task.status = STATUS.ERRORED;
@@ -2223,7 +2187,7 @@ function (util, sprintf, array, CbTask, PromiseTask,
 
   function execTasks(tasksReady, vCon, handleError, contExec) {
     tasksReady.forEach(function (t) { t.status = STATUS.READY; }); //set ready first, no double exec
-    tasksReady.forEach(function (t) { t.exec(vCon, handleError, contExec); }); 
+    tasksReady.forEach(function (t) { t.exec(vCon, handleError, contExec); });
   }
 
   /**
@@ -2254,7 +2218,7 @@ function (util, sprintf, array, CbTask, PromiseTask,
 
   function serializeTasks(tasks) { // conveniently set after for each task idx > 0
     nameTasks(tasks);
-    tasks.forEach(function (t, idx, arr) { if (idx !== 0) t.after = [arr[idx - 1].name]; }); 
+    tasks.forEach(function (t, idx, arr) { if (idx !== 0) t.after = [arr[idx - 1].name]; });
     return tasks;
   }
 
@@ -2275,15 +2239,15 @@ function (util, sprintf, array, CbTask, PromiseTask,
     findReadyAndExec: findReadyAndExec
   };
 
-});  
-
+});
 /*global define:true */
 
 
 
 define('react/validate',['util', './sprintf', 'ensure-array', './task'], function (util, sprintf, array, taskUtil) {
-  /*jshint latedef:false */
   
+  /*jshint latedef:false */
+
   var AST_IS_OBJECT = 'ast must be an object with inParams, tasks, and outTask';
   var INPARAMS_ARR_STR = 'ast.inParams must be an array of strings';
   var TASKS_ARR = 'ast.tasks must be an array of tasks';
@@ -2293,7 +2257,7 @@ define('react/validate',['util', './sprintf', 'ensure-array', './task'], functio
   var MISSING_INPUTS = 'missing or mispelled variable referenced in flow definition: %s';
 
   // match any of our literals true, false, int, float, quoted strings, or is property (has dot), match vcon.js
-  var LITERAL_OR_PROP_RE = /^(true|false|this|null|\-?[0-9\.]+)$|'|"|\./i;  
+  var LITERAL_OR_PROP_RE = /^(true|false|this|null|\-?[0-9\.]+)$|'|"|\./i;
 
   function format_error(errmsg, obj) {
     return sprintf('%s - %s', errmsg, util.inspect(obj));
@@ -2349,11 +2313,11 @@ define('react/validate',['util', './sprintf', 'ensure-array', './task'], functio
     tasks.forEach(function (t) {
       errors = errors.concat(taskUtil.validate(t));
     });
-      return errors;
+    return errors;
   }
 
   function validateTaskNamesUnique(tasks) {
-      if (!Array.isArray(tasks)) return [];
+    if (!Array.isArray(tasks)) return [];
     var errors = [];
     var namedTasks = tasks.filter(function (t) { return (t.name); });
     var names = namedTasks.map(function (t) { return t.name; });
@@ -2361,7 +2325,7 @@ define('react/validate',['util', './sprintf', 'ensure-array', './task'], functio
       if (accum[name]) errors.push(sprintf('%s %s', NAMES_UNIQUE, name));
       else accum[name] = true;
       return accum;
-    }, {});                             
+    }, {});
     return errors;
   }
 
@@ -2427,13 +2391,86 @@ define('react/validate',['util', './sprintf', 'ensure-array', './task'], functio
       if (!isLiteralOrProp(p) && !names[p]) accum.push(sprintf(MISSING_INPUTS, p)); // add error if missing
       return accum;
     }, errors);
-    return errors;  
+    return errors;
   }
 
   return validate;
 
-});  
+});
+/*global define:true */
+
+
 
+define('react/input-parser',['./event-manager'], function (EventManager) {
+  
+
+  var defaultExecOptions = {
+    reactExecOptions: true,
+    outputStyle: 'cb',
+  };
+
+  var OUTPUT_STYLES = {
+    CALLBACK: 'cb',
+    NONE: 'none'
+  };
+
+  function isExecOptions(x) { return (x && x.reactExecOptions); }
+  function execOptionsFilter(x) { return isExecOptions(x); }
+  function nonExecOptionsFilter(x) { return !isExecOptions(x); }
+  function mergeExecOptions(accum, options) {
+    Object.keys(options).forEach(function (k) { accum[k] = options[k]; });
+    return accum;
+  }
+
+  function splitArgs(args, inParams, style) {
+    var result = { };
+    result.args = inParams.map(function (p) { return args.shift(); }); // take args for input params first
+    if (style === OUTPUT_STYLES.CALLBACK && args.length) result.cb = args.shift(); // next take the cb
+    result.extra = args; // these remaining were after the callback
+    return result;
+  }
+
+  function inputParser(inputArgs, ast) {
+    var parsedInput = { };
+    var execOptionsArr = inputArgs.filter(execOptionsFilter);
+    execOptionsArr.unshift(defaultExecOptions);
+    parsedInput.options = execOptionsArr.reduce(mergeExecOptions, {});
+
+    var args = inputArgs.filter(nonExecOptionsFilter);
+    var splitResult = splitArgs(args, ast.inParams, parsedInput.options.outputStyle);
+    parsedInput.args = splitResult.args;
+    parsedInput.cb = splitResult.cb;
+    if (splitResult.outputStyle) parsedInput.options.outputStyle = splitResult.outputStyle;
+    if (splitResult.extra) parsedInput.extraArgs = splitResult.extra;
+    EventManager.global.emit(EventManager.TYPES.EXEC_INPUT_PREPROCESS, parsedInput);  // hook
+    return parsedInput;
+  }
+
+
+  inputParser.defaultExecOptions = defaultExecOptions;
+  return inputParser;
+
+});
+/*global define:true */
+
+
+
+define('react/id',[], function () {
+  
+
+  var startingId = 0;
+
+  function createUniqueId() {
+    startingId += 1;
+    if (startingId === Number.MAX_VALUE) startingId = 0; // if hits this start over //TODO need something better?
+    return startingId;
+  }
+
+  return {
+    createUniqueId: createUniqueId
+  };
+
+});
 /*global define:true */
 
 
@@ -2442,6 +2479,7 @@ define('react/core',['./eventemitter', './error', './validate', './task', './sta
         './vcon', './event-manager', './input-parser', './id', './sprintf'],
        function (EventEmitter, error, validate, taskUtil, STATUS,
                  VContext, EventManager, inputParser, idGenerator, sprintf) {
+  
 
   var reactOptions = {
     stackTraceLimitMin: 30
@@ -2456,7 +2494,7 @@ define('react/core',['./eventemitter', './error', './validate', './task', './sta
     return Object.keys(reactOptions).reduce(function (accum, k) {
       if (!accum[k]) accum[k] = reactOptions[k];
       return accum;
-    }, parsedOptions);    
+    }, parsedOptions);
   }
 
   /**
@@ -2513,7 +2551,7 @@ define('react/core',['./eventemitter', './error', './validate', './task', './sta
         });
         Object.freeze(newAST);
       }
-      flowEmitter.emit(EventManager.TYPES.AST_DEFINED, ast); 
+      flowEmitter.emit(EventManager.TYPES.AST_DEFINED, ast);
       return errors;
     }
 
@@ -2537,7 +2575,7 @@ define('react/core',['./eventemitter', './error', './validate', './task', './sta
       env.taskDefs = ast.tasks.slice(); // create copy
       env.outTaskDef = Object.create(ast.outTask); // create copy
       reactEmitter.emit(EventManager.TYPES.EXEC_TASKS_PRECREATE, env);  // hook
-      
+
       var tasks = env.taskDefs.map(taskUtil.create);
       var tasksByName = taskUtil.nameTasks(tasks); // map names to working tasks
       var outTask = taskUtil.createOutTask(env.outTaskDef, parsedInput.cb, tasks, vCon, env.options, env);
@@ -2568,13 +2606,13 @@ define('react/core',['./eventemitter', './error', './validate', './task', './sta
   reactFactory.options = reactOptions;   // global react options
   reactFactory.events = reactEmitter;    // global react emitter
   return reactFactory; // module returns reactFactory to create a react fn
-});  
-
+});
 /*global define:true */
 
 
 
 define('react/parse',['./sprintf'], function (sprintf) {
+  
 
   function splitTrimFilterArgs(commaSepArgs) { //parse 'one, two' into ['one', 'two']
     if (!commaSepArgs) return [];
@@ -2599,7 +2637,7 @@ define('react/parse',['./sprintf'], function (sprintf) {
       return result;
     } else { // no match
       throw new Error(sprintf(errStr, str));
-    }  
+    }
   }
 
   return {
@@ -2607,8 +2645,7 @@ define('react/parse',['./sprintf'], function (sprintf) {
     parseStr: parseStr
   };
 
-});  
-
+});
 
 /*global define:true */
 
@@ -2616,7 +2653,8 @@ define('react/parse',['./sprintf'], function (sprintf) {
 
 define('react/dsl',['./sprintf', './core', './parse', './task'],
        function (sprintf, core, parse, taskUtil) {
-         /*jshint regexp: false */
+  
+  /*jshint regexp: false */
 
   var MISSING_NAME = 'first flow parameter should be the flow name, but found in/out def: %s';
   var INOUT_PARAMS_NO_MATCH = 'params in wrong format, wanted "foo, bar, cb -> err, baz" - found: %s';
@@ -2640,23 +2678,23 @@ define('react/dsl',['./sprintf', './core', './parse', './task'],
 
   var inOutDefParse = {
     splitStr: '->',
-      fn: function (m, origStr) {
-        var inParams = parse.splitTrimFilterArgs(m[0]);
-        var lastParam = inParams[inParams.length - 1];
-        var type = (lastParam && CB_NAMES_RE.test(lastParam)) ? 'cb' : 'ret';
-          var outParams = parse.splitTrimFilterArgs(m[1]);
-        var firstOutParam = outParams[0];
-        if (type === 'cb' && (!firstOutParam || !ERR_NAMES_RE.test(firstOutParam))) {
-          throw new Error(sprintf(MISSING_ERR, origStr));  // found cb, but no err param
-        } else if (type === 'ret' && firstOutParam && ERR_NAMES_RE.test(firstOutParam)) {
-          throw new Error(sprintf(MISSING_CB, origStr));  // found err but not cb param
-        }
-        return {
-          type: type,
-          inDef: filterOutTrailingCbParam(inParams),
-            outDef: filterOutLeadingErrParam(outParams)
-        };
+    fn: function (m, origStr) {
+      var inParams = parse.splitTrimFilterArgs(m[0]);
+      var lastParam = inParams[inParams.length - 1];
+      var type = (lastParam && CB_NAMES_RE.test(lastParam)) ? 'cb' : 'ret';
+      var outParams = parse.splitTrimFilterArgs(m[1]);
+      var firstOutParam = outParams[0];
+      if (type === 'cb' && (!firstOutParam || !ERR_NAMES_RE.test(firstOutParam))) {
+        throw new Error(sprintf(MISSING_ERR, origStr));  // found cb, but no err param
+      } else if (type === 'ret' && firstOutParam && ERR_NAMES_RE.test(firstOutParam)) {
+        throw new Error(sprintf(MISSING_CB, origStr));  // found err but not cb param
       }
+      return {
+        type: type,
+        inDef: filterOutTrailingCbParam(inParams),
+        outDef: filterOutLeadingErrParam(outParams)
+      };
+    }
   };
 
   function parseInOutParams(str) {
@@ -2692,11 +2730,11 @@ define('react/dsl',['./sprintf', './core', './parse', './task'],
     // if next arg is object, shift it off as options
     var options = (vargs.length && typeof(vargs[0]) === 'object') ? vargs.shift() : { };
     var taskDefArr = vargs; // rest are for the tasks
-    var defObj = {  
+    var defObj = {
       inOutParamStr: inOutParamStr,
       taskDefArr: taskDefArr,
       options: options
-      };
+    };
     return defObj;
   }
 
@@ -2704,7 +2742,7 @@ define('react/dsl',['./sprintf', './core', './parse', './task'],
   function dslDefine(name, arg1, arg2, argN) {
     var reactFn = core();
     if (name && INOUT_RE.test(name)) throw new Error(sprintf(MISSING_NAME, name));
-    var defObj = parseVargs(Array.prototype.slice.call(arguments, 1)); // name, already used 
+    var defObj = parseVargs(Array.prototype.slice.call(arguments, 1)); // name, already used
     var inOutDef = parseInOutParams(defObj.inOutParamStr);
     var ast = {
       name: name,
@@ -2713,18 +2751,18 @@ define('react/dsl',['./sprintf', './core', './parse', './task'],
       outTask: { a: inOutDef.outDef }
     };
     if (defObj.options) Object.keys(defObj.options).forEach(function (k) { ast[k] = defObj.options[k]; });
-      var errors = reactFn.setAndValidateAST(ast);
+    var errors = reactFn.setAndValidateAST(ast);
     if (errors.length) {
       var errorStr = errors.join('\n');
-        throw new Error(errorStr);
+      throw new Error(errorStr);
     }
     return reactFn;
-    }
+  }
 
   function selectFirst(name, arg1, arg2, argN) {
     var reactFn = core();
-    var defObj = parseVargs(Array.prototype.slice.call(arguments, 1)); // name, already used 
-    var inOutDef = parseInOutParams(defObj.inOutParamStr);  
+    var defObj = parseVargs(Array.prototype.slice.call(arguments, 1)); // name, already used
+    var inOutDef = parseInOutParams(defObj.inOutParamStr);
     var tasks = taskUtil.serializeTasks(parseTasks(defObj.taskDefArr));
     var ast = {
       name: name,
@@ -2732,7 +2770,7 @@ define('react/dsl',['./sprintf', './core', './parse', './task'],
       tasks: tasks,
       outTask: { type: 'finalcbFirst', a: inOutDef.outDef },
     };
-    if (defObj.options) Object.keys(defObj.options).forEach(function (k) { ast[k] = defObj.options[k]; });  
+    if (defObj.options) Object.keys(defObj.options).forEach(function (k) { ast[k] = defObj.options[k]; });
     var errors = reactFn.setAndValidateAST(ast);
     if (errors.length) {
       var errorStr = errors.join('\n');
@@ -2743,15 +2781,15 @@ define('react/dsl',['./sprintf', './core', './parse', './task'],
 
   dslDefine.selectFirst = selectFirst;
   return dslDefine;
-  
-});  
 
+});
 /*global define:true */
 
 
 
 define('react/track-tasks',[], function () {
   
+
   /**
      Track the tasks, start, complete, args, results, elapsed time
      Emits events that can be monitored
@@ -2814,18 +2852,18 @@ define('react/track-tasks',[], function () {
 
   }
 
-  return trackTasks; 
-
-});  
+  return trackTasks;
 
+});
 /*global define:true */
 
 
 
 define('react/log-events',['util'], function (util) { // TODO replace util.inspect with something portable to browser
+  
 
   var logEventsMod = { };
-  
+
   /**
      Log events to console.error
 
@@ -2837,31 +2875,31 @@ define('react/log-events',['util'], function (util) { // TODO replace util.inspe
      react.logEvents(flowFn, 'flow.*'); // log all flow events on flowFn only
     */
 
-    var ALL_FLOW_EVENTS = 'flow.*';
+  var ALL_FLOW_EVENTS = 'flow.*';
   var ALL_TASK_EVENTS = 'task.*';
   var FLOW_RE = /^flow\./;
 
   function flowLog(obj) {
     /*jshint validthis: true */
     var time = new Date();
-      time.setTime(obj.time);
+    time.setTime(obj.startTime);
     var argsNoCb = obj.args.filter(function (a) { return (typeof(a) !== 'function'); });
     var eventTimeStr = time.toISOString();
     if (this.event === 'flow.complete') {
-      var env = obj; 
+      var env = obj;
       console.error('%s: %s \tmsecs: %s \n\targs: %s \n\tresults: %s\n',
-                    this.event, env.name, env.elapsedTime, util.inspect(argsNoCb), util.inspect(env.results));   
+                    this.event, env.name, env.elapsedTime, util.inspect(argsNoCb), util.inspect(env.results));
     } else {
       var name = obj.name;
       var args = obj.args;
       console.error('%s: %s \n\targs: %s\n', this.event, name, util.inspect(argsNoCb));
-    }    
+    }
   }
 
   function taskLog(obj) {
     /*jshint validthis: true */
     var time = new Date();
-    time.setTime(obj.time);
+    time.setTime(obj.startTime);
     var argsNoCb = obj.args.filter(function (a) { return (typeof(a) !== 'function'); });
     var eventTimeStr = time.toISOString();
     if (this.event === 'task.complete') {
@@ -2873,46 +2911,55 @@ define('react/log-events',['util'], function (util) { // TODO replace util.inspe
       var args = obj.args;
       console.error('%s: %s:%s \n\targs: %s\n', this.event, obj.env.name, obj.name, util.inspect(argsNoCb));
     }
-    
+
   }
 
   /**
      Log flow and task events for a flowFn or all of react.
      If called multiple times, remove previous listener (if any) before
      adding.
-     
+
      @example
      var react = require('react');
      react.logEvents(flowFn, eventWildcard); //log events on flowfn matching wildcard
-     
+
      @param flowFn Flow function or global react object
      @param eventWildcard wildcarded event type, if not provided use flow.* and task.*
   */
   function logEvents(flowFn, eventWildcard) {
     if (!flowFn) throw new Error('flowFn is required');
-    if (eventWildcard && eventWildcard !== '*') {
+    if (!flowFn.events._loggingEvents) flowFn.events._loggingEvents = [];
+    if (eventWildcard === false) { // turn off logging
+      flowFn.events._loggingEvents.forEach(function (evt) {
+        flowFn.events.removeAllListeners(evt);
+      });
+      flowFn.events._loggingEvents.length = 0; // clear
+    } else if (eventWildcard && eventWildcard !== '*') {
       var logFn = (FLOW_RE.test(eventWildcard)) ? flowLog : taskLog;
       flowFn.events.removeListener(eventWildcard, logFn);
       flowFn.events.on(eventWildcard, logFn);
+      flowFn.events._loggingEvents.push(eventWildcard);
     } else { // none provided, use flow.* and task.*
       //output events as tasks start and complete
       flowFn.events.removeListener(ALL_FLOW_EVENTS, flowLog);
       flowFn.events.on(ALL_FLOW_EVENTS, flowLog);
+      flowFn.events._loggingEvents.push(ALL_FLOW_EVENTS);
       flowFn.events.removeListener(ALL_TASK_EVENTS, taskLog);
-      flowFn.events.on(ALL_TASK_EVENTS, taskLog);      
+      flowFn.events.on(ALL_TASK_EVENTS, taskLog);
+      flowFn.events._loggingEvents.push(ALL_TASK_EVENTS);
     }
   }
 
   logEventsMod.logEvents = logEvents;
   return logEventsMod;
 
-});  
-
+});
 /*global define:true */
 
 
 
 define('react/promise-resolve',[], function () {
+  
 
   /**
      Auto resolve promises passed in as arguments to the flow
@@ -2924,9 +2971,9 @@ define('react/promise-resolve',[], function () {
   */
 
 
-    var PROMISE_SUFFIX = '__promise';  // added to param names that are promises
+  var PROMISE_SUFFIX = '__promise';  // added to param names that are promises
 
-    var resolvingPromises = false;
+  var resolvingPromises = false;
 
   function resolvePromises(react) {
     if (resolvingPromises) return; // already resolving
@@ -2954,13 +3001,13 @@ define('react/promise-resolve',[], function () {
 
   return resolvePromises;
 
-});  
-
+});
 /*global define:true */
 
 
 
 define('react/event-collector',[], function () {
+  
 
   /**
      create an instance of the event collector
@@ -3013,9 +3060,9 @@ define('react/event-collector',[], function () {
         } else if (TASK_EVENTS_RE.test(this.event)) {
           eventObject.task = obj;
         } else if (AST_EVENTS_RE.test(this.event)) {
-          eventObject.ast = obj;      
+          eventObject.ast = obj;
         }
-        self.events.push(eventObject);      
+        self.events.push(eventObject);
       }
       emitter.on(eventId, accumEvents);
     };
@@ -3028,22 +3075,22 @@ define('react/event-collector',[], function () {
       this.events = []; // clear
     };
 
-    return new EventCollector();  
+    return new EventCollector();
   }
 
   return instantiate; // return the factory for creating EventCollector
-  
-});  
 
+});
 /*global define:true */
 
 
 
-define('react',['./core', './dsl', './track-tasks', './log-events', './promise-resolve', './event-collector'],
+define('react/react',['./core', './dsl', './track-tasks', './log-events', './promise-resolve', './event-collector'],
        function (core, dsl, trackTasksFn, logEventsMod, resolvePromisesFn, eventCollectorFactory) {
+  
 
   var react = dsl; // core + default dsl
-         
+
   /**
      Enable detection of promises and resolution
     */
@@ -3057,8 +3104,8 @@ define('react',['./core', './dsl', './track-tasks', './log-events', './promise-r
     */
   function trackTasks() {
     trackTasksFn(react);
-  }  
-         
+  }
+
   /**
      If called, load the built-in plugin for log events and invoke
 
@@ -3066,7 +3113,7 @@ define('react',['./core', './dsl', './track-tasks', './log-events', './promise-r
      @param eventWildcard [string] pattern to log events for
   */
   function logEvents(flowFn, eventWildcard) {
-    if (!eventWildcard && typeof(flowFn) === 'string') { // only wildcard provided
+    if (typeof(flowFn) !== 'function') { // only wildcard provided
       eventWildcard = flowFn;
       flowFn = undefined;
     }
@@ -3087,7 +3134,8 @@ define('react',['./core', './dsl', './track-tasks', './log-events', './promise-r
   react.logEvents = logEvents;  // enable event logging
   react.resolvePromises = resolvePromises; // enable promise resolution
   react.trackTasks = trackTasks; // enable tracking of tasks
-  react.createEventCollector = createEventCollector; // create instance of EventCollector       
+  react.createEventCollector = createEventCollector; // create instance of EventCollector
   return react;
-  
-});
+
+});
+define('react', ['react/react'], function (main) { return main; });