Actualizacion maquina principal

[dotfiles/.git] / .config / coc / extensions / node_modules / coc-prettier / node_modules / rxjs / _esm2015 / internal / observable / bindNodeCallback.js

diff --git a/.config/coc/extensions/node_modules/coc-prettier/node_modules/rxjs/_esm2015/internal/observable/bindNodeCallback.js b/.config/coc/extensions/node_modules/coc-prettier/node_modules/rxjs/_esm2015/internal/observable/bindNodeCallback.js
new file mode 100644 (file)
index 0000000..81ca5a6
--- /dev/null
+++ b/.config/coc/extensions/node_modules/coc-prettier/node_modules/rxjs/_esm2015/internal/observable/bindNodeCallback.js
@@ -0,0 +1,93 @@
+import { Observable } from '../Observable';
+import { AsyncSubject } from '../AsyncSubject';
+import { map } from '../operators/map';
+import { canReportError } from '../util/canReportError';
+import { isScheduler } from '../util/isScheduler';
+import { isArray } from '../util/isArray';
+export function bindNodeCallback(callbackFunc, resultSelector, scheduler) {
+    if (resultSelector) {
+        if (isScheduler(resultSelector)) {
+            scheduler = resultSelector;
+        }
+        else {
+            return (...args) => bindNodeCallback(callbackFunc, scheduler)(...args).pipe(map(args => isArray(args) ? resultSelector(...args) : resultSelector(args)));
+        }
+    }
+    return function (...args) {
+        const params = {
+            subject: undefined,
+            args,
+            callbackFunc,
+            scheduler,
+            context: this,
+        };
+        return new Observable(subscriber => {
+            const { context } = params;
+            let { subject } = params;
+            if (!scheduler) {
+                if (!subject) {
+                    subject = params.subject = new AsyncSubject();
+                    const handler = (...innerArgs) => {
+                        const err = innerArgs.shift();
+                        if (err) {
+                            subject.error(err);
+                            return;
+                        }
+                        subject.next(innerArgs.length <= 1 ? innerArgs[0] : innerArgs);
+                        subject.complete();
+                    };
+                    try {
+                        callbackFunc.apply(context, [...args, handler]);
+                    }
+                    catch (err) {
+                        if (canReportError(subject)) {
+                            subject.error(err);
+                        }
+                        else {
+                            console.warn(err);
+                        }
+                    }
+                }
+                return subject.subscribe(subscriber);
+            }
+            else {
+                return scheduler.schedule(dispatch, 0, { params, subscriber, context });
+            }
+        });
+    };
+}
+function dispatch(state) {
+    const { params, subscriber, context } = state;
+    const { callbackFunc, args, scheduler } = params;
+    let subject = params.subject;
+    if (!subject) {
+        subject = params.subject = new AsyncSubject();
+        const handler = (...innerArgs) => {
+            const err = innerArgs.shift();
+            if (err) {
+                this.add(scheduler.schedule(dispatchError, 0, { err, subject }));
+            }
+            else {
+                const value = innerArgs.length <= 1 ? innerArgs[0] : innerArgs;
+                this.add(scheduler.schedule(dispatchNext, 0, { value, subject }));
+            }
+        };
+        try {
+            callbackFunc.apply(context, [...args, handler]);
+        }
+        catch (err) {
+            this.add(scheduler.schedule(dispatchError, 0, { err, subject }));
+        }
+    }
+    this.add(subject.subscribe(subscriber));
+}
+function dispatchNext(arg) {
+    const { value, subject } = arg;
+    subject.next(value);
+    subject.complete();
+}
+function dispatchError(arg) {
+    const { err, subject } = arg;
+    subject.error(err);
+}
+//# sourceMappingURL=bindNodeCallback.js.map
\ No newline at end of file