.config/coc/extensions/node_modules/coc-prettier/node_modules/rxjs/src/internal/observable/using.ts

   1 import { Observable } from '../Observable';
   2 import { Unsubscribable, ObservableInput } from '../types';
   3 import { from } from './from'; // from from from! LAWL
   4 import { EMPTY } from './empty';
   5
   6 /**
   7  * Creates an Observable that uses a resource which will be disposed at the same time as the Observable.
   8  *
   9  * <span class="informal">Use it when you catch yourself cleaning up after an Observable.</span>
  10  *
  11  * `using` is a factory operator, which accepts two functions. First function returns a disposable resource.
  12  * It can be an arbitrary object that implements `unsubscribe` method. Second function will be injected with
  13  * that object and should return an Observable. That Observable can use resource object during its execution.
  14  * Both functions passed to `using` will be called every time someone subscribes - neither an Observable nor
  15  * resource object will be shared in any way between subscriptions.
  16  *
  17  * When Observable returned by `using` is subscribed, Observable returned from the second function will be subscribed
  18  * as well. All its notifications (nexted values, completion and error events) will be emitted unchanged by the output
  19  * Observable. If however someone unsubscribes from the Observable or source Observable completes or errors by itself,
  20  * the `unsubscribe` method on resource object will be called. This can be used to do any necessary clean up, which
  21  * otherwise would have to be handled by hand. Note that complete or error notifications are not emitted when someone
  22  * cancels subscription to an Observable via `unsubscribe`, so `using` can be used as a hook, allowing you to make
  23  * sure that all resources which need to exist during an Observable execution will be disposed at appropriate time.
  24  *
  25  * @see {@link defer}
  26  *
  27  * @param {function(): ISubscription} resourceFactory A function which creates any resource object
  28  * that implements `unsubscribe` method.
  29  * @param {function(resource: ISubscription): Observable<T>} observableFactory A function which
  30  * creates an Observable, that can use injected resource object.
  31  * @return {Observable<T>} An Observable that behaves the same as Observable returned by `observableFactory`, but
  32  * which - when completed, errored or unsubscribed - will also call `unsubscribe` on created resource object.
  33  */
  34 export function using<T>(resourceFactory: () => Unsubscribable | void,
  35                          observableFactory: (resource: Unsubscribable | void) => ObservableInput<T> | void): Observable<T> {
  36   return new Observable<T>(subscriber => {
  37     let resource: Unsubscribable | void;
  38
  39     try {
  40       resource = resourceFactory();
  41     } catch (err) {
  42       subscriber.error(err);
  43       return undefined;
  44     }
  45
  46     let result: ObservableInput<T> | void;
  47     try {
  48       result = observableFactory(resource);
  49     } catch (err) {
  50       subscriber.error(err);
  51       return undefined;
  52     }
  53
  54     const source = result ? from(result) : EMPTY;
  55     const subscription = source.subscribe(subscriber);
  56     return () => {
  57       subscription.unsubscribe();
  58       if (resource) {
  59         resource.unsubscribe();
  60       }
  61     };
  62   });
  63 }