# Code coverage report for RxJS/dist/cjs/Observable.js

## Statements: 94.23% (49 / 52) Branches: 84% (21 / 25) Functions: 90.91% (10 / 11) Lines: 95.92% (47 / 49) Ignored: none

All files » RxJS/dist/cjs/ » Observable.js

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144

    1

    2

    2835

    1

    1

    1

    1

    1

    1

    1
    2835

    2835
    2835
    360

    1
    449
    449
    449
    449

    1

    1
    1670
    1670
    736
    703

    33

    934
    934

    1670
    1664

    1
    3

    3
    2
    1
    1
    1

    3

    3
    3

    1
    463

    1

    1
    1
    9

    1'use strict';

    exports.__esModule = true;

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

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

    var _Subscriber = require('./Subscriber');

    var _Subscriber2 = _interopRequireDefault(_Subscriber);

    var _utilRoot = require('./util/root');

    var _utilSymbol_observable = require('./util/Symbol_observable');

    var _utilSymbol_observable2 = _interopRequireDefault(_utilSymbol_observable);

    /**
     * A representation of any set of values over any amount of time. This the most basic building block
     * of RxJS.
     *
     * @class Observable<T>
     */

    var Observable = (function () {
        /**
         * @constructor
         * @param {Function} subscribe the function that is
         * called when the Observable is initially subscribed to. This function is given a Subscriber, to which new values
         * can be `next`ed, or an `error` method can be called to raise an error, or `complete` can be called to notify
         * of a successful completion.
         */

        function Observable(subscribe) {
            _classCallCheck(this, Observable);

            this._isScalar = false;
            if (subscribe) {
                this._subscribe = subscribe;
            }
        }

        // HACK: Since TypeScript inherits static properties too, we have to
        // fight against TypeScript here so Subject can have a different static create signature
        /**
         * @static
         * @method create
         * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
         * @returns {Observable} a new cold observable
         * @description creates a new cold Observable by calling the Observable constructor
         */

        /**
         * @method lift
         * @param {Operator} operator the operator defining the operation to take on the observable
         * @returns {Observable} a new observable with the Operator applied
         * @description creates a new Observable, with this Observable as the source, and the passed
         * operator defined as the new observable's operator.
         */

        Observable.prototype.lift = function lift(operator) {
            var observable = new Observable();
            observable.source = this;
            observable.operator = operator;
            return observable;
        };

        /**
         * @method Symbol.observable
         * @returns {Observable} this instance of the observable
         * @description an interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
         */

        Observable.prototype[_utilSymbol_observable2['default']] = function () {
            return this;
        };

        /**
         * @method subscribe
         * @param {Observer|Function} observerOrNext (optional) either an observer defining all functions to be called,
         *  or the first of three possible handlers, which is the handler for each value emitted from the observable.
         * @param {Function} error (optional) a handler for a terminal event resulting from an error. If no error handler is provided,
         *  the error will be thrown as unhandled
         * @param {Function} complete (optional) a handler for a terminal event resulting from successful completion.
         * @returns {Subscription} a subscription reference to the registered handlers
         * @description registers handlers for handling emitted values, error and completions from the observable, and
         *  executes the observable's subscriber function, which will take action to set up the underlying data stream
         */

        Observable.prototype.subscribe = function subscribe(observerOrNext, error, complete) {
            var subscriber = undefined;
            if (observerOrNext && typeof observerOrNext === "object") {
                if (observerOrNext instanceof _Subscriber2['default']) {
                    subscriber = observerOrNext;
                } else {
                    subscriber = new _Subscriber2['default'](observerOrNext);
                }
            } else {
                var next = observerOrNext;
                subscriber = _Subscriber2['default'].create(next, error, complete);
            }
            subscriber.add(this._subscribe(subscriber));
            return subscriber;
        };

        /**
         * @method forEach
         * @param {Function} next a handler for each value emitted by the observable
         * @param {PromiseConstructor} PromiseCtor? a constructor function used to instantiate the Promise
         * @returns {Promise} a promise that either resolves on observable completion or
         *  rejects with the handled error
         */

        Observable.prototype.forEach = function forEach(next, PromiseCtor) {
            var _this = this;

            if (!PromiseCtor) {
                if (_utilRoot.root.Rx && _utilRoot.root.Rx.config && _utilRoot.root.Rx.config.Promise) {
                    PromiseCtor = _utilRoot.root.Rx.config.Promise;
                } else Eif (_utilRoot.root.Promise) {
                    PromiseCtor = _utilRoot.root.Promise;
                }
            }
            Iif (!PromiseCtor) {
                throw new Error('no Promise impl found');
            }
            return new PromiseCtor(function (resolve, reject) {
                _this.subscribe(next, reject, resolve);
            });
        };

        Observable.prototype._subscribe = function _subscribe(subscriber) {
            return this.source._subscribe(this.operator.call(subscriber));
        };

        return Observable;
    })();

    exports['default'] = Observable;
    Observable.create = function (subscribe) {
        return new Observable(subscribe);
    };
    module.exports = exports['default'];