flexy/lib/dispatcher.js

A Flux library based on Channels and reducer functions

'use strict';

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

var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();

exports.defineDispatcher = defineDispatcher;

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

function _slicedToArray(arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }

var _jsCsp = require('js-csp');

var _transducersJs = require('transducers.js');

var _immutable = require('immutable');

var _immutable2 = _interopRequireDefault(_immutable);

function defineDispatcher(_ref) {
  var transformers = _ref.transformers;

  return (function () {
    var _class = function () {
      _classCallCheck(this, _class);

      this.outCh = _jsCsp.chan(_jsCsp.buffers.fixed(10), _transducersJs.compose(_transducersJs.filter(function (value) {
        return !!value;
      })));
      this.outMult = _jsCsp.operations.mult(this.outCh);
      this._subscribers = _immutable2['default'].Set();
    };

    _createClass(_class, [{
      key: 'listen',
      value: function listen(source) {

        if (source.outMult && source.throughMult) {
          source = source.throughMult;
        } else if (source.outMult) {
          source = source.outMult;
        }

        var ch = _jsCsp.chan();
        var that = this;
        _jsCsp.operations.mult.tap(source, ch);

        _jsCsp.go(regeneratorRuntime.mark(function callee$3$0() {
          var value;
          return regeneratorRuntime.wrap(function callee$3$0$(context$4$0) {
            while (1) switch (context$4$0.prev = context$4$0.next) {
              case 0:
                context$4$0.next = 2;
                return _jsCsp.take(ch);

              case 2:
                value = context$4$0.sent;

              case 3:
                if (!(value !== _jsCsp.CLOSED)) {
                  context$4$0.next = 10;
                  break;
                }

                that.trigger(value);
                context$4$0.next = 7;
                return _jsCsp.take(ch);

              case 7:
                value = context$4$0.sent;
                context$4$0.next = 3;
                break;

              case 10:
              case 'end':
                return context$4$0.stop();
            }
          }, callee$3$0, this);
        }));

        return this;
      }
    }, {
      key: 'broadcast',
      value: function broadcast(value) {
        this._subscribers.map(function (list) {
          return list.toJS();
        }).forEach(function (_ref2) {
          var _ref22 = _slicedToArray(_ref2, 2);

          var subscriber = _ref22[0];
          var ctx = _ref22[1];
          return subscriber.call(ctx, value);
        });
      }
    }, {
      key: 'subscribe',
      value: function subscribe(fn) {
        var ctx = arguments[1] === undefined ? null : arguments[1];

        var list = _immutable2['default'].List([fn, ctx]);
        this._subscribers = this._subscribers.add(list);
        return list;
      }
    }, {
      key: 'unsubscribe',
      value: function unsubscribe(fn) {
        var ctx = arguments[1] === undefined ? null : arguments[1];

        var list = _immutable2['default'].List([fn, ctx]);
        this._subscribers = this._subscribers['delete'](list);
        return list;
      }
    }, {
      key: 'emit',
      value: function emit() {
        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        this.trigger.apply(this, args);
      }
    }, {
      key: 'trigger',
      value: function trigger(name, payload, promise) {
        if (typeof name === 'string') {
          var obj = transformers[name] ? transformers[name]({ name: name, payload: payload, promise: promise }) : { name: name, payload: payload, promise: promise };
          _jsCsp.putAsync(this.outCh, obj);
          this.broadcast(obj);
        } else if (typeof name === 'object' && typeof name.name === 'object') {
          var obj = transformers[name] ? transformers[name](name) : name;
          _jsCsp.putAsync(this.outCh, obj);
          this.broadcast(obj);
        } else {
          console.warn('dispatched event without a name', name);
        }
      }
    }]);

    return _class;
  })();
}