Initial commit

node/TestCli/node_modules/rxjs/dist/esm/internal/Subscriber.js

@@ -0,0 +1,135 @@
+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();
+        }
+    }
+}
+export class SafeSubscriber extends Subscriber {
+    constructor(observerOrNext, error, complete) {
+        super();
+        let next;
+        if (isFunction(observerOrNext)) {
+            next = observerOrNext;
+        }
+        else if (observerOrNext) {
+            ({ next, error, complete } = observerOrNext);
+            let context;
+            if (this && config.useDeprecatedNextContext) {
+                context = Object.create(observerOrNext);
+                context.unsubscribe = () => this.unsubscribe();
+            }
+            else {
+                context = observerOrNext;
+            }
+            next = next === null || next === void 0 ? void 0 : next.bind(context);
+            error = error === null || error === void 0 ? void 0 : error.bind(context);
+            complete = complete === null || complete === void 0 ? void 0 : complete.bind(context);
+        }
+        this.destination = {
+            next: next ? wrapForErrorHandling(next, this) : noop,
+            error: wrapForErrorHandling(error !== null && error !== void 0 ? error : defaultErrorHandler, this),
+            complete: complete ? wrapForErrorHandling(complete, this) : noop,
+        };
+    }
+}
+function wrapForErrorHandling(handler, instance) {
+    return (...args) => {
+        try {
+            handler(...args);
+        }
+        catch (err) {
+            if (config.useDeprecatedSynchronousErrorHandling) {
+                captureError(err);
+            }
+            else {
+                reportUnhandledError(err);
+            }
+        }
+    };
+}
+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