update jsdoc examples (audit* through distinct*) (#3768)

* docs(jsdoc): audit* - update example to use pipe()

* docs(jsdoc): buffer* - update example to use pipe()

* docs(jsdoc): catchError - update example to use pipe()

* docs(jsdoc): concat* - update example to use pipe()

* docs(jsdoc): count - update example to use pipe()

* docs(jsdoc): debounce* - update example to use pipe()

* docs(jsdoc): defaultIfEmpty - update example to use pipe()

* docs(jsdoc): delay* - update example to use pipe()

* docs(jsdoc): dematerialize - update example to use pipe()

* docs(jsdoc): distinct* - update example to use pipe()

Author: moniuch

src/internal/operators/audit.ts

@@ -31,8 +31,8 @@ import { subscribeToResult } from '../util/subscribeToResult';
  * repeats for the next source value.
  *
  * @example <caption>Emit clicks at a rate of at most one click per second</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var result = clicks.audit(ev => Rx.Observable.interval(1000));
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(audit(ev => Rx.Observable.interval(1000)));
  * result.subscribe(x => console.log(x));
  *
  * @see {@link auditTime}

src/internal/operators/auditTime.ts

@@ -25,8 +25,8 @@ import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
  * Optionally takes a {@link IScheduler} for managing timers.
  *
  * @example <caption>Emit clicks at a rate of at most one click per second</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var result = clicks.auditTime(1000);
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(auditTime(1000));
  * result.subscribe(x => console.log(x));
  *
  * @see {@link audit}

src/internal/operators/buffer.ts

@@ -20,9 +20,9 @@ import { OperatorFunction } from '../types';
  * `closingNotifier` emits.
  *
  * @example <caption>On every click, emit array of most recent interval events</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var interval = Rx.Observable.interval(1000);
- * var buffered = interval.buffer(clicks);
+ * const clicks = fromEvent(document, 'click');
+ * const interval = interval(1000);
+ * const buffered = interval.pipe(buffer(clicks));
  * buffered.subscribe(x => console.log(x));
  *
  * @see {@link bufferCount}

src/internal/operators/bufferCount.ts

@@ -19,13 +19,13 @@ import { OperatorFunction, TeardownLogic } from '../types';
  * and when each buffer closes and is emitted.
  *
  * @example <caption>Emit the last two click events as an array</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var buffered = clicks.bufferCount(2);
+ * const clicks = fromEvent(document, 'click');
+ * const buffered = clicks.pipe(bufferCount(2));
  * buffered.subscribe(x => console.log(x));
  *
  * @example <caption>On every click, emit the last two click events as an array</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var buffered = clicks.bufferCount(2, 1);
+ * const clicks = fromEvent(document, 'click');
+ * const buffered = clicks.pipe(bufferCount(2, 1));
  * buffered.subscribe(x => console.log(x));
  *
  * @see {@link buffer}

src/internal/operators/bufferTime.ts

@@ -30,13 +30,13 @@ export function bufferTime<T>(bufferTimeSpan: number, bufferCreationInterval: nu
  * `bufferTimeSpan` milliseconds or when it contains `maxBufferSize` elements.
  *
  * @example <caption>Every second, emit an array of the recent click events</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var buffered = clicks.bufferTime(1000);
+ * const clicks = fromEvent(document, 'click');
+ * const buffered = clicks.pipe(bufferTime(1000));
  * buffered.subscribe(x => console.log(x));
  *
  * @example <caption>Every 5 seconds, emit the click events from the next 2 seconds</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var buffered = clicks.bufferTime(2000, 5000);
+ * const clicks = fromEvent(document, 'click');
+ * const buffered = clicks.pipe(bufferTime(2000, 5000));
  * buffered.subscribe(x => console.log(x));
  *
  * @see {@link buffer}

src/internal/operators/bufferToggle.ts

@@ -22,11 +22,11 @@ import { OperatorFunction, SubscribableOrPromise } from '../types';
  * a Subscribable or Promise returned by the `closingSelector` function emits.
  *
  * @example <caption>Every other second, emit the click events from the next 500ms</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var openings = Rx.Observable.interval(1000);
- * var buffered = clicks.bufferToggle(openings, i =>
- *   i % 2 ? Rx.Observable.interval(500) : Rx.Observable.empty()
- * );
+ * const clicks = fromEvent(document, 'click');
+ * const openings = interval(1000);
+ * const buffered = clicks.pipe(bufferToggle(openings, i =>
+ *   i % 2 ? interval(500) : empty()
+ * ));
  * buffered.subscribe(x => console.log(x));
  *
  * @see {@link buffer}

src/internal/operators/bufferWhen.ts

@@ -24,10 +24,10 @@ import { OperatorFunction } from '../types';
  * the buffer, it immediately opens a new buffer and repeats the process.
  *
  * @example <caption>Emit an array of the last clicks every [1-5] random seconds</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var buffered = clicks.bufferWhen(() =>
- *   Rx.Observable.interval(1000 + Math.random() * 4000)
- * );
+ * const clicks = fromEvent(document, 'click');
+ * const buffered = clicks.pipe(bufferWhen(() =>
+ *   interval(1000 + Math.random() * 4000)
+ * ));
  * buffered.subscribe(x => console.log(x));
  *
  * @see {@link buffer}

src/internal/operators/catchError.ts

@@ -13,43 +13,46 @@ import { ObservableInput, OperatorFunction, MonoTypeOperatorFunction } from '../
  *
  * @example <caption>Continues with a different Observable when there's an error</caption>
  *
- * Observable.of(1, 2, 3, 4, 5)
- *   .map(n => {
- * 	   if (n == 4) {
- * 	     throw 'four!';
- *     }
- *	   return n;
- *   })
- *   .catch(err => Observable.of('I', 'II', 'III', 'IV', 'V'))
+ * of(1, 2, 3, 4, 5).pipe(
+ *     map(n => {
+ *   	   if (n == 4) {
+ * 	       throw 'four!';
+ *       }
+ *	     return n;
+ *     }),
+ *     catchError(err => of('I', 'II', 'III', 'IV', 'V')),
+ *   )
  *   .subscribe(x => console.log(x));
  *   // 1, 2, 3, I, II, III, IV, V
  *
  * @example <caption>Retries the caught source Observable again in case of error, similar to retry() operator</caption>
  *
- * Observable.of(1, 2, 3, 4, 5)
- *   .map(n => {
- * 	   if (n === 4) {
- * 	     throw 'four!';
- *     }
- * 	   return n;
- *   })
- *   .catch((err, caught) => caught)
- *   .take(30)
+ * of(1, 2, 3, 4, 5).pipe(
+ *     map(n => {
+ *   	   if (n === 4) {
+ *   	     throw 'four!';
+ *       }
+ * 	     return n;
+ *     }),
+ *     catchError((err, caught) => caught),
+ *     take(30),
+ *   )
  *   .subscribe(x => console.log(x));
  *   // 1, 2, 3, 1, 2, 3, ...
  *
  * @example <caption>Throws a new error when the source Observable throws an error</caption>
  *
- * Observable.of(1, 2, 3, 4, 5)
- *   .map(n => {
- *     if (n == 4) {
- *       throw 'four!';
- *     }
- *     return n;
- *   })
- *   .catch(err => {
- *     throw 'error in source. Details: ' + err;
- *   })
+ * of(1, 2, 3, 4, 5).pipe(
+ *     map(n => {
+ *       if (n == 4) {
+ *         throw 'four!';
+ *       }
+ *       return n;
+ *     }),
+ *     catchError(err => {
+ *       throw 'error in source. Details: ' + err;
+ *     }),
+ *   )
  *   .subscribe(
  *     x => console.log(x),
  *     err => console.log(err)

src/internal/operators/concatAll.ts

@@ -28,9 +28,11 @@ export function concatAll<R>(): OperatorFunction<any, R>;
  * to `1`.
  *
  * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var higherOrder = clicks.map(ev => Rx.Observable.interval(1000).take(4));
- * var firstOrder = higherOrder.concatAll();
+ * const clicks = fromEvent(document, 'click');
+ * const higherOrder = clicks.pipe(
+ *   map(ev => interval(1000).pipe(take(4))),
+ * );
+ * const firstOrder = higherOrder.pipe(concatAll());
  * firstOrder.subscribe(x => console.log(x));
  *
  * // Results in the following:

src/internal/operators/concatMap.ts

@@ -33,8 +33,10 @@ export function concatMap<T, I, R>(project: (value: T, index: number) =>  Observ
  * to `1`.
  *
  * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var result = clicks.concatMap(ev => Rx.Observable.interval(1000).take(4));
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(
+ *   concatMap(ev => interval(1000).pipe(take(4)),
+ * );
  * result.subscribe(x => console.log(x));
  *
  * // Results in the following:

src/internal/operators/concatMapTo.ts

@@ -33,8 +33,10 @@ export function concatMapTo<T, I, R>(observable: ObservableInput<I>, resultSelec
  * set to `1`.
  *
  * @example <caption>For each click event, tick every second from 0 to 3, with no concurrency</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var result = clicks.concatMapTo(Rx.Observable.interval(1000).take(4));
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(
+ *   concatMapTo(interval(1000).pipe(take(4))),
+ * );
  * result.subscribe(x => console.log(x));
  *
  * // Results in the following:

src/internal/operators/count.ts

@@ -22,15 +22,15 @@ import { Subscriber } from '../Subscriber';
  * source values that matched `true` with the `predicate`.
  *
  * @example <caption>Counts how many seconds have passed before the first click happened</caption>
- * var seconds = Rx.Observable.interval(1000);
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var secondsBeforeClick = seconds.takeUntil(clicks);
- * var result = secondsBeforeClick.count();
+ * const seconds = interval(1000);
+ * const clicks = fromEvent(document, 'click');
+ * const secondsBeforeClick = seconds.pipe(takeUntil(clicks));
+ * const result = secondsBeforeClick.pipe(count());
  * result.subscribe(x => console.log(x));
  *
  * @example <caption>Counts how many odd numbers are there between 1 and 7</caption>
- * var numbers = Rx.Observable.range(1, 7);
- * var result = numbers.count(i => i % 2 === 1);
+ * const numbers = range(1, 7);
+ * const result = numbers.pipe(count(i => i % 2 === 1));
  * result.subscribe(x => console.log(x));
  *
  * // Results in:

src/internal/operators/debounce.ts

@@ -32,8 +32,8 @@ import { subscribeToResult } from '../util/subscribeToResult';
  * same time as they did on the source Observable.
  *
  * @example <caption>Emit the most recent click after a burst of clicks</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var result = clicks.debounce(() => Rx.Observable.interval(1000));
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(debounce(() => interval(1000)));
  * result.subscribe(x => console.log(x));
  *
  * @see {@link audit}

src/internal/operators/debounceTime.ts

@@ -29,8 +29,8 @@ import { MonoTypeOperatorFunction, SchedulerLike, TeardownLogic } from '../types
  * managing timers.
  *
  * @example <caption>Emit the most recent click after a burst of clicks</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var result = clicks.debounceTime(1000);
+ * const clicks = fromEvent(document, 'click');
+ * const result = clicks.pipe(debounceTime(1000));
  * result.subscribe(x => console.log(x));
  *
  * @see {@link auditTime}

src/internal/operators/defaultIfEmpty.ts

@@ -22,9 +22,9 @@ export function defaultIfEmpty<T, R>(defaultValue?: R): OperatorFunction<T, T |
  * having emitted any `next` value).
  *
  * @example <caption>If no clicks happen in 5 seconds, then emit "no clicks"</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var clicksBeforeFive = clicks.takeUntil(Rx.Observable.interval(5000));
- * var result = clicksBeforeFive.defaultIfEmpty('no clicks');
+ * const clicks = fromEvent(document, 'click');
+ * const clicksBeforeFive = clicks.pipe(takeUntil(interval(5000)));
+ * const result = clicksBeforeFive.pipe(defaultIfEmpty('no clicks'));
  * result.subscribe(x => console.log(x));
  *
  * @see {@link empty}

src/internal/operators/delay.ts

@@ -23,14 +23,14 @@ import { MonoTypeOperatorFunction, PartialObserver, SchedulerAction, SchedulerLi
  * Observable execution until the given date occurs.
  *
  * @example <caption>Delay each click by one second</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var delayedClicks = clicks.delay(1000); // each click emitted after 1 second
+ * const clicks = fromEvent(document, 'click');
+ * const delayedClicks = clicks.pipe(delay(1000)); // each click emitted after 1 second
  * delayedClicks.subscribe(x => console.log(x));
  *
  * @example <caption>Delay all clicks until a future date happens</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var date = new Date('March 15, 2050 12:00:00'); // in the future
- * var delayedClicks = clicks.delay(date); // click emitted only after that date
+ * const clicks = fromEvent(document, 'click');
+ * const date = new Date('March 15, 2050 12:00:00'); // in the future
+ * const delayedClicks = clicks.pipe(delay(date)); // click emitted only after that date
  * delayedClicks.subscribe(x => console.log(x));
  *
  * @see {@link debounceTime}

src/internal/operators/delayWhen.ts

@@ -39,9 +39,9 @@ export function delayWhen<T>(delayDurationSelector: (value: T) => Observable<any
  * Observable is subscribed.
  *
  * @example <caption>Delay each click by a random amount of time, between 0 and 5 seconds</caption>
- * var clicks = Rx.Observable.fromEvent(document, 'click');
- * var delayedClicks = clicks.delayWhen(event =>
- *   Rx.Observable.interval(Math.random() * 5000)
+ * const clicks = fromEvent(document, 'click');
+ * const delayedClicks = clicks.pipe(
+ *   delayWhen(event => interval(Math.random() * 5000)),
  * );
  * delayedClicks.subscribe(x => console.log(x));
  *

src/internal/operators/dematerialize.ts

@@ -22,13 +22,13 @@ import { OperatorFunction } from '../types';
  * Use this operator in conjunction with {@link materialize}.
  *
  * @example <caption>Convert an Observable of Notifications to an actual Observable</caption>
- * var notifA = new Rx.Notification('N', 'A');
- * var notifB = new Rx.Notification('N', 'B');
- * var notifE = new Rx.Notification('E', void 0,
+ * const notifA = new Rx.Notification('N', 'A');
+ * const notifB = new Rx.Notification('N', 'B');
+ * const notifE = new Rx.Notification('E', void 0,
  *   new TypeError('x.toUpperCase is not a function')
  * );
- * var materialized = Rx.Observable.of(notifA, notifB, notifE);
- * var upperCase = materialized.dematerialize();
+ * const materialized = of(notifA, notifB, notifE);
+ * const upperCase = materialized.pipe(dematerialize());
  * upperCase.subscribe(x => console.log(x), e => console.error(e));
  *
  * // Results in:

src/internal/operators/distinct.ts

@@ -21,8 +21,9 @@ import { MonoTypeOperatorFunction, TeardownLogic } from '../types';
  * that the internal `Set` can be "flushed", basically clearing it of values.
  *
  * @example <caption>A simple example with numbers</caption>
- * Observable.of(1, 1, 2, 2, 2, 1, 2, 3, 4, 3, 2, 1)
- *   .distinct()
+ * of(1, 1, 2, 2, 2, 1, 2, 3, 4, 3, 2, 1).pipe(
+ *     distinct(),
+ *   )
  *   .subscribe(x => console.log(x)); // 1, 2, 3, 4
  *
  * @example <caption>An example using a keySelector function</caption>
@@ -31,12 +32,14 @@ import { MonoTypeOperatorFunction, TeardownLogic } from '../types';
  *    name: string
  * }
  *
- * Observable.of<Person>(
+ * of<Person>(
  *     { age: 4, name: 'Foo'},
  *     { age: 7, name: 'Bar'},
- *     { age: 5, name: 'Foo'})
- *     .distinct((p: Person) => p.name)
- *     .subscribe(x => console.log(x));
+ *     { age: 5, name: 'Foo'},
+ *   ).pipe(
+ *     distinct((p: Person) => p.name),
+ *   )
+ *   .subscribe(x => console.log(x));
  *
  * // displays:
  * // { age: 4, name: 'Foo' }

src/internal/operators/distinctUntilChanged.ts

@@ -18,8 +18,9 @@ export function distinctUntilChanged<T, K>(compare: (x: K, y: K) => boolean, key
  * If a comparator function is not provided, an equality check is used by default.
  *
  * @example <caption>A simple example with numbers</caption>
- * Observable.of(1, 1, 2, 2, 2, 1, 1, 2, 3, 3, 4)
- *   .distinctUntilChanged()
+ * of(1, 1, 2, 2, 2, 1, 1, 2, 3, 3, 4).pipe(
+ *     distinctUntilChanged(),
+ *   )
  *   .subscribe(x => console.log(x)); // 1, 2, 1, 2, 3, 4
  *
  * @example <caption>An example using a compare function</caption>
@@ -28,13 +29,15 @@ export function distinctUntilChanged<T, K>(compare: (x: K, y: K) => boolean, key
  *    name: string
  * }
  *
- * Observable.of<Person>(
+ * of<Person>(
  *     { age: 4, name: 'Foo'},
  *     { age: 7, name: 'Bar'},
- *     { age: 5, name: 'Foo'})
- *     { age: 6, name: 'Foo'})
- *     .distinctUntilChanged((p: Person, q: Person) => p.name === q.name)
- *     .subscribe(x => console.log(x));
+ *     { age: 5, name: 'Foo'},
+ *     { age: 6, name: 'Foo'},
+ *   ).pipe(
+ *     distinctUntilChanged((p: Person, q: Person) => p.name === q.name),
+ *   )
+ *   .subscribe(x => console.log(x));
  *
  * // displays:
  * // { age: 4, name: 'Foo' }