import { SafeSubscriber, Subscriber } from './Subscriber'; import { isSubscription } from './Subscription'; import { observable as Symbol_observable } from './symbol/observable'; import { pipeFromArray } from './util/pipe'; import { config } from './config'; import { isFunction } from './util/isFunction'; var Observable = (function () { function Observable(subscribe) { if (subscribe) { this._subscribe = subscribe; } } Observable.prototype.lift = function (operator) { var observable = new Observable(); observable.source = this; observable.operator = operator; return observable; }; Observable.prototype.subscribe = function (observerOrNext, error, complete) { var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete); if (config.useDeprecatedSynchronousErrorHandling) { this._deprecatedSyncErrorSubscribe(subscriber); } else { var _a = this, operator = _a.operator, source = _a.source; subscriber.add(operator ? operator.call(subscriber, source) : source ? this._subscribe(subscriber) : this._trySubscribe(subscriber)); } return subscriber; }; Observable.prototype._deprecatedSyncErrorSubscribe = function (subscriber) { var localSubscriber = subscriber; localSubscriber._syncErrorHack_isSubscribing = true; var operator = this.operator; if (operator) { subscriber.add(operator.call(subscriber, this.source)); } else { try { this._subscribe(subscriber); } catch (err) { localSubscriber.__syncError = err; } } var dest = localSubscriber; while (dest) { if ('__syncError' in dest) { try { throw dest.__syncError; } finally { subscriber.unsubscribe(); } } dest = dest.destination; } localSubscriber._syncErrorHack_isSubscribing = false; }; Observable.prototype._trySubscribe = function (sink) { try { return this._subscribe(sink); } catch (err) { sink.error(err); } }; Observable.prototype.forEach = function (next, promiseCtor) { var _this = this; promiseCtor = getPromiseCtor(promiseCtor); return new promiseCtor(function (resolve, reject) { var subscription; subscription = _this.subscribe(function (value) { try { next(value); } catch (err) { reject(err); subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe(); } }, reject, resolve); }); }; Observable.prototype._subscribe = function (subscriber) { var _a; return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber); }; Observable.prototype[Symbol_observable] = function () { return this; }; Observable.prototype.pipe = function () { var operations = []; for (var _i = 0; _i < arguments.length; _i++) { operations[_i] = arguments[_i]; } return operations.length ? pipeFromArray(operations)(this) : this; }; Observable.prototype.toPromise = function (promiseCtor) { var _this = this; promiseCtor = getPromiseCtor(promiseCtor); return new promiseCtor(function (resolve, reject) { var value; _this.subscribe(function (x) { return (value = x); }, function (err) { return reject(err); }, function () { return resolve(value); }); }); }; Observable.create = function (subscribe) { return new Observable(subscribe); }; return Observable; }()); export { Observable }; function getPromiseCtor(promiseCtor) { var _a; return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise; } function isObserver(value) { return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete); } function isSubscriber(value) { return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value)); } //# sourceMappingURL=Observable.js.map