Gecko [ unitednationsplay.com ]

Name	Size	Permission	Date
_esm2015	[ DIR ]	drwxrwxr-x	2022-08-30 11:49
_esm5	[ DIR ]	drwxrwxr-x	2022-08-30 11:49
add	[ DIR ]	drwxrwxr-x	2022-08-30 11:49
bundles	[ DIR ]	drwxrwxr-x	2022-08-30 11:49
observable	[ DIR ]	drwxrwxr-x	2022-08-30 11:49
operator	[ DIR ]	drwxrwxr-x	2022-08-30 11:49
operators	[ DIR ]	drwxrwxr-x	2022-08-30 11:49
scheduler	[ DIR ]	drwxrwxr-x	2022-08-30 11:49
src	[ DIR ]	drwxrwxr-x	2022-08-30 11:49
symbol	[ DIR ]	drwxrwxr-x	2022-08-30 11:49
testing	[ DIR ]	drwxrwxr-x	2022-08-30 11:49
util	[ DIR ]	drwxrwxr-x	2022-08-30 11:49
AsyncSubject.d.ts	460 B	-rw-rw-r--	2022-08-30 11:49
AsyncSubject.js	1.79 KB	-rw-rw-r--	2022-08-30 11:49
AsyncSubject.js.map	2.45 KB	-rw-rw-r--	2022-08-30 11:49
BehaviorSubject.d.ts	437 B	-rw-rw-r--	2022-08-30 11:49
BehaviorSubject.js	1.66 KB	-rw-rw-r--	2022-08-30 11:49
BehaviorSubject.js.map	2.06 KB	-rw-rw-r--	2022-08-30 11:49
InnerSubscriber.d.ts	537 B	-rw-rw-r--	2022-08-30 11:49
InnerSubscriber.js	1.26 KB	-rw-rw-r--	2022-08-30 11:49
InnerSubscriber.js.map	1.58 KB	-rw-rw-r--	2022-08-30 11:49
LICENSE.txt	10.8 KB	-rw-rw-r--	2022-08-30 11:49
Notification.d.ts	3.07 KB	-rw-rw-r--	2022-08-30 11:49
Notification.js	4.65 KB	-rw-rw-r--	2022-08-30 11:49
Notification.js.map	6.81 KB	-rw-rw-r--	2022-08-30 11:49
Observable.d.ts	5 KB	-rw-rw-r--	2022-08-30 11:49
Observable.js	12.89 KB	-rw-rw-r--	2022-08-30 11:49
Observable.js.map	19.46 KB	-rw-rw-r--	2022-08-30 11:49
Observer.d.ts	737 B	-rw-rw-r--	2022-08-30 11:49
Observer.js	193 B	-rw-rw-r--	2022-08-30 11:49
Observer.js.map	1.12 KB	-rw-rw-r--	2022-08-30 11:49
Operator.d.ts	192 B	-rw-rw-r--	2022-08-30 11:49
Operator.js	50 B	-rw-rw-r--	2022-08-30 11:49
Operator.js.map	327 B	-rw-rw-r--	2022-08-30 11:49
OuterSubscriber.d.ts	509 B	-rw-rw-r--	2022-08-30 11:49
OuterSubscriber.js	1.08 KB	-rw-rw-r--	2022-08-30 11:49
OuterSubscriber.js.map	1.25 KB	-rw-rw-r--	2022-08-30 11:49
README.md	7.27 KB	-rw-rw-r--	2022-08-30 11:49
ReplaySubject.d.ts	625 B	-rw-rw-r--	2022-08-30 11:49
ReplaySubject.js	3.81 KB	-rw-rw-r--	2022-08-30 11:49
ReplaySubject.js.map	6.16 KB	-rw-rw-r--	2022-08-30 11:49
Rx.d.ts	7.59 KB	-rw-rw-r--	2022-08-30 11:49
Rx.js	9.56 KB	-rw-rw-r--	2022-08-30 11:49
Rx.js.map	13.4 KB	-rw-rw-r--	2022-08-30 11:49
Scheduler.d.ts	2.18 KB	-rw-rw-r--	2022-08-30 11:49
Scheduler.js	1.84 KB	-rw-rw-r--	2022-08-30 11:49
Scheduler.js.map	3.01 KB	-rw-rw-r--	2022-08-30 11:49
Subject.d.ts	1.41 KB	-rw-rw-r--	2022-08-30 11:49
Subject.js	5.55 KB	-rw-rw-r--	2022-08-30 11:49
Subject.js.map	8.67 KB	-rw-rw-r--	2022-08-30 11:49
SubjectSubscription.d.ts	447 B	-rw-rw-r--	2022-08-30 11:49
SubjectSubscription.js	1.37 KB	-rw-rw-r--	2022-08-30 11:49
SubjectSubscription.js.map	1.85 KB	-rw-rw-r--	2022-08-30 11:49
Subscriber.d.ts	2.97 KB	-rw-rw-r--	2022-08-30 11:49
Subscriber.js	10.02 KB	-rw-rw-r--	2022-08-30 11:49
Subscriber.js.map	15.51 KB	-rw-rw-r--	2022-08-30 11:49
Subscription.d.ts	2.74 KB	-rw-rw-r--	2022-08-30 11:49
Subscription.js	7.99 KB	-rw-rw-r--	2022-08-30 11:49
Subscription.js.map	12.17 KB	-rw-rw-r--	2022-08-30 11:49
interfaces.d.ts	322 B	-rw-rw-r--	2022-08-30 11:49
interfaces.js	52 B	-rw-rw-r--	2022-08-30 11:49
interfaces.js.map	437 B	-rw-rw-r--	2022-08-30 11:49
operators.d.ts	5.21 KB	-rw-rw-r--	2022-08-30 11:49
operators.js	9.52 KB	-rw-rw-r--	2022-08-30 11:49
operators.js.map	9.28 KB	-rw-rw-r--	2022-08-30 11:49
package.json	5.16 KB	-rw-rw-r--	2022-08-30 11:49

Rename

"use strict";
var root_1 = require('./util/root');
var toSubscriber_1 = require('./util/toSubscriber');
var observable_1 = require('./symbol/observable');
var pipe_1 = require('./util/pipe');
/**
 * A representation of any set of values over any amount of time. This is 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) {
        this._isScalar = false;
        if (subscribe) {
            this._subscribe = subscribe;
        }
    }
    /**
     * Creates a new Observable, with this Observable as the source, and the passed
     * operator defined as the new observable's operator.
     * @method lift
     * @param {Operator} operator the operator defining the operation to take on the observable
     * @return {Observable} a new observable with the Operator applied
     */
    Observable.prototype.lift = function (operator) {
        var observable = new Observable();
        observable.source = this;
        observable.operator = operator;
        return observable;
    };
    /**
     * Invokes an execution of an Observable and registers Observer handlers for notifications it will emit.
     *
     * <span class="informal">Use it when you have all these Observables, but still nothing is happening.</span>
     *
     * `subscribe` is not a regular operator, but a method that calls Observable's internal `subscribe` function. It
     * might be for example a function that you passed to a {@link create} static factory, but most of the time it is
     * a library implementation, which defines what and when will be emitted by an Observable. This means that calling
     * `subscribe` is actually the moment when Observable starts its work, not when it is created, as it is often
     * thought.
     *
     * Apart from starting the execution of an Observable, this method allows you to listen for values
     * that an Observable emits, as well as for when it completes or errors. You can achieve this in two
     * following ways.
     *
     * The first way is creating an object that implements {@link Observer} interface. It should have methods
     * defined by that interface, but note that it should be just a regular JavaScript object, which you can create
     * yourself in any way you want (ES6 class, classic function constructor, object literal etc.). In particular do
     * not attempt to use any RxJS implementation details to create Observers - you don't need them. Remember also
     * that your object does not have to implement all methods. If you find yourself creating a method that doesn't
     * do anything, you can simply omit it. Note however, that if `error` method is not provided, all errors will
     * be left uncaught.
     *
     * The second way is to give up on Observer object altogether and simply provide callback functions in place of its methods.
     * This means you can provide three functions as arguments to `subscribe`, where first function is equivalent
     * of a `next` method, second of an `error` method and third of a `complete` method. Just as in case of Observer,
     * if you do not need to listen for something, you can omit a function, preferably by passing `undefined` or `null`,
     * since `subscribe` recognizes these functions by where they were placed in function call. When it comes
     * to `error` function, just as before, if not provided, errors emitted by an Observable will be thrown.
     *
     * Whatever style of calling `subscribe` you use, in both cases it returns a Subscription object.
     * This object allows you to call `unsubscribe` on it, which in turn will stop work that an Observable does and will clean
     * up all resources that an Observable used. Note that cancelling a subscription will not call `complete` callback
     * provided to `subscribe` function, which is reserved for a regular completion signal that comes from an Observable.
     *
     * Remember that callbacks provided to `subscribe` are not guaranteed to be called asynchronously.
     * It is an Observable itself that decides when these functions will be called. For example {@link of}
     * by default emits all its values synchronously. Always check documentation for how given Observable
     * will behave when subscribed and if its default behavior can be modified with a {@link Scheduler}.
     *
     * @example <caption>Subscribe with an Observer</caption>
     * const sumObserver = {
     *   sum: 0,
     *   next(value) {
     *     console.log('Adding: ' + value);
     *     this.sum = this.sum + value;
     *   },
     *   error() { // We actually could just remove this method,
     *   },        // since we do not really care about errors right now.
     *   complete() {
     *     console.log('Sum equals: ' + this.sum);
     *   }
     * };
     *
     * Rx.Observable.of(1, 2, 3) // Synchronously emits 1, 2, 3 and then completes.
     * .subscribe(sumObserver);
     *
     * // Logs:
     * // "Adding: 1"
     * // "Adding: 2"
     * // "Adding: 3"
     * // "Sum equals: 6"
     *
     *
     * @example <caption>Subscribe with functions</caption>
     * let sum = 0;
     *
     * Rx.Observable.of(1, 2, 3)
     * .subscribe(
     *   function(value) {
     *     console.log('Adding: ' + value);
     *     sum = sum + value;
     *   },
     *   undefined,
     *   function() {
     *     console.log('Sum equals: ' + sum);
     *   }
     * );
     *
     * // Logs:
     * // "Adding: 1"
     * // "Adding: 2"
     * // "Adding: 3"
     * // "Sum equals: 6"
     *
     *
     * @example <caption>Cancel a subscription</caption>
     * const subscription = Rx.Observable.interval(1000).subscribe(
     *   num => console.log(num),
     *   undefined,
     *   () => console.log('completed!') // Will not be called, even
     * );                                // when cancelling subscription
     *
     *
     * setTimeout(() => {
     *   subscription.unsubscribe();
     *   console.log('unsubscribed!');
     * }, 2500);
     *
     * // Logs:
     * // 0 after 1s
     * // 1 after 2s
     * // "unsubscribed!" after 2.5s
     *
     *
     * @param {Observer|Function} observerOrNext (optional) Either an observer with methods to be called,
     *  or the first of three possible handlers, which is the handler for each value emitted from the subscribed
     *  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.
     * @return {ISubscription} a subscription reference to the registered handlers
     * @method subscribe
     */
    Observable.prototype.subscribe = function (observerOrNext, error, complete) {
        var operator = this.operator;
        var sink = toSubscriber_1.toSubscriber(observerOrNext, error, complete);
        if (operator) {
            operator.call(sink, this.source);
        }
        else {
            sink.add(this.source || !sink.syncErrorThrowable ? this._subscribe(sink) : this._trySubscribe(sink));
        }
        if (sink.syncErrorThrowable) {
            sink.syncErrorThrowable = false;
            if (sink.syncErrorThrown) {
                throw sink.syncErrorValue;
            }
        }
        return sink;
    };
    Observable.prototype._trySubscribe = function (sink) {
        try {
            return this._subscribe(sink);
        }
        catch (err) {
            sink.syncErrorThrown = true;
            sink.syncErrorValue = err;
            sink.error(err);
        }
    };
    /**
     * @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
     * @return {Promise} a promise that either resolves on observable completion or
     *  rejects with the handled error
     */
    Observable.prototype.forEach = function (next, PromiseCtor) {
        var _this = this;
        if (!PromiseCtor) {
            if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {
                PromiseCtor = root_1.root.Rx.config.Promise;
            }
            else if (root_1.root.Promise) {
                PromiseCtor = root_1.root.Promise;
            }
        }
        if (!PromiseCtor) {
            throw new Error('no Promise impl found');
        }
        return new PromiseCtor(function (resolve, reject) {
            // Must be declared in a separate statement to avoid a RefernceError when
            // accessing subscription below in the closure due to Temporal Dead Zone.
            var subscription;
            subscription = _this.subscribe(function (value) {
                if (subscription) {
                    // if there is a subscription, then we can surmise
                    // the next handling is asynchronous. Any errors thrown
                    // need to be rejected explicitly and unsubscribe must be
                    // called manually
                    try {
                        next(value);
                    }
                    catch (err) {
                        reject(err);
                        subscription.unsubscribe();
                    }
                }
                else {
                    // if there is NO subscription, then we're getting a nexted
                    // value synchronously during subscription. We can just call it.
                    // If it errors, Observable's `subscribe` will ensure the
                    // unsubscription logic is called, then synchronously rethrow the error.
                    // After that, Promise will trap the error and send it
                    // down the rejection path.
                    next(value);
                }
            }, reject, resolve);
        });
    };
    /** @deprecated internal use only */ Observable.prototype._subscribe = function (subscriber) {
        return this.source.subscribe(subscriber);
    };
    /**
     * An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
     * @method Symbol.observable
     * @return {Observable} this instance of the observable
     */
    Observable.prototype[observable_1.observable] = function () {
        return this;
    };
    /* tslint:enable:max-line-length */
    /**
     * Used to stitch together functional operators into a chain.
     * @method pipe
     * @return {Observable} the Observable result of all of the operators having
     * been called in the order they were passed in.
     *
     * @example
     *
     * import { map, filter, scan } from 'rxjs/operators';
     *
     * Rx.Observable.interval(1000)
     *   .pipe(
     *     filter(x => x % 2 === 0),
     *     map(x => x + x),
     *     scan((acc, x) => acc + x)
     *   )
     *   .subscribe(x => console.log(x))
     */
    Observable.prototype.pipe = function () {
        var operations = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            operations[_i - 0] = arguments[_i];
        }
        if (operations.length === 0) {
            return this;
        }
        return pipe_1.pipeFromArray(operations)(this);
    };
    /* tslint:enable:max-line-length */
    Observable.prototype.toPromise = function (PromiseCtor) {
        var _this = this;
        if (!PromiseCtor) {
            if (root_1.root.Rx && root_1.root.Rx.config && root_1.root.Rx.config.Promise) {
                PromiseCtor = root_1.root.Rx.config.Promise;
            }
            else if (root_1.root.Promise) {
                PromiseCtor = root_1.root.Promise;
            }
        }
        if (!PromiseCtor) {
            throw new Error('no Promise impl found');
        }
        return new PromiseCtor(function (resolve, reject) {
            var value;
            _this.subscribe(function (x) { return value = x; }, function (err) { return reject(err); }, function () { return resolve(value); });
        });
    };
    // HACK: Since TypeScript inherits static properties too, we have to
    // fight against TypeScript here so Subject can have a different static create signature
    /**
     * Creates a new cold Observable by calling the Observable constructor
     * @static true
     * @owner Observable
     * @method create
     * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
     * @return {Observable} a new cold observable
     */
    Observable.create = function (subscribe) {
        return new Observable(subscribe);
    };
    return Observable;
}());
exports.Observable = Observable;
//# sourceMappingURL=Observable.js.map