fix: prevent asset conflicts between React and Grid.js versions

Add coexistence checks to all enqueue methods to prevent loading
both React and Grid.js assets simultaneously.

Changes:
- ReactAdmin.php: Only enqueue React assets when ?react=1
- Init.php: Skip Grid.js when React active on admin pages
- Form.php, Coupon.php, Access.php: Restore classic assets when ?react=0
- Customer.php, Product.php, License.php: Add coexistence checks

Now the toggle between Classic and React versions works correctly.

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

node_modules/rungen/.npmignore

@@ -0,0 +1,3 @@
+.babelrc
+.eslintrc
+test

node_modules/rungen/CHANGELOG.md

@@ -0,0 +1,11 @@
+<a name="0.1.0"></a>
+# 0.1.0 (2016-01-31)
+
+
+### Features
+
+* **controls:** Adding wrap controls ([74e4020](https://github.com/youknowriad/rungen/commit/74e4020))
+* **runtime:** Move from an experimentation stage to an alpha stage ([67876b7](https://github.com/youknowriad/rungen/commit/67876b7))
+
+
+

node_modules/rungen/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2016 Riad Benguella
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/rungen/README.md

@@ -0,0 +1,361 @@
+RunGen
+======
+
+This library provides a generic runtime around async flow in javascript.
+This provides something like [co](https://github.com/tj/co) with the ability to extend its behaviour.
+This is also largely inspired from [redux-saga](https://github.com/yelouafi/redux-saga). It first started from the idea of decoupling redux-saga from redux.
+
+API
+---
+
+If you're familiar with co, The API here is slitely different. Instead of taking a generator and returning a promise.
+We can take basically any value (pass in an iterator to have the same behavior as co for generators) and as a result uses callbacks instead of a promise.
+
+```javascript
+import {create} from 'rungen'
+const myGenerator*() {
+  yield new Promise()
+}
+
+const runtime = create()
+const onSuccess = value => console.log('success : ' + value)
+const onError = error => console.log('error : ' + error)
+runtime(myGenerator(), onSuccess, onError)
+```
+
+If you want to have a similar API than `co`, It's as easy as
+
+```javascript
+const runtime = create()
+const co = (input, ...args) => new Promise((resolve, reject) =>
+  rungen(input.apply(null, args), resolve, reject)
+)
+co.wrap = input => runtime.bind(this, input)
+
+co(myGenerator, onSuccess, onError)
+```
+
+Generic ?
+---------
+
+Co allows to you to wrap generators that yields automatically promises, iterators, arrays etc... The idea of genericity here is the ability to perform a custom process on any value depending on your needs.
+We call these custom processes : controls.
+
+Built-in Controls
+-----------------
+
+By default, you can yield generators, arrays, objects and errors : These are the base controls included in every runtime.
+
+```javascript
+import {create} from 'rungen'
+
+// Create a runtime
+const runtime = create()
+
+const myGenerator = function*(input) {
+  const value = yield input
+  return value
+}
+
+// Run the generator
+runtime(myGenerator, 'any value', value => {
+  console.log(value) // 'any value'
+}, err => {
+  console.log(err)
+})
+```
+
+Instead of running your generator directly, you can also get a simple function from your generator and run it later
+
+```javascript
+const myFunction = runtime.wrap(myGenerator)
+
+// Run it later
+myFunction('any value', value => {
+  console.log(value) // 'any value'
+}, err => {
+  console.log(err)
+})
+```
+
+### Sub-generators
+
+Nesting generators is allowed using the built-in generator control.
+
+```javascript
+const increment = function* (input) {
+  yield input
+  return input + 1
+}
+
+runtime(function* () {
+  let output = yield increment(1) // nesting
+  console.log(output) // 2
+  output = yield increment(output)
+  console.log(output) // 3
+})
+```
+
+### Arrays
+
+By using the `all` helper, yield arrays will make the runtime resolve all the values of the array and get the result as an array.
+Here is an example combining the array and the subgenerator control.
+
+```javascript
+import {all} from 'rungen'
+
+const increment = function* (input) {
+  yield input
+  return input + 1
+}
+
+runtime(function* () {
+  let output = yield all([
+    increment(1),
+    4,
+    increment(3)
+  ])
+  console.log(output) // [2, 4, 3]
+})
+```
+
+### Objects
+
+By using the `all` helper, in the same way as arrays, yielding javascript objets will resolve all the attributes of the objects
+and return an object containing the resolved values.
+
+```javascript
+import {all} from 'rungen'
+
+const increment = function* (input) {
+  yield input
+  return input + 1
+}
+
+runtime(function* () {
+  let output = yield all({
+    a: increment(1),
+    b: 4,
+    c: increment(3)
+  })
+  console.log(output) // { a: 2, b: 4, c: 3 }
+})
+```
+
+Async controls
+--------------
+
+RunGen offers you some async controls that allows you to write basically any async flow in a simple declarative way.
+These controls are opt-in, this means you can choose to use them or not in your runtime. Here is how to do that.
+
+```javascript
+import {create, asyncControls} from 'rungen'
+
+// creating a runtime with these controls
+const runtime = create(asyncControls)
+```
+
+## Promise
+
+Async controls allows you to yield promises, the runtime resolves the promise and returns the resolved value on success or trigger an error on failure.
+
+```javascript
+import {delay} from 'rungen'
+
+runtime(function* {
+  yield delay(10) // delay is just a helper that returns a promise resolved after a timeout
+  const output = yield Promise.resolve(1)
+  console.log(output) // 1
+})
+```
+
+## fork/join
+
+When dealing with async flows, we need a way to trigger non blocking calls, this can be done easily using the `fork` helper.
+
+```javascript
+import {fork, delay} from 'rungen'
+
+const subGenerator = function*(timeout, input) {
+  yield delay(timeout)
+  console.log(input)
+}
+
+runtime(function*() {
+  yield fork(subgenerator(10, 1))
+  yield fork(subgenerator(5, 2))
+})
+
+// this will output 2 than 1
+```
+
+We can get the result of a forked generator using the `join` helper (join raises an error if the forked task has already finished)
+
+```javascript
+import {fork, join, delay} from 'rungen'
+
+const subGenerator = function*(timeout, input) {
+  yield delay(timeout)
+  console.log(input)
+
+  return input+1
+}
+
+runtime(function*() {
+  const task1 = yield fork(subgenerator(10, 1))
+  const task2 = yield fork(subgenerator(5, 2))
+
+  yield delay(6)
+  const output = yield join(task1)
+  console.log(output) // 2
+  yield join(task2) // throws an error because task2 is already terminated
+})
+
+// this will output 2 than 1
+```
+
+## race
+
+Race is a special control that lets you deal with race conditions. For example : timeouts on API calls.
+
+```javascript
+import {race, delay} from 'rungen'
+
+runtime(function*() {
+  const { result, timeout } = race({
+    result: fetch('/myApi'),
+    timeout: delay(500)
+  })
+
+  if (timeout) {
+    // fetch took more than a half second
+  } else {
+    console.log(result)
+  }
+})
+```
+
+Race can also be used using arrays
+
+```javascript
+import {race, delay} from 'rungen'
+
+runtime(function*() {
+  const [result, timeout] = race([
+    fetch('/myApi'),
+    delay(500)
+  })
+
+  if (timeout) {
+    // fetch took more than a half second
+  } else {
+    console.log(result)
+  }
+})
+```
+
+Wrap controls
+-------------
+
+To ease testing generators without the need of mocks, we have to avoid triggering any side effect (api calls, timeouts...) in the generator.
+We use some of those effects in our previous example : calling fork, join or race helpers returs a simple javascript object and doest trigger any side effect.
+The wrap controls can be used to extend this mecanism to any function call.
+
+## invoke, call and apply
+
+those are helpers used to tell the runtime to trigger a function call, but the function is not called directory in the generator.
+
+```javascript
+import {create, invoke, wrapControls, asyncControls} from 'rungen'
+
+runtime = create([...asyncControls, ...wrapControls])
+function myApiCall(input) {
+  return fetch('/api/' + input)
+}
+
+const myGenerator = function* {
+  const result = yield invoke(myApiCall, 'param')
+
+  return result
+}
+
+runtime(myGenerator)
+```
+
+testing this generator is now straighforward
+
+```javascript
+// the generator to test
+const gen = myGenerator()
+// Asserts
+expect(gen.next().value).toEqual(invoke(myApiCall, 'param'))
+expect(gen.next('result').toEqual({ done: true, value: 'result' })
+```
+
+`apply` and `call` do the same thing as the `invoke` helper with the ability to specify a context (the `this` inside the function call)
+
+```javascript
+import {call, apply} from 'rungen'
+
+runtime(function* () {
+  let result
+  // these two are equivalent
+  result = yield call(myFunction, context, arg1, arg2)
+  result = yield apply(myFunction, context, [arg1, arg2])
+})
+```
+
+## cps
+
+In nodejs, libraries often use cps (Continuation-passing style). functions expecting the last argument to be a callback with the following signature : `(err, result) => void`
+RunGen provide a helper that wraps these kind of function calls.
+
+```javascript
+import {cps} from 'rungen'
+
+function cpsApi(timeout, output, callback) {
+  setTimeout(() => callback(false, output), timeout)
+}
+
+runtime(function* () {
+  const result = yield cps(cpsApi, 1000, 2)
+  console.log(result) // displays 2 after one second timeout
+})
+```
+
+Custom Controls
+---------------
+
+A control is an function with the following signature `(value, next) => bool`
+ * the function returns a boolean whether or not, it handles the yielded value passed as argument
+ * Once the value has been resolved, It should call the `next` callback with the result
+
+Let's say we are going to create a control that allows us to get values from the localStorage
+```javascript
+import {create} from 'rungen'
+
+// pushing data test
+localStorage.set('token', 'myToken')
+
+// Creating the custom control
+myCustomLocalStorageControl = (value, next) {
+  if (typeof value !== 'object' || value.type !== 'localstorage') return false
+  next(localStorage.get(value.key))
+  return true
+}
+
+// Creating a runtime with this control
+runtime = create([ myCustomLocalStorageControl ])
+
+runtime(function* () {
+  const output = yield { type: 'localstorage', key: 'token' }
+  console.log(output) // outputs : myToken
+})
+```
+
+While this should be fine for almost all custom controls use cases, there are some cases when you would need to call some specific callbacks.
+The full signature of the control is : `(value, next, runtime, yieldNext, yieldError) => bool`
+   * the `next` callback : we call this with a resolved value, when we handled the current value and we have no idea about the result (like promises)
+   * the `runtime` callback : the runtime itself, can be used to perform nesting
+   * the `yieldNext` callback : is a shortcut to avoid infinite loops, it directly yields the resolved value without trying to resolve it as well. This can be usefull to avoid infinte loops, for example in an arrayControl takes an array and yields an array as a result
+   * the `yieldError` callback : called to trigger an error (that can be catched using try/catch in the generator)

node_modules/rungen/dist/controls/async.js

@@ -0,0 +1,115 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.race = exports.join = exports.fork = exports.promise = undefined;
+
+var _is = require('../utils/is');
+
+var _is2 = _interopRequireDefault(_is);
+
+var _helpers = require('../utils/helpers');
+
+var _dispatcher = require('../utils/dispatcher');
+
+var _dispatcher2 = _interopRequireDefault(_dispatcher);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var promise = exports.promise = function promise(value, next, rungen, yieldNext, raiseNext) {
+  if (!_is2.default.promise(value)) return false;
+  value.then(next, raiseNext);
+  return true;
+};
+
+var forkedTasks = new Map();
+var fork = exports.fork = function fork(value, next, rungen) {
+  if (!_is2.default.fork(value)) return false;
+  var task = Symbol('fork');
+  var dispatcher = (0, _dispatcher2.default)();
+  forkedTasks.set(task, dispatcher);
+  rungen(value.iterator.apply(null, value.args), function (result) {
+    return dispatcher.dispatch(result);
+  }, function (err) {
+    return dispatcher.dispatch((0, _helpers.error)(err));
+  });
+  var unsubscribe = dispatcher.subscribe(function () {
+    unsubscribe();
+    forkedTasks.delete(task);
+  });
+  next(task);
+  return true;
+};
+
+var join = exports.join = function join(value, next, rungen, yieldNext, raiseNext) {
+  if (!_is2.default.join(value)) return false;
+  var dispatcher = forkedTasks.get(value.task);
+  if (!dispatcher) {
+    raiseNext('join error : task not found');
+  } else {
+    (function () {
+      var unsubscribe = dispatcher.subscribe(function (result) {
+        unsubscribe();
+        next(result);
+      });
+    })();
+  }
+  return true;
+};
+
+var race = exports.race = function race(value, next, rungen, yieldNext, raiseNext) {
+  if (!_is2.default.race(value)) return false;
+  var finished = false;
+  var success = function success(result, k, v) {
+    if (finished) return;
+    finished = true;
+    result[k] = v;
+    next(result);
+  };
+
+  var fail = function fail(err) {
+    if (finished) return;
+    raiseNext(err);
+  };
+  if (_is2.default.array(value.competitors)) {
+    (function () {
+      var result = value.competitors.map(function () {
+        return false;
+      });
+      value.competitors.forEach(function (competitor, index) {
+        rungen(competitor, function (output) {
+          return success(result, index, output);
+        }, fail);
+      });
+    })();
+  } else {
+    (function () {
+      var result = Object.keys(value.competitors).reduce(function (p, c) {
+        p[c] = false;
+        return p;
+      }, {});
+      Object.keys(value.competitors).forEach(function (index) {
+        rungen(value.competitors[index], function (output) {
+          return success(result, index, output);
+        }, fail);
+      });
+    })();
+  }
+  return true;
+};
+
+var subscribe = function subscribe(value, next) {
+  if (!_is2.default.subscribe(value)) return false;
+  if (!_is2.default.channel(value.channel)) {
+    throw new Error('the first argument of "subscribe" must be a valid channel');
+  }
+  var unsubscribe = value.channel.subscribe(function (ret) {
+    unsubscribe && unsubscribe();
+    next(ret);
+  });
+
+  return true;
+};
+
+exports.default = [promise, fork, join, race, subscribe];

node_modules/rungen/dist/controls/builtin.js

@@ -0,0 +1,94 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.iterator = exports.array = exports.object = exports.error = exports.any = undefined;
+
+var _is = require('../utils/is');
+
+var _is2 = _interopRequireDefault(_is);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var any = exports.any = function any(value, next, rungen, yieldNext) {
+  yieldNext(value);
+  return true;
+};
+
+var error = exports.error = function error(value, next, rungen, yieldNext, raiseNext) {
+  if (!_is2.default.error(value)) return false;
+  raiseNext(value.error);
+  return true;
+};
+
+var object = exports.object = function object(value, next, rungen, yieldNext, raiseNext) {
+  if (!_is2.default.all(value) || !_is2.default.obj(value.value)) return false;
+  var result = {};
+  var keys = Object.keys(value.value);
+  var count = 0;
+  var hasError = false;
+  var gotResultSuccess = function gotResultSuccess(key, ret) {
+    if (hasError) return;
+    result[key] = ret;
+    count++;
+    if (count === keys.length) {
+      yieldNext(result);
+    }
+  };
+
+  var gotResultError = function gotResultError(key, error) {
+    if (hasError) return;
+    hasError = true;
+    raiseNext(error);
+  };
+
+  keys.map(function (key) {
+    rungen(value.value[key], function (ret) {
+      return gotResultSuccess(key, ret);
+    }, function (err) {
+      return gotResultError(key, err);
+    });
+  });
+
+  return true;
+};
+
+var array = exports.array = function array(value, next, rungen, yieldNext, raiseNext) {
+  if (!_is2.default.all(value) || !_is2.default.array(value.value)) return false;
+  var result = [];
+  var count = 0;
+  var hasError = false;
+  var gotResultSuccess = function gotResultSuccess(key, ret) {
+    if (hasError) return;
+    result[key] = ret;
+    count++;
+    if (count === value.value.length) {
+      yieldNext(result);
+    }
+  };
+
+  var gotResultError = function gotResultError(key, error) {
+    if (hasError) return;
+    hasError = true;
+    raiseNext(error);
+  };
+
+  value.value.map(function (v, key) {
+    rungen(v, function (ret) {
+      return gotResultSuccess(key, ret);
+    }, function (err) {
+      return gotResultError(key, err);
+    });
+  });
+
+  return true;
+};
+
+var iterator = exports.iterator = function iterator(value, next, rungen, yieldNext, raiseNext) {
+  if (!_is2.default.iterator(value)) return false;
+  rungen(value, next, raiseNext);
+  return true;
+};
+
+exports.default = [error, iterator, array, object, any];

node_modules/rungen/dist/controls/wrap.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cps = exports.call = undefined;
+
+var _is = require('../utils/is');
+
+var _is2 = _interopRequireDefault(_is);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+var call = exports.call = function call(value, next, rungen, yieldNext, raiseNext) {
+  if (!_is2.default.call(value)) return false;
+  try {
+    next(value.func.apply(value.context, value.args));
+  } catch (err) {
+    raiseNext(err);
+  }
+  return true;
+};
+
+var cps = exports.cps = function cps(value, next, rungen, yieldNext, raiseNext) {
+  var _value$func;
+
+  if (!_is2.default.cps(value)) return false;
+  (_value$func = value.func).call.apply(_value$func, [null].concat(_toConsumableArray(value.args), [function (err, result) {
+    if (err) raiseNext(err);else next(result);
+  }]));
+  return true;
+};
+
+exports.default = [call, cps];

node_modules/rungen/dist/create.js

@@ -0,0 +1,79 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _builtin = require('./controls/builtin');
+
+var _builtin2 = _interopRequireDefault(_builtin);
+
+var _is = require('./utils/is');
+
+var _is2 = _interopRequireDefault(_is);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+var create = function create() {
+  var userControls = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];
+
+  var controls = [].concat(_toConsumableArray(userControls), _toConsumableArray(_builtin2.default));
+
+  var runtime = function runtime(input) {
+    var success = arguments.length <= 1 || arguments[1] === undefined ? function () {} : arguments[1];
+    var error = arguments.length <= 2 || arguments[2] === undefined ? function () {} : arguments[2];
+
+    var iterate = function iterate(gen) {
+      var yieldValue = function yieldValue(isError) {
+        return function (ret) {
+          try {
+            var _ref = isError ? gen.throw(ret) : gen.next(ret);
+
+            var value = _ref.value;
+            var done = _ref.done;
+
+            if (done) return success(value);
+            next(value);
+          } catch (e) {
+            return error(e);
+          }
+        };
+      };
+
+      var next = function next(ret) {
+        controls.some(function (control) {
+          return control(ret, next, runtime, yieldValue(false), yieldValue(true));
+        });
+      };
+
+      yieldValue(false)();
+    };
+
+    var iterator = _is2.default.iterator(input) ? input : regeneratorRuntime.mark(function _callee() {
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return input;
+
+            case 2:
+              return _context.abrupt('return', _context.sent);
+
+            case 3:
+            case 'end':
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    })();
+
+    iterate(iterator, success, error);
+  };
+
+  return runtime;
+};
+
+exports.default = create;

node_modules/rungen/dist/index.js

@@ -0,0 +1,36 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wrapControls = exports.asyncControls = exports.create = undefined;
+
+var _helpers = require('./utils/helpers');
+
+Object.keys(_helpers).forEach(function (key) {
+  if (key === "default") return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _helpers[key];
+    }
+  });
+});
+
+var _create = require('./create');
+
+var _create2 = _interopRequireDefault(_create);
+
+var _async = require('./controls/async');
+
+var _async2 = _interopRequireDefault(_async);
+
+var _wrap = require('./controls/wrap');
+
+var _wrap2 = _interopRequireDefault(_wrap);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.create = _create2.default;
+exports.asyncControls = _async2.default;
+exports.wrapControls = _wrap2.default;

node_modules/rungen/dist/utils/dispatcher.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var createDispatcher = function createDispatcher() {
+  var listeners = [];
+
+  return {
+    subscribe: function subscribe(listener) {
+      listeners.push(listener);
+      return function () {
+        listeners = listeners.filter(function (l) {
+          return l !== listener;
+        });
+      };
+    },
+    dispatch: function dispatch(action) {
+      listeners.slice().forEach(function (listener) {
+        return listener(action);
+      });
+    }
+  };
+};
+
+exports.default = createDispatcher;

node_modules/rungen/dist/utils/helpers.js

@@ -0,0 +1,134 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createChannel = exports.subscribe = exports.cps = exports.apply = exports.call = exports.invoke = exports.delay = exports.race = exports.join = exports.fork = exports.error = exports.all = undefined;
+
+var _keys = require('./keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var all = exports.all = function all(value) {
+  return {
+    type: _keys2.default.all,
+    value: value
+  };
+};
+
+var error = exports.error = function error(err) {
+  return {
+    type: _keys2.default.error,
+    error: err
+  };
+};
+
+var fork = exports.fork = function fork(iterator) {
+  for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+
+  return {
+    type: _keys2.default.fork,
+    iterator: iterator,
+    args: args
+  };
+};
+
+var join = exports.join = function join(task) {
+  return {
+    type: _keys2.default.join,
+    task: task
+  };
+};
+
+var race = exports.race = function race(competitors) {
+  return {
+    type: _keys2.default.race,
+    competitors: competitors
+  };
+};
+
+var delay = exports.delay = function delay(timeout) {
+  return new Promise(function (resolve) {
+    setTimeout(function () {
+      return resolve(true);
+    }, timeout);
+  });
+};
+
+var invoke = exports.invoke = function invoke(func) {
+  for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+    args[_key2 - 1] = arguments[_key2];
+  }
+
+  return {
+    type: _keys2.default.call,
+    func: func,
+    context: null,
+    args: args
+  };
+};
+
+var call = exports.call = function call(func, context) {
+  for (var _len3 = arguments.length, args = Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
+    args[_key3 - 2] = arguments[_key3];
+  }
+
+  return {
+    type: _keys2.default.call,
+    func: func,
+    context: context,
+    args: args
+  };
+};
+
+var apply = exports.apply = function apply(func, context, args) {
+  return {
+    type: _keys2.default.call,
+    func: func,
+    context: context,
+    args: args
+  };
+};
+
+var cps = exports.cps = function cps(func) {
+  for (var _len4 = arguments.length, args = Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+    args[_key4 - 1] = arguments[_key4];
+  }
+
+  return {
+    type: _keys2.default.cps,
+    func: func,
+    args: args
+  };
+};
+
+var subscribe = exports.subscribe = function subscribe(channel) {
+  return {
+    type: _keys2.default.subscribe,
+    channel: channel
+  };
+};
+
+var createChannel = exports.createChannel = function createChannel(callback) {
+  var listeners = [];
+  var subscribe = function subscribe(l) {
+    listeners.push(l);
+    return function () {
+      return listeners.splice(listeners.indexOf(l), 1);
+    };
+  };
+  var next = function next(val) {
+    return listeners.forEach(function (l) {
+      return l(val);
+    });
+  };
+  callback(next);
+
+  return {
+    subscribe: subscribe
+  };
+};

node_modules/rungen/dist/utils/is.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
+
+var _keys = require('./keys');
+
+var _keys2 = _interopRequireDefault(_keys);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var is = {
+  obj: function obj(value) {
+    return (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && !!value;
+  },
+  all: function all(value) {
+    return is.obj(value) && value.type === _keys2.default.all;
+  },
+  error: function error(value) {
+    return is.obj(value) && value.type === _keys2.default.error;
+  },
+  array: Array.isArray,
+  func: function func(value) {
+    return typeof value === 'function';
+  },
+  promise: function promise(value) {
+    return value && is.func(value.then);
+  },
+  iterator: function iterator(value) {
+    return value && is.func(value.next) && is.func(value.throw);
+  },
+  fork: function fork(value) {
+    return is.obj(value) && value.type === _keys2.default.fork;
+  },
+  join: function join(value) {
+    return is.obj(value) && value.type === _keys2.default.join;
+  },
+  race: function race(value) {
+    return is.obj(value) && value.type === _keys2.default.race;
+  },
+  call: function call(value) {
+    return is.obj(value) && value.type === _keys2.default.call;
+  },
+  cps: function cps(value) {
+    return is.obj(value) && value.type === _keys2.default.cps;
+  },
+  subscribe: function subscribe(value) {
+    return is.obj(value) && value.type === _keys2.default.subscribe;
+  },
+  channel: function channel(value) {
+    return is.obj(value) && is.func(value.subscribe);
+  }
+};
+
+exports.default = is;

node_modules/rungen/dist/utils/keys.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var keys = {
+  all: Symbol('all'),
+  error: Symbol('error'),
+  fork: Symbol('fork'),
+  join: Symbol('join'),
+  race: Symbol('race'),
+  call: Symbol('call'),
+  cps: Symbol('cps'),
+  subscribe: Symbol('subscribe')
+};
+
+exports.default = keys;

node_modules/rungen/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "rungen",
+  "version": "0.3.2",
+  "description": "A generator runtime creator",
+  "main": "dist/index.js",
+  "devDependencies": {
+    "babel": "^6.3.26",
+    "babel-cli": "^6.4.5",
+    "babel-eslint": "^5.0.0-beta8",
+    "babel-polyfill": "^6.3.14",
+    "babel-preset-es2015": "^6.3.13",
+    "babel-register": "^6.4.3",
+    "conventional-changelog": "^0.5.3",
+    "eslint": "^1.10.3",
+    "expect": "^1.13.4",
+    "mocha": "^2.4.5",
+    "rimraf": "^2.5.1"
+  },
+  "scripts": {
+    "lint": "eslint src",
+    "compile": "rimraf lib && babel -d dist/ src/",
+    "prepublish": "npm run test && npm run compile",
+    "unit": "mocha --compilers js:babel-register --recursive test",
+    "test": "npm run lint && npm run unit",
+    "changelog": "conventional-changelog -i CHANGELOG.md -w -r 0 -p angular"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/youknowriad/rungen.git"
+  },
+  "author": "Riad Benguella <riad@rizeway.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/youknowriad/rungen/issues"
+  },
+  "homepage": "https://github.com/youknowriad/rungen#readme"
+}

node_modules/rungen/src/controls/async.js

@@ -0,0 +1,89 @@
+import is from '../utils/is'
+import {error} from '../utils/helpers'
+import createDispatcher from '../utils/dispatcher'
+
+export const promise = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.promise(value)) return false
+  value.then(next, raiseNext)
+  return true
+}
+
+const forkedTasks = new Map()
+export const fork = (value, next, rungen) => {
+  if (!is.fork(value)) return false
+  const task = Symbol('fork')
+  const dispatcher = createDispatcher()
+  forkedTasks.set(task, dispatcher)
+  rungen(
+    value.iterator.apply(null, value.args),
+    result => dispatcher.dispatch(result),
+    err => dispatcher.dispatch(error(err))
+  )
+  const unsubscribe = dispatcher.subscribe(() => {
+    unsubscribe()
+    forkedTasks.delete(task)
+  })
+  next(task)
+  return true
+}
+
+export const join = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.join(value)) return false
+  const dispatcher = forkedTasks.get(value.task)
+  if (!dispatcher) {
+    raiseNext('join error : task not found')
+  } else {
+    const unsubscribe = dispatcher.subscribe(result => {
+      unsubscribe()
+      next(result)
+    })
+  }
+  return true
+}
+
+export const race = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.race(value)) return false
+  let finished = false
+  const success = (result, k, v) => {
+    if (finished) return
+    finished = true
+    result[k] = v
+    next(result)
+  }
+
+  const fail = err => {
+    if (finished) return
+    raiseNext(err)
+  }
+  if (is.array(value.competitors)) {
+    const result = value.competitors.map(() => false)
+    value.competitors.forEach((competitor, index) => {
+      rungen(competitor, output => success(result, index, output), fail)
+    })
+  }
+  else {
+    const result = Object.keys(value.competitors).reduce((p, c) => {
+      p[c] = false
+      return p
+    }, {})
+    Object.keys(value.competitors).forEach(index => {
+      rungen(value.competitors[index], output => success(result, index, output), fail)
+    })
+  }
+  return true
+}
+
+const subscribe = (value, next) => {
+  if (!is.subscribe(value)) return false
+  if (!is.channel(value.channel)) {
+    throw new Error('the first argument of "subscribe" must be a valid channel')
+  }
+  const unsubscribe = value.channel.subscribe(ret => {
+    unsubscribe && unsubscribe()
+    next(ret)
+  })
+
+  return true
+}
+
+export default [promise, fork, join, race, subscribe]

node_modules/rungen/src/controls/builtin.js

@@ -0,0 +1,83 @@
+import is from '../utils/is'
+
+export const any = (value, next, rungen, yieldNext) => {
+  yieldNext(value)
+  return true
+}
+
+export const error = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.error(value)) return false
+  raiseNext(value.error)
+  return true
+}
+
+export const object = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.all(value) || !is.obj(value.value)) return false
+  const result = {}
+  const keys = Object.keys(value.value)
+  let count = 0
+  let hasError = false
+  const gotResultSuccess = (key, ret) => {
+    if (hasError) return
+    result[key] = ret
+    count++
+    if (count === keys.length) {
+      yieldNext(result)
+    }
+  }
+
+  const gotResultError = (key, error) => {
+    if (hasError) return
+    hasError = true
+    raiseNext(error)
+  }
+
+  keys.map(key => {
+    rungen(
+      value.value[key],
+      ret => gotResultSuccess(key, ret),
+      err => gotResultError(key, err)
+    )
+  })
+
+  return true
+}
+
+export const array = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.all(value) || !is.array(value.value)) return false
+  const result = []
+  let count = 0
+  let hasError = false
+  const gotResultSuccess = (key, ret) => {
+    if (hasError) return
+    result[key] = ret
+    count++
+    if (count === value.value.length) {
+      yieldNext(result)
+    }
+  }
+
+  const gotResultError = (key, error) => {
+    if (hasError) return
+    hasError = true
+    raiseNext(error)
+  }
+
+  value.value.map((v, key) => {
+    rungen(
+      v,
+      ret => gotResultSuccess(key, ret),
+      err => gotResultError(key, err)
+    )
+  })
+
+  return true
+}
+
+export const iterator = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.iterator(value)) return false
+  rungen(value, next, raiseNext)
+  return true
+}
+
+export default [error, iterator, array, object, any]

node_modules/rungen/src/controls/wrap.js

@@ -0,0 +1,22 @@
+import is from '../utils/is'
+
+export const call = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.call(value)) return false
+  try {
+    next(value.func.apply(value.context, value.args))
+  } catch (err) {
+    raiseNext(err)
+  }
+  return true
+}
+
+export const cps = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.cps(value)) return false
+  value.func.call(null, ...value.args, (err, result) => {
+    if (err) raiseNext(err)
+    else next(result)
+  })
+  return true
+}
+
+export default [call, cps]

node_modules/rungen/src/create.js

@@ -0,0 +1,38 @@
+import builtinControls from './controls/builtin'
+import is from './utils/is'
+
+const create = (userControls = []) => {
+  const controls = [...userControls, ...builtinControls]
+
+  const runtime = (input, success = () => {}, error = () => {}) => {
+    const iterate = gen => {
+      const yieldValue = isError => ret => {
+        try {
+          const { value, done } = isError ? gen.throw(ret) : gen.next(ret)
+          if (done) return success(value)
+          next(value)
+        } catch (e) {
+          return error(e)
+        }
+      }
+
+      const next = ret => {
+        controls.some(control => control(ret, next, runtime, yieldValue(false), yieldValue(true)))
+      }
+
+      yieldValue(false)()
+    }
+
+    const iterator = is.iterator(input)
+      ? input
+      : function* () {
+          return yield input
+        }()
+
+    iterate(iterator, success, error)
+  }
+
+  return runtime
+}
+
+export default create;

node_modules/rungen/src/index.js

@@ -0,0 +1,10 @@
+import create from './create'
+export {create}
+
+import asyncControls from './controls/async'
+export {asyncControls}
+
+import wrapControls from './controls/wrap'
+export {wrapControls}
+
+export * from './utils/helpers'

node_modules/rungen/src/utils/dispatcher.js

@@ -0,0 +1,17 @@
+const createDispatcher = () => {
+  let listeners = []
+
+  return {
+    subscribe: (listener) => {
+      listeners.push(listener)
+      return () => {
+        listeners = listeners.filter(l => l !== listener)
+      }
+    },
+    dispatch: (action) => {
+      listeners.slice().forEach(listener => listener(action))
+    }
+  }
+}
+
+export default createDispatcher

node_modules/rungen/src/utils/helpers.js

@@ -0,0 +1,77 @@
+import keys from './keys'
+
+export const all = value => ({
+  type: keys.all,
+  value
+})
+
+export const error = err => ({
+  type: keys.error,
+  error: err
+})
+
+export const fork = (iterator, ...args) => ({
+  type: keys.fork,
+  iterator,
+  args
+})
+
+export const join = task => ({
+  type: keys.join,
+  task
+})
+
+export const race = competitors => ({
+  type: keys.race,
+  competitors
+})
+
+export const delay = timeout => new Promise(resolve => {
+  setTimeout(() => resolve(true), timeout)
+})
+
+export const invoke = (func, ...args) => ({
+  type: keys.call,
+  func,
+  context: null,
+  args
+})
+
+export const call = (func, context, ...args) => ({
+  type: keys.call,
+  func,
+  context,
+  args
+})
+
+export const apply = (func, context, args) => ({
+  type: keys.call,
+  func,
+  context,
+  args
+})
+
+export const cps = (func, ...args) => ({
+  type: keys.cps,
+  func,
+  args
+})
+
+export const subscribe = channel => ({
+  type: keys.subscribe,
+  channel
+})
+
+export const createChannel = callback => {
+  const listeners = []
+  const subscribe = l => {
+    listeners.push(l)
+    return () => listeners.splice(listeners.indexOf(l), 1)
+  }
+  const next = val => listeners.forEach(l => l(val))
+  callback(next)
+
+  return {
+    subscribe
+  }
+}

node_modules/rungen/src/utils/is.js

@@ -0,0 +1,20 @@
+import keys from './keys'
+
+const is = {
+  obj       : value => typeof value === 'object' && !! value,
+  all       : value => is.obj(value) && value.type === keys.all,
+  error     : value => is.obj(value) && value.type === keys.error,
+  array     : Array.isArray,
+  func      : value => typeof value === 'function',
+  promise   : value => value && is.func(value.then),
+  iterator  : value => value && is.func(value.next) && is.func(value.throw),
+  fork      : value => is.obj(value) && value.type === keys.fork,
+  join      : value => is.obj(value) && value.type === keys.join,
+  race      : value => is.obj(value) && value.type === keys.race,
+  call      : value => is.obj(value) && value.type === keys.call,
+  cps       : value => is.obj(value) && value.type === keys.cps,
+  subscribe : value => is.obj(value) && value.type === keys.subscribe,
+  channel   : value => is.obj(value) && is.func(value.subscribe)
+}
+
+export default is

node_modules/rungen/src/utils/keys.js

@@ -0,0 +1,12 @@
+const keys = {
+  all       : Symbol('all'),
+  error     : Symbol('error'),
+  fork      : Symbol('fork'),
+  join      : Symbol('join'),
+  race      : Symbol('race'),
+  call      : Symbol('call'),
+  cps       : Symbol('cps'),
+  subscribe : Symbol('subscribe')
+}
+
+export default keys