cyclejs-stream/dist/input-proxy.js

Observable (events stream) to which you can inject another streams.

'use strict';

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

var _slicedToArray = (function () { function sliceIterator(arr, i) { 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; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();

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; }; })();

var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };

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

function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }

require('core-js/fn/object/entries');

var _cycleCore = require('@cycle/core');

function _throwThatNotObservable() {
    throw new TypeError('source must be an observable or interactions object!');
}

var InputProxy = (function (_Rx$Subject) {
    _inherits(InputProxy, _Rx$Subject);

    function InputProxy() {
        _classCallCheck(this, InputProxy);

        _get(Object.getPrototypeOf(InputProxy.prototype), 'constructor', this).call(this);

        this.type = 'InputProxy';
        this._interactions = {};
        this._wasPassed = false;
        this._subscriptions = new _cycleCore.Rx.CompositeDisposable();
    }

    _createClass(InputProxy, [{
        key: 'dispose',
        value: function dispose() {
            _get(Object.getPrototypeOf(InputProxy.prototype), 'dispose', this).call(this);

            this._subscriptions.dispose();
        }
    }, {
        key: 'get',

        // multistream like interactions
        value: function get(selector, eventName) {
            if (!this._interactions.hasOwnProperty(selector)) {
                this._interactions[selector] = {};
            }

            if (!this._interactions[selector].hasOwnProperty(eventName)) {
                this._interactions[selector][eventName] = new _cycleCore.Rx.Subject();
            }

            return this._interactions[selector][eventName];
        }
    }, {
        key: 'pass',
        value: function pass(source) {
            if (arguments.length > 1) {
                throw new Error('only one source can be passed');
            }

            if (this._wasPassed) {
                throw new Error('source already passed');
            }

            if ('undefined' === typeof source || source === null) {
                _throwThatNotObservable();
                // multistream (interactions object)
            } else if ('function' === typeof source.get) {
                var _iteratorNormalCompletion = true;
                var _didIteratorError = false;
                var _iteratorError = undefined;

                try {
                    for (var _iterator = Object.entries(this._interactions)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                        var _step$value = _slicedToArray(_step.value, 2);

                        var selector = _step$value[0];
                        var events = _step$value[1];
                        var _iteratorNormalCompletion2 = true;
                        var _didIteratorError2 = false;
                        var _iteratorError2 = undefined;

                        try {
                            for (var _iterator2 = Object.entries(events)[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                                var _step2$value = _slicedToArray(_step2.value, 2);

                                var eventName = _step2$value[0];
                                var proxyEvent$ = _step2$value[1];

                                var sourceEvent$ = source.get(selector, eventName);

                                if (sourceEvent$ && sourceEvent$.subscribe instanceof _cycleCore.Rx.Observable) {
                                    var subscription = sourceEvent$.subscribe(proxyEvent$.asObserver());

                                    this._subscriptions.add(subscription);
                                } else {
                                    _throwThatNotObservable();
                                }
                            }
                        } catch (err) {
                            _didIteratorError2 = true;
                            _iteratorError2 = err;
                        } finally {
                            try {
                                if (!_iteratorNormalCompletion2 && _iterator2['return']) {
                                    _iterator2['return']();
                                }
                            } finally {
                                if (_didIteratorError2) {
                                    throw _iteratorError2;
                                }
                            }
                        }
                    }
                    // single stream
                } catch (err) {
                    _didIteratorError = true;
                    _iteratorError = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion && _iterator['return']) {
                            _iterator['return']();
                        }
                    } finally {
                        if (_didIteratorError) {
                            throw _iteratorError;
                        }
                    }
                }
            } else if (source instanceof _cycleCore.Rx.Observable) {
                var subscription = source.subscribe(this.asObserver());

                this._subscriptions.add(subscription);
            } else {
                _throwThatNotObservable();
            }

            this._wasPassed = true;

            return this._subscriptions;
        }
    }, {
        key: 'wasPassed',
        get: function get() {
            return this._wasPassed;
        }
    }]);

    return InputProxy;
})(_cycleCore.Rx.Subject);

exports['default'] = InputProxy;
module.exports = exports['default'];