Buckets:
| import { __extends } from "tslib"; | |
| import { isFunction } from './util/isFunction'; | |
| import { isSubscription, Subscription } from './Subscription'; | |
| import { config } from './config'; | |
| import { reportUnhandledError } from './util/reportUnhandledError'; | |
| import { noop } from './util/noop'; | |
| import { nextNotification, errorNotification, COMPLETE_NOTIFICATION } from './NotificationFactories'; | |
| import { timeoutProvider } from './scheduler/timeoutProvider'; | |
| import { captureError } from './util/errorContext'; | |
| var Subscriber = (function (_super) { | |
| __extends(Subscriber, _super); | |
| function Subscriber(destination) { | |
| var _this = _super.call(this) || this; | |
| _this.isStopped = false; | |
| if (destination) { | |
| _this.destination = destination; | |
| if (isSubscription(destination)) { | |
| destination.add(_this); | |
| } | |
| } | |
| else { | |
| _this.destination = EMPTY_OBSERVER; | |
| } | |
| return _this; | |
| } | |
| Subscriber.create = function (next, error, complete) { | |
| return new SafeSubscriber(next, error, complete); | |
| }; | |
| Subscriber.prototype.next = function (value) { | |
| if (this.isStopped) { | |
| handleStoppedNotification(nextNotification(value), this); | |
| } | |
| else { | |
| this._next(value); | |
| } | |
| }; | |
| Subscriber.prototype.error = function (err) { | |
| if (this.isStopped) { | |
| handleStoppedNotification(errorNotification(err), this); | |
| } | |
| else { | |
| this.isStopped = true; | |
| this._error(err); | |
| } | |
| }; | |
| Subscriber.prototype.complete = function () { | |
| if (this.isStopped) { | |
| handleStoppedNotification(COMPLETE_NOTIFICATION, this); | |
| } | |
| else { | |
| this.isStopped = true; | |
| this._complete(); | |
| } | |
| }; | |
| Subscriber.prototype.unsubscribe = function () { | |
| if (!this.closed) { | |
| this.isStopped = true; | |
| _super.prototype.unsubscribe.call(this); | |
| this.destination = null; | |
| } | |
| }; | |
| Subscriber.prototype._next = function (value) { | |
| this.destination.next(value); | |
| }; | |
| Subscriber.prototype._error = function (err) { | |
| try { | |
| this.destination.error(err); | |
| } | |
| finally { | |
| this.unsubscribe(); | |
| } | |
| }; | |
| Subscriber.prototype._complete = function () { | |
| try { | |
| this.destination.complete(); | |
| } | |
| finally { | |
| this.unsubscribe(); | |
| } | |
| }; | |
| return Subscriber; | |
| }(Subscription)); | |
| export { Subscriber }; | |
| var _bind = Function.prototype.bind; | |
| function bind(fn, thisArg) { | |
| return _bind.call(fn, thisArg); | |
| } | |
| var ConsumerObserver = (function () { | |
| function ConsumerObserver(partialObserver) { | |
| this.partialObserver = partialObserver; | |
| } | |
| ConsumerObserver.prototype.next = function (value) { | |
| var partialObserver = this.partialObserver; | |
| if (partialObserver.next) { | |
| try { | |
| partialObserver.next(value); | |
| } | |
| catch (error) { | |
| handleUnhandledError(error); | |
| } | |
| } | |
| }; | |
| ConsumerObserver.prototype.error = function (err) { | |
| var partialObserver = this.partialObserver; | |
| if (partialObserver.error) { | |
| try { | |
| partialObserver.error(err); | |
| } | |
| catch (error) { | |
| handleUnhandledError(error); | |
| } | |
| } | |
| else { | |
| handleUnhandledError(err); | |
| } | |
| }; | |
| ConsumerObserver.prototype.complete = function () { | |
| var partialObserver = this.partialObserver; | |
| if (partialObserver.complete) { | |
| try { | |
| partialObserver.complete(); | |
| } | |
| catch (error) { | |
| handleUnhandledError(error); | |
| } | |
| } | |
| }; | |
| return ConsumerObserver; | |
| }()); | |
| var SafeSubscriber = (function (_super) { | |
| __extends(SafeSubscriber, _super); | |
| function SafeSubscriber(observerOrNext, error, complete) { | |
| var _this = _super.call(this) || this; | |
| var partialObserver; | |
| if (isFunction(observerOrNext) || !observerOrNext) { | |
| partialObserver = { | |
| next: (observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined), | |
| error: error !== null && error !== void 0 ? error : undefined, | |
| complete: complete !== null && complete !== void 0 ? complete : undefined, | |
| }; | |
| } | |
| else { | |
| var context_1; | |
| if (_this && config.useDeprecatedNextContext) { | |
| context_1 = Object.create(observerOrNext); | |
| context_1.unsubscribe = function () { return _this.unsubscribe(); }; | |
| partialObserver = { | |
| next: observerOrNext.next && bind(observerOrNext.next, context_1), | |
| error: observerOrNext.error && bind(observerOrNext.error, context_1), | |
| complete: observerOrNext.complete && bind(observerOrNext.complete, context_1), | |
| }; | |
| } | |
| else { | |
| partialObserver = observerOrNext; | |
| } | |
| } | |
| _this.destination = new ConsumerObserver(partialObserver); | |
| return _this; | |
| } | |
| return SafeSubscriber; | |
| }(Subscriber)); | |
| export { SafeSubscriber }; | |
| function handleUnhandledError(error) { | |
| if (config.useDeprecatedSynchronousErrorHandling) { | |
| captureError(error); | |
| } | |
| else { | |
| reportUnhandledError(error); | |
| } | |
| } | |
| function defaultErrorHandler(err) { | |
| throw err; | |
| } | |
| function handleStoppedNotification(notification, subscriber) { | |
| var onStoppedNotification = config.onStoppedNotification; | |
| onStoppedNotification && timeoutProvider.setTimeout(function () { return onStoppedNotification(notification, subscriber); }); | |
| } | |
| export var EMPTY_OBSERVER = { | |
| closed: true, | |
| next: noop, | |
| error: defaultErrorHandler, | |
| complete: noop, | |
| }; | |
| //# sourceMappingURL=Subscriber.js.map |
Xet Storage Details
- Size:
- 6.03 kB
- Xet hash:
- e9872c468174909c5f4ab530d37061f747e815d907392e754ad491b74af07641
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.