hugoWebsite/node_modules/rxjs/dist/esm/internal/Subscriber.js

174 lines
5.0 KiB
JavaScript
Raw Normal View History

2022-10-29 00:20:35 +02:00
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';
export class Subscriber extends Subscription {
constructor(destination) {
super();
this.isStopped = false;
if (destination) {
this.destination = destination;
if (isSubscription(destination)) {
destination.add(this);
}
}
else {
this.destination = EMPTY_OBSERVER;
}
}
static create(next, error, complete) {
return new SafeSubscriber(next, error, complete);
}
next(value) {
if (this.isStopped) {
handleStoppedNotification(nextNotification(value), this);
}
else {
this._next(value);
}
}
error(err) {
if (this.isStopped) {
handleStoppedNotification(errorNotification(err), this);
}
else {
this.isStopped = true;
this._error(err);
}
}
complete() {
if (this.isStopped) {
handleStoppedNotification(COMPLETE_NOTIFICATION, this);
}
else {
this.isStopped = true;
this._complete();
}
}
unsubscribe() {
if (!this.closed) {
this.isStopped = true;
super.unsubscribe();
this.destination = null;
}
}
_next(value) {
this.destination.next(value);
}
_error(err) {
try {
this.destination.error(err);
}
finally {
this.unsubscribe();
}
}
_complete() {
try {
this.destination.complete();
}
finally {
this.unsubscribe();
}
}
}
const _bind = Function.prototype.bind;
function bind(fn, thisArg) {
return _bind.call(fn, thisArg);
}
class ConsumerObserver {
constructor(partialObserver) {
this.partialObserver = partialObserver;
}
next(value) {
const { partialObserver } = this;
if (partialObserver.next) {
try {
partialObserver.next(value);
}
catch (error) {
handleUnhandledError(error);
}
}
}
error(err) {
const { partialObserver } = this;
if (partialObserver.error) {
try {
partialObserver.error(err);
}
catch (error) {
handleUnhandledError(error);
}
}
else {
handleUnhandledError(err);
}
}
complete() {
const { partialObserver } = this;
if (partialObserver.complete) {
try {
partialObserver.complete();
}
catch (error) {
handleUnhandledError(error);
}
}
}
}
export class SafeSubscriber extends Subscriber {
constructor(observerOrNext, error, complete) {
super();
let 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 {
let context;
if (this && config.useDeprecatedNextContext) {
context = Object.create(observerOrNext);
context.unsubscribe = () => this.unsubscribe();
partialObserver = {
next: observerOrNext.next && bind(observerOrNext.next, context),
error: observerOrNext.error && bind(observerOrNext.error, context),
complete: observerOrNext.complete && bind(observerOrNext.complete, context),
};
}
else {
partialObserver = observerOrNext;
}
}
this.destination = new ConsumerObserver(partialObserver);
}
}
function handleUnhandledError(error) {
if (config.useDeprecatedSynchronousErrorHandling) {
captureError(error);
}
else {
reportUnhandledError(error);
}
}
function defaultErrorHandler(err) {
throw err;
}
function handleStoppedNotification(notification, subscriber) {
const { onStoppedNotification } = config;
onStoppedNotification && timeoutProvider.setTimeout(() => onStoppedNotification(notification, subscriber));
}
export const EMPTY_OBSERVER = {
closed: true,
next: noop,
error: defaultErrorHandler,
complete: noop,
};
//# sourceMappingURL=Subscriber.js.map