esnext-async/lib/signal.js

Patterns for asynchronous computation in ES.next

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _getIterator2 = require('babel-runtime/core-js/get-iterator');

var _getIterator3 = _interopRequireDefault(_getIterator2);

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');

var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);

exports.default = signal;

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function parameterNames(fn) {
  var _fn$toString$match = fn.toString().match(/^.*?\((.*?)\)/);

  var _fn$toString$match2 = (0, _slicedToArray3.default)(_fn$toString$match, 2);

  var names = _fn$toString$match2[1];

  return names.split(/\s*,\s*/).filter(Boolean);
}

var definitions = {};
function signal(name) {
  var definition = arguments.length <= 1 || arguments[1] === undefined ? definitions[name] : arguments[1];

  definitions[name] = definition;
  var signals = parameterNames(definition).map(function (param) {
    return signal(param);
  });
  return definition.apply(undefined, (0, _toConsumableArray3.default)(signals));
}

signal.discrete = function discrete(name, source) {
  var currentValue = void 0;

  function definition() {
    return currentValue;
  }
  definition.subscribers = [];

  signal(name, definition);
  source(function (newValue) {
    currentValue = newValue;

    var _iteratorNormalCompletion = true;
    var _didIteratorError = false;
    var _iteratorError = undefined;

    try {
      for (var _iterator = (0, _getIterator3.default)(definition.subscribers), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
        var read = _step.value;

        var signals = parameterNames(read).map(function (param) {
          return signal(param);
        });
        read.apply(undefined, (0, _toConsumableArray3.default)(signals));
      }
    } catch (err) {
      _didIteratorError = true;
      _iteratorError = err;
    } finally {
      try {
        if (!_iteratorNormalCompletion && _iterator.return) {
          _iterator.return();
        }
      } finally {
        if (_didIteratorError) {
          throw _iteratorError;
        }
      }
    }
  });
};

signal.subscribe = function subscribe(read) {
  var dependencies = parameterNames(read);
  var _iteratorNormalCompletion2 = true;
  var _didIteratorError2 = false;
  var _iteratorError2 = undefined;

  try {
    for (var _iterator2 = (0, _getIterator3.default)(dependencies), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
      var dependency = _step2.value;

      definitions[dependency].subscribers.push(read);
    }
  } catch (err) {
    _didIteratorError2 = true;
    _iteratorError2 = err;
  } finally {
    try {
      if (!_iteratorNormalCompletion2 && _iterator2.return) {
        _iterator2.return();
      }
    } finally {
      if (_didIteratorError2) {
        throw _iteratorError2;
      }
    }
  }
};

signal('time', function () {
  return new Date().valueOf();
});