feat(scheduler): removed deprecated asyncScheduler constant

BREAKING CHANGE: The `async` constant is no longer available. Use `asyncScheduler`.

Author: demensky

docs_app/content/guide/scheduler.md

@@ -8,7 +8,7 @@
 
 <span class="informal">A Scheduler lets you define in what execution context will an Observable deliver notifications to its Observer.</span>
 
-In the example below, we take the usual simple Observable that emits values `1`, `2`, `3` synchronously, and use the operator `observeOn` to specify the `async` scheduler to use for delivering those values.
+In the example below, we take the usual simple Observable that emits values `1`, `2`, `3` synchronously, and use the operator `observeOn` to specify the `asyncScheduler` scheduler to use for delivering those values.
 
 <!-- prettier-ignore -->
 ```ts
@@ -98,13 +98,13 @@ const proxyObserver = {
 };
 ```
 
-The `async` Scheduler operates with a `setTimeout` or `setInterval`, even if the given `delay` was zero. As usual, in JavaScript, `setTimeout(fn, 0)` is known to run the function `fn` earliest on the next event loop iteration. This explains why `got value 1` is delivered to the `finalObserver` after `just after subscribe` happened.
+The `asyncScheduler` Scheduler operates with a `setTimeout` or `setInterval`, even if the given `delay` was zero. As usual, in JavaScript, `setTimeout(fn, 0)` is known to run the function `fn` earliest on the next event loop iteration. This explains why `got value 1` is delivered to the `finalObserver` after `just after subscribe` happened.
 
 The `schedule()` method of a Scheduler takes a `delay` argument, which refers to a quantity of time relative to the Scheduler's own internal clock. A Scheduler's clock need not have any relation to the actual wall-clock time. This is how temporal operators like `delay` operate not on actual time, but on time dictated by the Scheduler's clock. This is specially useful in testing, where a _virtual time Scheduler_ may be used to fake wall-clock time while in reality executing scheduled tasks synchronously.
 
 ## Scheduler Types
 
-The `async` Scheduler is one of the built-in schedulers provided by RxJS. Each of these can be created and returned by using static properties of the `Scheduler` object.
+The `asyncScheduler` Scheduler is one of the built-in schedulers provided by RxJS. Each of these can be created and returned by using static properties of the `Scheduler` object.
 
 | Scheduler                 | Purpose                                                                                                                                                                        |
 | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
@@ -116,7 +116,7 @@ The `async` Scheduler is one of the built-in schedulers provided by RxJS. Each o
 
 ## Using Schedulers
 
-You may have already used schedulers in your RxJS code without explicitly stating the type of schedulers to be used. This is because all Observable operators that deal with concurrency have optional schedulers. If you do not provide the scheduler, RxJS will pick a default scheduler by using the principle of least concurrency. This means that the scheduler which introduces the least amount of concurrency that satisfies the needs of the operator is chosen. For example, for operators returning an observable with a finite and small number of messages, RxJS uses no Scheduler, i.e. `null` or `undefined`. For operators returning a potentially large or infinite number of messages, `queueScheduler` Scheduler is used. For operators which use timers, `async` is used.
+You may have already used schedulers in your RxJS code without explicitly stating the type of schedulers to be used. This is because all Observable operators that deal with concurrency have optional schedulers. If you do not provide the scheduler, RxJS will pick a default scheduler by using the principle of least concurrency. This means that the scheduler which introduces the least amount of concurrency that satisfies the needs of the operator is chosen. For example, for operators returning an observable with a finite and small number of messages, RxJS uses no Scheduler, i.e. `null` or `undefined`. For operators returning a potentially large or infinite number of messages, `queueScheduler` Scheduler is used. For operators which use timers, `asyncScheduler` is used.
 
 Because RxJS uses the least concurrency scheduler, you can pick a different scheduler if you want to introduce concurrency for performance purpose. To specify a particular scheduler, you can use those operator methods that take a scheduler, e.g., `from([10, 20, 30], asyncScheduler)`.
 

src/index.ts

@@ -28,7 +28,7 @@ export { AsyncSubject } from './internal/AsyncSubject';
 
 /* Schedulers */
 export { asapScheduler } from './internal/scheduler/asap';
-export { async, asyncScheduler } from './internal/scheduler/async';
+export { asyncScheduler } from './internal/scheduler/async';
 export { queueScheduler } from './internal/scheduler/queue';
 export { animationFrameScheduler } from './internal/scheduler/animationFrame';
 export { VirtualTimeScheduler, VirtualAction } from './internal/scheduler/VirtualTimeScheduler';

src/internal/observable/generate.ts

@@ -136,7 +136,7 @@ export function generate<T, S>(
  * `scheduler` property on the object passed to the operator. In both cases, a scheduler decides when
  * the next iteration of the loop will happen and therefore when the next value will be emitted
  * by the Observable. For example, to ensure that each value is pushed to the Observer
- * on a separate task in the event loop, you could use the `async` scheduler. Note that
+ * on a separate task in the event loop, you could use the `asyncScheduler` scheduler. Note that
  * by default (when no scheduler is passed) values are simply emitted synchronously.
  *
  *

src/internal/observable/interval.ts

@@ -15,7 +15,7 @@ import { timer } from './timer';
  * ascending integers, with a constant interval of time of your choosing
  * between those emissions. The first emission is not sent immediately, but
  * only after the first period has passed. By default, this operator uses the
- * `async` {@link SchedulerLike} to provide a notion of time, but you may pass any
+ * `asyncScheduler` {@link SchedulerLike} to provide a notion of time, but you may pass any
  * {@link SchedulerLike} to it.
  *
  * ## Example
@@ -43,7 +43,7 @@ import { timer } from './timer';
  *
  * @param {number} [period=0] The interval size in milliseconds (by default)
  * or the time unit determined by the scheduler's clock.
- * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for scheduling
+ * @param {SchedulerLike} [scheduler=asyncScheduler] The {@link SchedulerLike} to use for scheduling
  * the emission of values, and providing a notion of "time".
  * @return {Observable} An Observable that emits a sequential number each time
  * interval.

src/internal/observable/timer.ts

@@ -1,6 +1,6 @@
 import { Observable } from '../Observable';
 import { SchedulerLike } from '../types';
-import { async as asyncScheduler } from '../scheduler/async';
+import { asyncScheduler } from '../scheduler/async';
 import { isScheduler } from '../util/isScheduler';
 import { isValidDate } from '../util/isDate';
 

src/internal/operators/auditTime.ts

@@ -45,7 +45,7 @@ import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
  * @param {number} duration Time to wait before emitting the most recent source
  * value, measured in milliseconds or the time unit determined internally
  * by the optional `scheduler`.
- * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for
+ * @param {SchedulerLike} [scheduler=asyncScheduler] The {@link SchedulerLike} to use for
  * managing the timers that handle the rate-limiting behavior.
  * @return A function that returns an Observable that performs rate-limiting of
  * emissions from the source Observable.

src/internal/operators/debounceTime.ts

@@ -55,7 +55,7 @@ import { createOperatorSubscriber } from './OperatorSubscriber';
  * unit determined internally by the optional `scheduler`) for the window of
  * time required to wait for emission silence before emitting the most recent
  * source value.
- * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for
+ * @param {SchedulerLike} [scheduler=asyncScheduler] The {@link SchedulerLike} to use for
  * managing the timers that handle the timeout for each value.
  * @return A function that returns an Observable that delays the emissions of
  * the source Observable by the specified `dueTime`, and may drop some values

src/internal/operators/delay.ts

@@ -54,7 +54,7 @@ import { timer } from '../observable/timer';
  *
  * @param {number|Date} due The delay duration in milliseconds (a `number`) or
  * a `Date` until which the emission of the source items is delayed.
- * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for
+ * @param {SchedulerLike} [scheduler=asyncScheduler] The {@link SchedulerLike} to use for
  * managing the timers that handle the time-shift for each item.
  * @return A function that returns an Observable that delays the emissions of
  * the source Observable by the specified timeout or Date.

src/internal/operators/sampleTime.ts

@@ -40,7 +40,7 @@ import { interval } from '../observable/interval';
  *
  * @param {number} period The sampling period expressed in milliseconds or the
  * time unit determined internally by the optional `scheduler`.
- * @param {SchedulerLike} [scheduler=async] The {@link SchedulerLike} to use for
+ * @param {SchedulerLike} [scheduler=asyncScheduler] The {@link SchedulerLike} to use for
  * managing the timers that handle the sampling.
  * @return A function that returns an Observable that emits the results of
  * sampling the values emitted by the source Observable at the specified time

src/internal/operators/timeoutWith.ts

@@ -1,4 +1,4 @@
-import { async } from '../scheduler/async';
+import { asyncScheduler } from '../scheduler/async';
 import { isValidDate } from '../util/isDate';
 import { ObservableInput, OperatorFunction, SchedulerLike } from '../types';
 import { timeout } from './timeout';
@@ -88,7 +88,7 @@ export function timeoutWith<T, R>(
   let first: number | Date | undefined;
   let each: number | undefined;
   let _with: () => ObservableInput<R>;
-  scheduler = scheduler ?? async;
+  scheduler = scheduler ?? asyncScheduler;
 
   if (isValidDate(due)) {
     first = due;

src/internal/scheduler/async.ts

@@ -7,7 +7,7 @@ import { AsyncScheduler } from './AsyncScheduler';
  *
  * <span class="informal">Schedule task as if you used setTimeout(task, duration)</span>
  *
- * `async` scheduler schedules tasks asynchronously, by putting them on the JavaScript
+ * `asyncScheduler` scheduler schedules tasks asynchronously, by putting them on the JavaScript
  * event loop queue. It is best used to delay tasks in time or to schedule tasks repeating
  * in intervals.
  *
@@ -49,8 +49,3 @@ import { AsyncScheduler } from './AsyncScheduler';
  */
 
 export const asyncScheduler = new AsyncScheduler(AsyncAction);
-
-/**
- * @deprecated Renamed to {@link asyncScheduler}. Will be removed in v8.
- */
-export const async = asyncScheduler;