rxjs - npm Package Compare versions

Comparing version 7.8.0 to 7.8.1

dist/cjs/internal/operators/throttle.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.throttle = exports.defaultThrottleConfig = void 0;
+exports.throttle = void 0;
 var lift_1 = require("../util/lift");
 var OperatorSubscriber_1 = require("./OperatorSubscriber");
 var innerFrom_1 = require("../observable/innerFrom");
-exports.defaultThrottleConfig = {
-    leading: true,
-    trailing: false,
-};
 function throttle(durationSelector, config) {
-    if (config === void 0) { config = exports.defaultThrottleConfig; }
     return lift_1.operate(function (source, subscriber) {
-        var leading = config.leading, trailing = config.trailing;
+        var _a = config !== null && config !== void 0 ? config : {}, _b = _a.leading, leading = _b === void 0 ? true : _b, _c = _a.trailing, trailing = _c === void 0 ? false : _c;
         var hasValue = false;
@@ -16,0 +11,0 @@ var sendValue = null;

dist/cjs/internal/operators/throttleTime.js

@@ -9,3 +9,2 @@ "use strict";
     if (scheduler === void 0) { scheduler = async_1.asyncScheduler; }
-    if (config === void 0) { config = throttle_1.defaultThrottleConfig; }
     var duration$ = timer_1.timer(duration, scheduler);
@@ -12,0 +11,0 @@ return throttle_1.throttle(function () { return duration$; }, config);

dist/cjs/internal/scheduler/AsapAction.js

@@ -46,3 +46,5 @@ "use strict";
             immediateProvider_1.immediateProvider.clearImmediate(id);
-            scheduler._scheduled = undefined;
+            if (scheduler._scheduled === id) {
+                scheduler._scheduled = undefined;
+            }
         }
@@ -49,0 +51,0 @@ return undefined;

dist/esm/internal/operators/throttle.js

 import { operate } from '../util/lift';
 import { createOperatorSubscriber } from './OperatorSubscriber';
 import { innerFrom } from '../observable/innerFrom';
-export const defaultThrottleConfig = {
-    leading: true,
-    trailing: false,
-};
-export function throttle(durationSelector, config = defaultThrottleConfig) {
+export function throttle(durationSelector, config) {
     return operate((source, subscriber) => {
-        const { leading, trailing } = config;
+        const { leading = true, trailing = false } = config !== null && config !== void 0 ? config : {};
         let hasValue = false;
@@ -12,0 +8,0 @@ let sendValue = null;

dist/esm/internal/operators/throttleTime.js

 import { asyncScheduler } from '../scheduler/async';
-import { defaultThrottleConfig, throttle } from './throttle';
+import { throttle } from './throttle';
 import { timer } from '../observable/timer';
-export function throttleTime(duration, scheduler = asyncScheduler, config = defaultThrottleConfig) {
+export function throttleTime(duration, scheduler = asyncScheduler, config) {
     const duration$ = timer(duration, scheduler);
@@ -6,0 +6,0 @@ return throttle(() => duration$, config);

dist/esm/internal/scheduler/AsapAction.js

@@ -24,3 +24,5 @@ import { AsyncAction } from './AsyncAction';
             immediateProvider.clearImmediate(id);
-            scheduler._scheduled = undefined;
+            if (scheduler._scheduled === id) {
+                scheduler._scheduled = undefined;
+            }
         }
@@ -27,0 +29,0 @@ return undefined;

dist/esm5/internal/operators/throttle.js

 import { operate } from '../util/lift';
 import { createOperatorSubscriber } from './OperatorSubscriber';
 import { innerFrom } from '../observable/innerFrom';
-export var defaultThrottleConfig = {
-    leading: true,
-    trailing: false,
-};
 export function throttle(durationSelector, config) {
-    if (config === void 0) { config = defaultThrottleConfig; }
     return operate(function (source, subscriber) {
-        var leading = config.leading, trailing = config.trailing;
+        var _a = config !== null && config !== void 0 ? config : {}, _b = _a.leading, leading = _b === void 0 ? true : _b, _c = _a.trailing, trailing = _c === void 0 ? false : _c;
         var hasValue = false;
@@ -13,0 +8,0 @@ var sendValue = null;

dist/esm5/internal/operators/throttleTime.js

 import { asyncScheduler } from '../scheduler/async';
-import { defaultThrottleConfig, throttle } from './throttle';
+import { throttle } from './throttle';
 import { timer } from '../observable/timer';
 export function throttleTime(duration, scheduler, config) {
     if (scheduler === void 0) { scheduler = asyncScheduler; }
-    if (config === void 0) { config = defaultThrottleConfig; }
     var duration$ = timer(duration, scheduler);
@@ -8,0 +7,0 @@ return throttle(function () { return duration$; }, config);

dist/esm5/internal/scheduler/AsapAction.js

@@ -29,3 +29,5 @@ import { __extends } from "tslib";
             immediateProvider.clearImmediate(id);
-            scheduler._scheduled = undefined;
+            if (scheduler._scheduled === id) {
+                scheduler._scheduled = undefined;
+            }
         }
@@ -32,0 +34,0 @@ return undefined;

dist/types/index.d.ts

@@ -156,3 +156,3 @@ /// <reference path="operators/index.d.ts" />
 export { takeWhile } from './internal/operators/takeWhile';
-export { tap } from './internal/operators/tap';
+export { tap, TapObserver } from './internal/operators/tap';
 export { throttle, ThrottleConfig } from './internal/operators/throttle';
@@ -159,0 +159,0 @@ export { throttleTime } from './internal/operators/throttleTime';

dist/types/internal/operators/exhaustAll.d.ts

@@ -9,3 +9,3 @@ import { OperatorFunction, ObservableInput, ObservedValueOf } from '../types';
  *
- * ![](exhaust.png)
+ * ![](exhaustAll.svg)
  *
@@ -12,0 +12,0 @@ * `exhaustAll` subscribes to an Observable that emits Observables, also known as a

dist/types/internal/operators/tap.d.ts

 import { MonoTypeOperatorFunction, Observer } from '../types';
+/**
+ * An extension to the {@link Observer} interface used only by the {@link tap} operator.
+ *
+ * It provides a useful set of callbacks a user can register to do side-effects in
+ * cases other than what the usual {@link Observer} callbacks are
+ * ({@link guide/glossary-and-semantics#next next},
+ * {@link guide/glossary-and-semantics#error error} and/or
+ * {@link guide/glossary-and-semantics#complete complete}).
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { fromEvent, switchMap, tap, interval, take } from 'rxjs';
+ *
+ * const source$ = fromEvent(document, 'click');
+ * const result$ = source$.pipe(
+ *   switchMap((_, i) => i % 2 === 0
+ *     ? fromEvent(document, 'mousemove').pipe(
+ *         tap({
+ *           subscribe: () => console.log('Subscribed to the mouse move events after click #' + i),
+ *           unsubscribe: () => console.log('Mouse move events #' + i + ' unsubscribed'),
+ *           finalize: () => console.log('Mouse move events #' + i + ' finalized')
+ *         })
+ *       )
+ *     : interval(1_000).pipe(
+ *         take(5),
+ *         tap({
+ *           subscribe: () => console.log('Subscribed to the 1-second interval events after click #' + i),
+ *           unsubscribe: () => console.log('1-second interval events #' + i + ' unsubscribed'),
+ *           finalize: () => console.log('1-second interval events #' + i + ' finalized')
+ *         })
+ *       )
+ *   )
+ * );
+ *
+ * const subscription = result$.subscribe({
+ *   next: console.log
+ * });
+ *
+ * setTimeout(() => {
+ *   console.log('Unsubscribe after 60 seconds');
+ *   subscription.unsubscribe();
+ * }, 60_000);
+ * ```
+ */
 export interface TapObserver<T> extends Observer<T> {
+    /**
+     * The callback that `tap` operator invokes at the moment when the source Observable
+     * gets subscribed to.
+     */
     subscribe: () => void;
+    /**
+     * The callback that `tap` operator invokes when an explicit
+     * {@link guide/glossary-and-semantics#unsubscription unsubscribe} happens. It won't get invoked on
+     * `error` or `complete` events.
+     */
     unsubscribe: () => void;
+    /**
+     * The callback that `tap` operator invokes when any kind of
+     * {@link guide/glossary-and-semantics#finalization finalization} happens - either when
+     * the source Observable `error`s or `complete`s or when it gets explicitly unsubscribed
+     * by the user. There is no difference in using this callback or the {@link finalize}
+     * operator, but if you're already using `tap` operator, you can use this callback
+     * instead. You'd get the same result in either case.
+     */
     finalize: () => void;
@@ -6,0 +68,0 @@ }

dist/types/internal/operators/throttle.d.ts

 import { MonoTypeOperatorFunction, ObservableInput } from '../types';
+/**
+ * An object interface used by {@link throttle} or {@link throttleTime} that ensure
+ * configuration options of these operators.
+ *
+ * @see {@link throttle}
+ * @see {@link throttleTime}
+ */
 export interface ThrottleConfig {
+    /**
+     * If `true`, the resulting Observable will emit the first value from the source
+     * Observable at the **start** of the "throttling" process (when starting an
+     * internal timer that prevents other emissions from the source to pass through).
+     * If `false`, it will not emit the first value from the source Observable at the
+     * start of the "throttling" process.
+     *
+     * If not provided, defaults to: `true`.
+     */
     leading?: boolean;
+    /**
+     * If `true`, the resulting Observable will emit the last value from the source
+     * Observable at the **end** of the "throttling" process (when ending an internal
+     * timer that prevents other emissions from the source to pass through).
+     * If `false`, it will not emit the last value from the source Observable at the
+     * end of the "throttling" process.
+     *
+     * If not provided, defaults to: `false`.
+     */
     trailing?: boolean;
 }
-export declare const defaultThrottleConfig: ThrottleConfig;
 /**
@@ -45,7 +69,7 @@ * Emits a value from the source Observable, then ignores subsequent source
  *
- * @param durationSelector A function
- * that receives a value from the source Observable, for computing the silencing
- * duration for each source value, returned as an Observable or a Promise.
- * @param config a configuration object to define `leading` and `trailing` behavior. Defaults
- * to `{ leading: true, trailing: false }`.
+ * @param durationSelector A function that receives a value from the source
+ * Observable, for computing the silencing duration for each source value,
+ * returned as an `ObservableInput`.
+ * @param config A configuration object to define `leading` and `trailing`
+ * behavior. Defaults to `{ leading: true, trailing: false }`.
  * @return A function that returns an Observable that performs the throttle
@@ -52,0 +76,0 @@ * operation to limit the rate of emissions from the source.

dist/types/internal/operators/throttleTime.d.ts

@@ -0,1 +1,2 @@
+import { ThrottleConfig } from './throttle';
 import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
@@ -46,3 +47,3 @@ /**
  * managing the timers that handle the throttling. Defaults to {@link asyncScheduler}.
- * @param config a configuration object to define `leading` and
+ * @param config A configuration object to define `leading` and
  * `trailing` behavior. Defaults to `{ leading: true, trailing: false }`.
@@ -52,3 +53,3 @@ * @return A function that returns an Observable that performs the throttle
  */
-export declare function throttleTime<T>(duration: number, scheduler?: SchedulerLike, config?: import("./throttle").ThrottleConfig): MonoTypeOperatorFunction<T>;
+export declare function throttleTime<T>(duration: number, scheduler?: SchedulerLike, config?: ThrottleConfig): MonoTypeOperatorFunction<T>;
 //# sourceMappingURL=throttleTime.d.ts.map

dist/types/internal/types.d.ts

@@ -13,3 +13,9 @@ /// <reference lib="esnext.asynciterable" />
 }
-/** OPERATOR INTERFACES */
+/**
+ * A function type interface that describes a function that accepts one parameter `T`
+ * and returns another parameter `R`.
+ *
+ * Usually used to describe {@link OperatorFunction} - it always takes a single
+ * parameter (the source Observable) and returns another Observable.
+ */
 export interface UnaryFunction<T, R> {
@@ -54,3 +60,2 @@ (source: T): R;
 }
-/** SUBSCRIPTION INTERFACES */
 export interface Unsubscribable {
@@ -86,3 +91,2 @@ unsubscribe(): void;
 }
-/** NOTIFICATIONS */
 /**
@@ -118,3 +122,2 @@ * A notification representing a "next" from an observable.
 export declare type ObservableNotification<T> = NextNotification<T> | ErrorNotification | CompleteNotification;
-/** OBSERVER INTERFACES */
 export interface NextObserver<T> {
@@ -139,5 +142,37 @@ closed?: boolean;
 export declare type PartialObserver<T> = NextObserver<T> | ErrorObserver<T> | CompletionObserver<T>;
+/**
+ * An object interface that defines a set of callback functions a user can use to get
+ * notified of any set of {@link Observable}
+ * {@link guide/glossary-and-semantics#notification notification} events.
+ *
+ * For more info, please refer to {@link guide/observer this guide}.
+ */
 export interface Observer<T> {
+    /**
+     * A callback function that gets called by the producer during the subscription when
+     * the producer "has" the `value`. It won't be called if `error` or `complete` callback
+     * functions have been called, nor after the consumer has unsubscribed.
+     *
+     * For more info, please refer to {@link guide/glossary-and-semantics#next this guide}.
+     */
     next: (value: T) => void;
+    /**
+     * A callback function that gets called by the producer if and when it encountered a
+     * problem of any kind. The errored value will be provided through the `err` parameter.
+     * This callback can't be called more than one time, it can't be called if the
+     * `complete` callback function have been called previously, nor it can't be called if
+     * the consumer has unsubscribed.
+     *
+     * For more info, please refer to {@link guide/glossary-and-semantics#error this guide}.
+     */
     error: (err: any) => void;
+    /**
+     * A callback function that gets called by the producer if and when it has no more
+     * values to provide (by calling `next` callback function). This means that no error
+     * has happened. This callback can't be called more than one time, it can't be called
+     * if the `error` callback function have been called previously, nor it can't be called
+     * if the consumer has unsubscribed.
+     *
+     * For more info, please refer to {@link guide/glossary-and-semantics#complete this guide}.
+     */
     complete: () => void;
@@ -147,3 +182,2 @@ }
 }
-/** SCHEDULER INTERFACES */
 export interface SchedulerLike extends TimestampProvider {
@@ -150,0 +184,0 @@ schedule<T>(work: (this: SchedulerAction<T>, state: T) => void, delay: number, state: T): Subscription;

dist/types/operators/index.d.ts

@@ -96,3 +96,3 @@ export { audit } from '../internal/operators/audit';
 export { takeWhile } from '../internal/operators/takeWhile';
-export { tap } from '../internal/operators/tap';
+export { tap, TapObserver } from '../internal/operators/tap';
 export { throttle, ThrottleConfig } from '../internal/operators/throttle';
@@ -99,0 +99,0 @@ export { throttleTime } from '../internal/operators/throttleTime';

package.json

 {
   "name": "rxjs",
-  "version": "7.8.0",
+  "version": "7.8.1",
   "description": "Reactive Extensions for modern JavaScript",
@@ -5,0 +5,0 @@ "main": "./dist/cjs/index.js",

src/index.ts

@@ -193,3 +193,3 @@ //////////////////////////////////////////////////////////
 export { takeWhile } from './internal/operators/takeWhile';
-export { tap } from './internal/operators/tap';
+export { tap, TapObserver } from './internal/operators/tap';
 export { throttle, ThrottleConfig } from './internal/operators/throttle';
@@ -196,0 +196,0 @@ export { throttleTime } from './internal/operators/throttleTime';

src/internal/observable/bindCallback.ts

@@ -89,9 +89,9 @@ /* @prettier */
  *
- * const someFunction = (cb) => {
- *   cb(5, 'some string', {someProperty: 'someValue'})
+ * const someFunction = (n, s, cb) => {
+ *   cb(n, s, { someProperty: 'someValue' });
  * };
  *
  * const boundSomeFunction = bindCallback(someFunction);
- * boundSomeFunction(12, 10).subscribe(values => {
- *   console.log(values); // [22, 2]
+ * boundSomeFunction(5, 'some string').subscribe((values) => {
+ *   console.log(values); // [5, 'some string', {someProperty: 'someValue'}]
  * });
@@ -98,0 +98,0 @@ * ```

src/internal/observable/fromEvent.ts

@@ -207,6 +207,10 @@ import { innerFrom } from '../observable/innerFrom';
  *
- * const clicksInDocument = fromEvent(document, 'click', true); // note optional configuration parameter
- *                                                              // which will be passed to addEventListener
- * const clicksInDiv = fromEvent(someDivInDocument, 'click');
+ * const div = document.createElement('div');
+ * div.style.cssText = 'width: 200px; height: 200px; background: #09c;';
+ * document.body.appendChild(div);
  *
+ * // note optional configuration parameter which will be passed to addEventListener
+ * const clicksInDocument = fromEvent(document, 'click', { capture: true });
+ * const clicksInDiv = fromEvent(div, 'click');
+ *
  * clicksInDocument.subscribe(() => console.log('document'));
@@ -213,0 +217,0 @@ * clicksInDiv.subscribe(() => console.log('div'));

src/internal/operators/exhaustAll.ts

@@ -12,3 +12,3 @@ import { OperatorFunction, ObservableInput, ObservedValueOf } from '../types';
  *
- * ![](exhaust.png)
+ * ![](exhaustAll.svg)
  *
@@ -15,0 +15,0 @@ * `exhaustAll` subscribes to an Observable that emits Observables, also known as a

src/internal/operators/exhaustMap.ts

@@ -30,3 +30,3 @@ import { Observable } from '../Observable';
  * <span class="informal">Maps each value to an Observable, then flattens all of
- * these inner Observables using {@link exhaust}.</span>
+ * these inner Observables using {@link exhaustAll}.</span>
  *
@@ -33,0 +33,0 @@ * ![](exhaustMap.png)

src/internal/operators/switchMap.ts

@@ -28,3 +28,3 @@ import { Subscriber } from '../Subscriber';
  * <span class="informal">Maps each value to an Observable, then flattens all of
- * these inner Observables.</span>
+ * these inner Observables using {@link switchAll}.</span>
  *
@@ -31,0 +31,0 @@ * ![](switchMap.png)

src/internal/operators/tap.ts

@@ -7,5 +7,67 @@ import { MonoTypeOperatorFunction, Observer } from '../types';
 
+/**
+ * An extension to the {@link Observer} interface used only by the {@link tap} operator.
+ *
+ * It provides a useful set of callbacks a user can register to do side-effects in
+ * cases other than what the usual {@link Observer} callbacks are
+ * ({@link guide/glossary-and-semantics#next next},
+ * {@link guide/glossary-and-semantics#error error} and/or
+ * {@link guide/glossary-and-semantics#complete complete}).
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { fromEvent, switchMap, tap, interval, take } from 'rxjs';
+ *
+ * const source$ = fromEvent(document, 'click');
+ * const result$ = source$.pipe(
+ *   switchMap((_, i) => i % 2 === 0
+ *     ? fromEvent(document, 'mousemove').pipe(
+ *         tap({
+ *           subscribe: () => console.log('Subscribed to the mouse move events after click #' + i),
+ *           unsubscribe: () => console.log('Mouse move events #' + i + ' unsubscribed'),
+ *           finalize: () => console.log('Mouse move events #' + i + ' finalized')
+ *         })
+ *       )
+ *     : interval(1_000).pipe(
+ *         take(5),
+ *         tap({
+ *           subscribe: () => console.log('Subscribed to the 1-second interval events after click #' + i),
+ *           unsubscribe: () => console.log('1-second interval events #' + i + ' unsubscribed'),
+ *           finalize: () => console.log('1-second interval events #' + i + ' finalized')
+ *         })
+ *       )
+ *   )
+ * );
+ *
+ * const subscription = result$.subscribe({
+ *   next: console.log
+ * });
+ *
+ * setTimeout(() => {
+ *   console.log('Unsubscribe after 60 seconds');
+ *   subscription.unsubscribe();
+ * }, 60_000);
+ * ```
+ */
 export interface TapObserver<T> extends Observer<T> {
+  /**
+   * The callback that `tap` operator invokes at the moment when the source Observable
+   * gets subscribed to.
+   */
   subscribe: () => void;
+  /**
+   * The callback that `tap` operator invokes when an explicit
+   * {@link guide/glossary-and-semantics#unsubscription unsubscribe} happens. It won't get invoked on
+   * `error` or `complete` events.
+   */
   unsubscribe: () => void;
+  /**
+   * The callback that `tap` operator invokes when any kind of
+   * {@link guide/glossary-and-semantics#finalization finalization} happens - either when
+   * the source Observable `error`s or `complete`s or when it gets explicitly unsubscribed
+   * by the user. There is no difference in using this callback or the {@link finalize}
+   * operator, but if you're already using `tap` operator, you can use this callback
+   * instead. You'd get the same result in either case.
+   */
   finalize: () => void;
@@ -98,3 +160,3 @@ }
  * @see {@link finalize}
- * @see {@link Observable#subscribe}
+ * @see {@link TapObserver}
  *
@@ -101,0 +163,0 @@ * @param observerOrNext A next handler or partial observer

src/internal/operators/throttle.ts

@@ -8,12 +8,32 @@ import { Subscription } from '../Subscription';
 
+/**
+ * An object interface used by {@link throttle} or {@link throttleTime} that ensure
+ * configuration options of these operators.
+ *
+ * @see {@link throttle}
+ * @see {@link throttleTime}
+ */
 export interface ThrottleConfig {
+  /**
+   * If `true`, the resulting Observable will emit the first value from the source
+   * Observable at the **start** of the "throttling" process (when starting an
+   * internal timer that prevents other emissions from the source to pass through).
+   * If `false`, it will not emit the first value from the source Observable at the
+   * start of the "throttling" process.
+   *
+   * If not provided, defaults to: `true`.
+   */
   leading?: boolean;
+  /**
+   * If `true`, the resulting Observable will emit the last value from the source
+   * Observable at the **end** of the "throttling" process (when ending an internal
+   * timer that prevents other emissions from the source to pass through).
+   * If `false`, it will not emit the last value from the source Observable at the
+   * end of the "throttling" process.
+   *
+   * If not provided, defaults to: `false`.
+   */
   trailing?: boolean;
 }
 
-export const defaultThrottleConfig: ThrottleConfig = {
-  leading: true,
-  trailing: false,
-};
-
 /**
@@ -57,16 +77,13 @@ * Emits a value from the source Observable, then ignores subsequent source
  *
- * @param durationSelector A function
- * that receives a value from the source Observable, for computing the silencing
- * duration for each source value, returned as an Observable or a Promise.
- * @param config a configuration object to define `leading` and `trailing` behavior. Defaults
- * to `{ leading: true, trailing: false }`.
+ * @param durationSelector A function that receives a value from the source
+ * Observable, for computing the silencing duration for each source value,
+ * returned as an `ObservableInput`.
+ * @param config A configuration object to define `leading` and `trailing`
+ * behavior. Defaults to `{ leading: true, trailing: false }`.
  * @return A function that returns an Observable that performs the throttle
  * operation to limit the rate of emissions from the source.
  */
-export function throttle<T>(
-  durationSelector: (value: T) => ObservableInput<any>,
-  config: ThrottleConfig = defaultThrottleConfig
-): MonoTypeOperatorFunction<T> {
+export function throttle<T>(durationSelector: (value: T) => ObservableInput<any>, config?: ThrottleConfig): MonoTypeOperatorFunction<T> {
   return operate((source, subscriber) => {
-    const { leading, trailing } = config;
+    const { leading = true, trailing = false } = config ?? {};
     let hasValue = false;
@@ -73,0 +90,0 @@ let sendValue: T | null = null;

src/internal/operators/throttleTime.ts

 import { asyncScheduler } from '../scheduler/async';
-import { defaultThrottleConfig, throttle } from './throttle';
+import { throttle, ThrottleConfig } from './throttle';
 import { MonoTypeOperatorFunction, SchedulerLike } from '../types';
@@ -50,3 +50,3 @@ import { timer } from '../observable/timer';
  * managing the timers that handle the throttling. Defaults to {@link asyncScheduler}.
- * @param config a configuration object to define `leading` and
+ * @param config A configuration object to define `leading` and
  * `trailing` behavior. Defaults to `{ leading: true, trailing: false }`.
@@ -59,3 +59,3 @@ * @return A function that returns an Observable that performs the throttle
   scheduler: SchedulerLike = asyncScheduler,
-  config = defaultThrottleConfig
+  config?: ThrottleConfig
 ): MonoTypeOperatorFunction<T> {
@@ -62,0 +62,0 @@ const duration$ = timer(duration, scheduler);

src/internal/scheduler/AsapAction.ts

@@ -38,3 +38,5 @@ import { AsyncAction } from './AsyncAction';
       immediateProvider.clearImmediate(id);
-      scheduler._scheduled = undefined;
+      if (scheduler._scheduled === id) {
+        scheduler._scheduled = undefined;
+      }
     }
@@ -41,0 +43,0 @@ // Return undefined so the action knows to request a new async id if it's rescheduled.

src/internal/types.ts

@@ -17,4 +17,11 @@ // https://github.com/microsoft/TypeScript/issues/40462#issuecomment-689879308
 
-/** OPERATOR INTERFACES */
+/* OPERATOR INTERFACES */
 
+/**
+ * A function type interface that describes a function that accepts one parameter `T`
+ * and returns another parameter `R`.
+ *
+ * Usually used to describe {@link OperatorFunction} - it always takes a single
+ * parameter (the source Observable) and returns another Observable.
+ */
 export interface UnaryFunction<T, R> {
@@ -64,3 +71,3 @@ (source: T): R;
 
-/** SUBSCRIPTION INTERFACES */
+/* SUBSCRIPTION INTERFACES */
 
@@ -113,3 +120,3 @@ export interface Unsubscribable {
 
-/** NOTIFICATIONS */
+/* NOTIFICATIONS */
 
@@ -150,3 +157,3 @@ /**
 
-/** OBSERVER INTERFACES */
+/* OBSERVER INTERFACES */
 
@@ -176,5 +183,37 @@ export interface NextObserver<T> {
 
+/**
+ * An object interface that defines a set of callback functions a user can use to get
+ * notified of any set of {@link Observable}
+ * {@link guide/glossary-and-semantics#notification notification} events.
+ *
+ * For more info, please refer to {@link guide/observer this guide}.
+ */
 export interface Observer<T> {
+  /**
+   * A callback function that gets called by the producer during the subscription when
+   * the producer "has" the `value`. It won't be called if `error` or `complete` callback
+   * functions have been called, nor after the consumer has unsubscribed.
+   *
+   * For more info, please refer to {@link guide/glossary-and-semantics#next this guide}.
+   */
   next: (value: T) => void;
+  /**
+   * A callback function that gets called by the producer if and when it encountered a
+   * problem of any kind. The errored value will be provided through the `err` parameter.
+   * This callback can't be called more than one time, it can't be called if the
+   * `complete` callback function have been called previously, nor it can't be called if
+   * the consumer has unsubscribed.
+   *
+   * For more info, please refer to {@link guide/glossary-and-semantics#error this guide}.
+   */
   error: (err: any) => void;
+  /**
+   * A callback function that gets called by the producer if and when it has no more
+   * values to provide (by calling `next` callback function). This means that no error
+   * has happened. This callback can't be called more than one time, it can't be called
+   * if the `error` callback function have been called previously, nor it can't be called
+   * if the consumer has unsubscribed.
+   *
+   * For more info, please refer to {@link guide/glossary-and-semantics#complete this guide}.
+   */
   complete: () => void;
@@ -185,3 +224,3 @@ }
 
-/** SCHEDULER INTERFACES */
+/* SCHEDULER INTERFACES */
 
@@ -188,0 +227,0 @@ export interface SchedulerLike extends TimestampProvider {

src/operators/index.ts

@@ -97,3 +97,3 @@ /* Operator exports */
 export { takeWhile } from '../internal/operators/takeWhile';
-export { tap } from '../internal/operators/tap';
+export { tap, TapObserver } from '../internal/operators/tap';
 export { throttle, ThrottleConfig } from '../internal/operators/throttle';
@@ -100,0 +100,0 @@ export { throttleTime } from '../internal/operators/throttleTime';

No alert changes

Improved metrics

Total package byte prevSize

4501327

increased by0.25%

Lines of code

57547

increased by0.4%

No dependency changes