Repositorio del curso CCOM4030 el semestre B91 del proyecto Artesanías con el Instituto de Cultura

skipUntil.d.ts 2.0KB

123456789101112131415161718192021222324252627282930313233343536373839404142
  1. import { Observable } from '../Observable';
  2. import { MonoTypeOperatorFunction } from '../types';
  3. /**
  4. * Returns an Observable that skips items emitted by the source Observable until a second Observable emits an item.
  5. *
  6. * The `skipUntil` operator causes the observable stream to skip the emission of values ​​until the passed in observable emits the first value.
  7. * This can be particularly useful in combination with user interactions, responses of http requests or waiting for specific times to pass by.
  8. *
  9. * ![](skipUntil.png)
  10. *
  11. * Internally the `skipUntil` operator subscribes to the passed in observable (in the following called *notifier*) in order to recognize the emission
  12. * of its first value. When this happens, the operator unsubscribes from the *notifier* and starts emitting the values of the *source*
  13. * observable. It will never let the *source* observable emit any values if the *notifier* completes or throws an error without emitting
  14. * a value before.
  15. *
  16. * ## Example
  17. *
  18. * In the following example, all emitted values ​​of the interval observable are skipped until the user clicks anywhere within the page.
  19. *
  20. * ```ts
  21. * import { interval, fromEvent } from 'rxjs';
  22. * import { skipUntil } from 'rxjs/operators';
  23. *
  24. * const intervalObservable = interval(1000);
  25. * const click = fromEvent(document, 'click');
  26. *
  27. * const emitAfterClick = intervalObservable.pipe(
  28. * skipUntil(click)
  29. * );
  30. * // clicked at 4.6s. output: 5...6...7...8........ or
  31. * // clicked at 7.3s. output: 8...9...10..11.......
  32. * const subscribe = emitAfterClick.subscribe(value => console.log(value));
  33. * ```
  34. *
  35. * @param {Observable} notifier - The second Observable that has to emit an item before the source Observable's elements begin to
  36. * be mirrored by the resulting Observable.
  37. * @return {Observable<T>} An Observable that skips items from the source Observable until the second Observable emits
  38. * an item, then emits the remaining items.
  39. * @method skipUntil
  40. * @owner Observable
  41. */
  42. export declare function skipUntil<T>(notifier: Observable<any>): MonoTypeOperatorFunction<T>;