124 lines
5.3 KiB
JavaScript
124 lines
5.3 KiB
JavaScript
"use strict";
|
|
var root_1 = require('./util/root');
|
|
var SymbolShim_1 = require('./util/SymbolShim');
|
|
var toSubscriber_1 = require('./util/toSubscriber');
|
|
var tryCatch_1 = require('./util/tryCatch');
|
|
var errorObject_1 = require('./util/errorObject');
|
|
/**
|
|
* 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) {
|
|
this._isScalar = false;
|
|
if (subscribe) {
|
|
this._subscribe = subscribe;
|
|
}
|
|
}
|
|
/**
|
|
* @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 (operator) {
|
|
var observable = new Observable();
|
|
observable.source = this;
|
|
observable.operator = operator;
|
|
return observable;
|
|
};
|
|
/**
|
|
* @method subscribe
|
|
* @param {PartialObserver|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 (observerOrNext, error, complete) {
|
|
var operator = this.operator;
|
|
var subscriber = toSubscriber_1.toSubscriber(observerOrNext, error, complete);
|
|
if (operator) {
|
|
subscriber.add(this._subscribe(operator.call(subscriber)));
|
|
}
|
|
else {
|
|
subscriber.add(this._subscribe(subscriber));
|
|
}
|
|
if (subscriber.syncErrorThrowable) {
|
|
subscriber.syncErrorThrowable = false;
|
|
if (subscriber.syncErrorThrown) {
|
|
throw subscriber.syncErrorValue;
|
|
}
|
|
}
|
|
return subscriber;
|
|
};
|
|
/**
|
|
* @method forEach
|
|
* @param {Function} next a handler for each value emitted by the observable
|
|
* @param {any} [thisArg] a `this` context for the `next` handler function
|
|
* @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 (next, thisArg, PromiseCtor) {
|
|
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');
|
|
}
|
|
var source = this;
|
|
return new PromiseCtor(function (resolve, reject) {
|
|
source.subscribe(function (value) {
|
|
var result = tryCatch_1.tryCatch(next).call(thisArg, value);
|
|
if (result === errorObject_1.errorObject) {
|
|
reject(errorObject_1.errorObject.e);
|
|
}
|
|
}, reject, resolve);
|
|
});
|
|
};
|
|
Observable.prototype._subscribe = function (subscriber) {
|
|
return this.source.subscribe(subscriber);
|
|
};
|
|
/**
|
|
* @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[SymbolShim_1.SymbolShim.observable] = function () {
|
|
return this;
|
|
};
|
|
// 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
|
|
*/
|
|
Observable.create = function (subscribe) {
|
|
return new Observable(subscribe);
|
|
};
|
|
return Observable;
|
|
}());
|
|
exports.Observable = Observable;
|
|
//# sourceMappingURL=Observable.js.map
|