Actualizacion maquina principal

[dotfiles/.git] / .config / coc / extensions / node_modules / coc-prettier / node_modules / rxjs / src / internal / observable / onErrorResumeNext.ts

diff --git a/.config/coc/extensions/node_modules/coc-prettier/node_modules/rxjs/src/internal/observable/onErrorResumeNext.ts b/.config/coc/extensions/node_modules/coc-prettier/node_modules/rxjs/src/internal/observable/onErrorResumeNext.ts
new file mode 100644 (file)
index 0000000..9f0900e
--- /dev/null
+++ b/.config/coc/extensions/node_modules/coc-prettier/node_modules/rxjs/src/internal/observable/onErrorResumeNext.ts
@@ -0,0 +1,102 @@
+import { Observable } from '../Observable';
+import { ObservableInput } from '../types';
+import { from } from './from';
+import { isArray } from '../util/isArray';
+import { EMPTY } from './empty';
+
+/* tslint:disable:max-line-length */
+export function onErrorResumeNext<R>(v: ObservableInput<R>): Observable<R>;
+export function onErrorResumeNext<T2, T3, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>): Observable<R>;
+export function onErrorResumeNext<T2, T3, T4, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>): Observable<R>;
+export function onErrorResumeNext<T2, T3, T4, T5, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>): Observable<R>;
+export function onErrorResumeNext<T2, T3, T4, T5, T6, R>(v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>): Observable<R>;
+
+export function onErrorResumeNext<R>(...observables: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): Observable<R>;
+export function onErrorResumeNext<R>(array: ObservableInput<any>[]): Observable<R>;
+/* tslint:enable:max-line-length */
+
+/**
+ * When any of the provided Observable emits an complete or error notification, it immediately subscribes to the next one
+ * that was passed.
+ *
+ * <span class="informal">Execute series of Observables no matter what, even if it means swallowing errors.</span>
+ *
+ * ![](onErrorResumeNext.png)
+ *
+ * `onErrorResumeNext` Will subscribe to each observable source it is provided, in order.
+ * If the source it's subscribed to emits an error or completes, it will move to the next source
+ * without error.
+ *
+ * If `onErrorResumeNext` is provided no arguments, or a single, empty array, it will return {@link index/EMPTY}.
+ *
+ * `onErrorResumeNext` is basically {@link concat}, only it will continue, even if one of its
+ * sources emits an error.
+ *
+ * Note that there is no way to handle any errors thrown by sources via the result of
+ * `onErrorResumeNext`. If you want to handle errors thrown in any given source, you can
+ * always use the {@link catchError} operator on them before passing them into `onErrorResumeNext`.
+ *
+ * ## Example
+ * Subscribe to the next Observable after map fails</caption>
+ * ```ts
+ * import { onErrorResumeNext, of } from 'rxjs';
+ * import { map } from 'rxjs/operators';
+ *
+ * onErrorResumeNext(
+ *  of(1, 2, 3, 0).pipe(
+ *    map(x => {
+ *      if (x === 0) throw Error();
+ *      return 10 / x;
+ *    })
+ *  ),
+ *  of(1, 2, 3),
+ * )
+ * .subscribe(
+ *   val => console.log(val),
+ *   err => console.log(err),          // Will never be called.
+ *   () => console.log('done'),
+ * );
+ *
+ * // Logs:
+ * // 10
+ * // 5
+ * // 3.3333333333333335
+ * // 1
+ * // 2
+ * // 3
+ * // "done"
+ * ```
+ *
+ * @see {@link concat}
+ * @see {@link catchError}
+ *
+ * @param {...ObservableInput} sources Observables (or anything that *is* observable) passed either directly or as an array.
+ * @return {Observable} An Observable that concatenates all sources, one after the other,
+ * ignoring all errors, such that any error causes it to move on to the next source.
+ */
+export function onErrorResumeNext<T, R>(...sources: Array<ObservableInput<any> |
+                                                              Array<ObservableInput<any>> |
+                                                              ((...values: Array<any>) => R)>): Observable<R> {
+
+  if (sources.length === 0) {
+    return EMPTY;
+  }
+
+  const [ first, ...remainder ] = sources;
+
+  if (sources.length === 1 && isArray(first)) {
+    return onErrorResumeNext(...first);
+  }
+
+  return new Observable(subscriber => {
+    const subNext = () => subscriber.add(
+      onErrorResumeNext(...remainder).subscribe(subscriber)
+    );
+
+    return from(first).subscribe({
+      next(value) { subscriber.next(value); },
+      error: subNext,
+      complete: subNext,
+    });
+  });
+}