@dereekb/rxjs 13.3.1 → 13.4.1

package/index.cjs.js

@@ -30,7 +30,7 @@ function asObservable(valueOrObs) {
     });
 }
 function asObservableFromGetter(input, args) {
-    var obs = util.getValueFromGetter(input, args);
+    var obs = util.getValueFromGetter(input, args); // eslint-disable-line @typescript-eslint/no-explicit-any
     return asObservable(obs);
 }
 /**
@@ -45,6 +45,8 @@ function asObservableFromGetter(input, args) {
 /**
  * RxJS operator that flattens an emitted Maybe<{@link ObservableOrValueGetter}> into its resolved value,
  * emitting `undefined` when the input is nullish.
+ *
+ * @returns an operator that unwraps Maybe<ObservableOrValueGetter> emissions, emitting undefined for nullish inputs
  */ function maybeValueFromObservableOrValueGetter() {
     return rxjs.switchMap(function(x) {
         return x != null ? asObservableFromGetter(x) : rxjs.of(undefined);
@@ -139,6 +141,7 @@ function _unsupported_iterable_to_array$b(o, minLen) {
  *
  * @param isCheckFunction - optional check function
  * @param defaultValueOnMaybe - default result for null/undefined values
+ * @returns a function that evaluates each value against the check function and returns it or undefined
  */ function makeReturnIfIsFunction(isCheckFunction, defaultValueOnMaybe) {
     return function(value) {
         return returnIfIs(isCheckFunction, value, defaultValueOnMaybe);
@@ -150,6 +153,7 @@ function _unsupported_iterable_to_array$b(o, minLen) {
  * @param isCheckFunction - optional check function
  * @param value - the value to check
  * @param defaultValueOnMaybe - default result for null/undefined values
+ * @returns an observable that emits the value if the check passes, or undefined otherwise
  */ function returnIfIs(isCheckFunction, value, defaultValueOnMaybe) {
     return checkIs(isCheckFunction, value, defaultValueOnMaybe).pipe(rxjs.map(function(x) {
         return x ? value : undefined;
@@ -160,6 +164,7 @@ function _unsupported_iterable_to_array$b(o, minLen) {
  *
  * @param isCheckFunction - optional check function
  * @param defaultValueOnMaybe - default result for null/undefined values
+ * @returns a function that evaluates each value against the check function and returns an observable boolean
  */ function makeCheckIsFunction(isCheckFunction, defaultValueOnMaybe) {
     return function(value) {
         return checkIs(isCheckFunction, value, defaultValueOnMaybe);
@@ -173,6 +178,7 @@ function _unsupported_iterable_to_array$b(o, minLen) {
  * @param isCheckFunction - optional check function
  * @param value - the value to check
  * @param defaultValueOnMaybe - default result for null/undefined values (defaults to false)
+ * @returns an observable boolean indicating whether the value passes the check
  */ function checkIs(isCheckFunction, value) {
     var defaultValueOnMaybe = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
     var is = isCheckFunction ? value != null ? isCheckFunction(value) : rxjs.of(defaultValueOnMaybe) : rxjs.of(true);
@@ -181,6 +187,8 @@ function _unsupported_iterable_to_array$b(o, minLen) {
 // MARK: Filter
 /**
  * RxJS operator that filters out null and undefined values, only passing through defined values.
+ *
+ * @returns operator that filters out null and undefined emissions
  */ function filterMaybe() {
     return rxjs.filter(util.isMaybeSo);
 }
@@ -189,11 +197,15 @@ function _unsupported_iterable_to_array$b(o, minLen) {
  */ var filterMaybeStrict = filterMaybe;
 /**
  * RxJS operator that filters out null/undefined elements from an emitted array, keeping only defined values.
+ *
+ * @returns operator that maps each emitted array to a version with null/undefined elements removed
  */ function filterMaybeArray() {
     return rxjs.map(util.filterMaybeArrayValues);
 }
 /**
  * RxJS operator that skips all leading null/undefined emissions, then passes all subsequent values through.
+ *
+ * @returns operator that skips all null/undefined emissions at the start of the stream
  */ function skipAllInitialMaybe() {
     return rxjs.skipWhile(function(x) {
         return x == null;
@@ -201,6 +213,8 @@ function _unsupported_iterable_to_array$b(o, minLen) {
 }
 /**
  * RxJS operator that skips only the first emission if it is null/undefined, then passes all subsequent values.
+ *
+ * @returns operator that skips the first null/undefined emission if it occurs at the start of the stream
  */ function skipInitialMaybe() {
     return skipMaybes(1);
 }
@@ -208,6 +222,7 @@ function _unsupported_iterable_to_array$b(o, minLen) {
  * RxJS operator that skips up to `maxToSkip` null/undefined emissions, then passes all subsequent values.
  *
  * @param maxToSkip - maximum number of null/undefined emissions to skip
+ * @returns operator that skips the first N null/undefined emissions from the stream
  */ function skipMaybes(maxToSkip) {
     return rxjs.skipWhile(function(x, i) {
         return x == null && i < maxToSkip;
@@ -229,7 +244,7 @@ function _unsupported_iterable_to_array$b(o, minLen) {
     });
 }
 function switchMapToDefault(defaultObs, useDefault) {
-    var useDefaultFn = useDefault ? useDefault : function(x) {
+    var useDefaultFn = useDefault !== null && useDefault !== void 0 ? useDefault : function(x) {
         return rxjs.of(x == null);
     };
     return rxjs.switchMap(function(x) {
@@ -245,6 +260,9 @@ function switchMapToDefault(defaultObs, useDefault) {
 /**
  * RxJS operator that resolves an observable/getter config input into a value, applying defaults
  * for `null`/`undefined`/`true` inputs and emitting `null` for `false`.
+ *
+ * @param config - configuration providing an optional default getter for null/undefined/true inputs
+ * @returns operator that resolves each emitted getter into a value, using the default for nullish or true inputs
  */ function switchMapObject(config) {
     var defaultGetter = config.defaultGetter;
     return rxjs.switchMap(function(inputConfig) {
@@ -279,6 +297,8 @@ function switchMapOnBoolean(switchOnValue, obs, otherwise) {
  * RxJS operator that filters out null/undefined observables and then switches to the remaining ones.
  *
  * Combines {@link filterMaybe} and `switchMap` to only subscribe to non-nullish observables.
+ *
+ * @returns operator that filters nullish observables and subscribes to the non-nullish ones
  */ function switchMapFilterMaybe() {
     return function(source) {
         var subscriber = source.pipe(filterMaybe(), rxjs.switchMap(function(x) {
@@ -289,10 +309,12 @@ function switchMapOnBoolean(switchOnValue, obs, otherwise) {
 }
 /**
  * RxJS operator that switches to the emitted observable if defined, or emits `undefined` when the observable is nullish.
+ *
+ * @returns operator that switches to the emitted observable or emits undefined for null/undefined inputs
  */ function switchMapMaybe() {
     return function(source) {
         var subscriber = source.pipe(rxjs.switchMap(function(x) {
-            return x != null ? x : rxjs.of(undefined);
+            return x !== null && x !== void 0 ? x : rxjs.of(undefined);
         }));
         return subscriber;
     };
@@ -317,11 +339,11 @@ function switchMapOnBoolean(switchOnValue, obs, otherwise) {
     });
 }
 /**
- * Combines both combineLatest with map values to an other value.
+ * Combines the source observable with another observable via `combineLatest`, then maps the pair to a result.
  *
- * @param combineObs
- * @param mapFn
- * @returns
+ * @param combineObs - the secondary observable to combine with the source
+ * @param mapFn - function that maps the source value and combined value to the output
+ * @returns operator that combines the source with `combineObs` and maps each pair using `mapFn`
  */ function combineLatestMapFrom(combineObs, mapFn) {
     return function(obs) {
         return rxjs.combineLatest([
@@ -337,6 +359,11 @@ function switchMapOnBoolean(switchOnValue, obs, otherwise) {
  * Creates an observable that emits a starting value, then a second value after a delay.
  *
  * If the delay is not provided, or is falsy, then the second value is never emitted.
+ *
+ * @param startWith - the value to emit immediately
+ * @param endWith - the value to emit after the delay
+ * @param delayTime - optional delay in milliseconds before emitting the second value
+ * @returns an observable that emits `startWith` immediately and `endWith` after the delay (if provided)
  */ function emitDelayObs(startWith, endWith, delayTime) {
     var obs = rxjs.of(startWith);
     if (delayTime) {
@@ -346,6 +373,10 @@ function switchMapOnBoolean(switchOnValue, obs, otherwise) {
 }
 /**
  * Emits a value after a given delay after every new emission.
+ *
+ * @param value - the value to emit after the delay
+ * @param delayTime - duration in milliseconds before emitting the value
+ * @returns operator that appends the given value after each source emission with the specified delay
  */ function emitAfterDelay(value, delayTime) {
     return function(obs) {
         return obs.pipe(rxjs.switchMap(function(x) {
@@ -375,15 +406,12 @@ function switchMapOnBoolean(switchOnValue, obs, otherwise) {
     });
 }
 function filterIfObjectValuesUnchanged(input) {
-    if (rxjs.isObservable(input)) {
-        return rxjs.mergeMap(function(inputFilter) {
-            return input.pipe(filterIfObjectValuesUnchanged(inputFilter));
-        });
-    } else {
-        return rxjs.filter(function(inputObject) {
-            return !util.areEqualPOJOValues(input, inputObject);
-        });
-    }
+    var result = rxjs.isObservable(input) ? rxjs.mergeMap(function(inputFilter) {
+        return input.pipe(filterIfObjectValuesUnchanged(inputFilter));
+    }) : rxjs.filter(function(inputObject) {
+        return !util.areEqualPOJOValues(input, inputObject);
+    });
+    return result;
 }
 
 function _array_like_to_array$a(arr, len) {
@@ -391,7 +419,7 @@ function _array_like_to_array$a(arr, len) {
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
-function _array_without_holes$5(arr) {
+function _array_without_holes$6(arr) {
     if (Array.isArray(arr)) return _array_like_to_array$a(arr);
 }
 function _class_call_check$8(instance, Constructor) {
@@ -425,14 +453,14 @@ function _define_property$c(obj, key, value) {
     }
     return obj;
 }
-function _iterable_to_array$5(iter) {
+function _iterable_to_array$6(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
-function _non_iterable_spread$5() {
+function _non_iterable_spread$6() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _to_consumable_array$5(arr) {
-    return _array_without_holes$5(arr) || _iterable_to_array$5(arr) || _unsupported_iterable_to_array$a(arr) || _non_iterable_spread$5();
+function _to_consumable_array$6(arr) {
+    return _array_without_holes$6(arr) || _iterable_to_array$6(arr) || _unsupported_iterable_to_array$a(arr) || _non_iterable_spread$6();
 }
 function _unsupported_iterable_to_array$a(o, minLen) {
     if (!o) return;
@@ -472,6 +500,8 @@ function _unsupported_iterable_to_array$a(o, minLen) {
             key: "hasSubscription",
             get: /**
      * Whether a subscription is currently being managed.
+     *
+     * @returns true if a subscription is currently active
      */ function get() {
                 return Boolean(this._subscription);
             }
@@ -551,6 +581,8 @@ function _unsupported_iterable_to_array$a(o, minLen) {
             key: "hasSubscription",
             get: /**
      * Whether any subscriptions are currently being managed.
+     *
+     * @returns true if one or more subscriptions are currently active
      */ function get() {
                 var _this__subscriptions;
                 return Boolean((_this__subscriptions = this._subscriptions) === null || _this__subscriptions === void 0 ? void 0 : _this__subscriptions.length);
@@ -583,7 +615,7 @@ function _unsupported_iterable_to_array$a(o, minLen) {
      */ key: "addSubs",
             value: function addSubs(subs) {
                 var _this__subscriptions;
-                var nextSubscriptions = _to_consumable_array$5((_this__subscriptions = this._subscriptions) !== null && _this__subscriptions !== void 0 ? _this__subscriptions : []);
+                var nextSubscriptions = _to_consumable_array$6((_this__subscriptions = this._subscriptions) !== null && _this__subscriptions !== void 0 ? _this__subscriptions : []);
                 util.convertToArray(subs).forEach(function(sub) {
                     if (!nextSubscriptions.includes(sub)) {
                         nextSubscriptions.push(sub);
@@ -816,24 +848,23 @@ function _unsupported_iterable_to_array$9(o, minLen) {
             key: "initFilterTakesPriority",
             value: function initFilterTakesPriority() {
                 var _this = this;
-                if (!this._initialFilterSub.subscription) {
-                    this._initialFilterSub.subscription = this._initialFilterTakesPriority.pipe(rxjs.switchMap(function(clearFilterOnInitialFilterPush) {
-                        if (clearFilterOnInitialFilterPush) {
-                            return _this._initialFilter.pipe(rxjs.switchMap(function(x) {
-                                return x ? x : rxjs.EMPTY;
-                            }), filterMaybe(), rxjs.map(function() {
-                                return true;
-                            }), rxjs.skip(1) // skip the first emission
-                            );
-                        } else {
-                            return rxjs.EMPTY;
-                        }
-                    }), rxjs.defaultIfEmpty(false)).subscribe(function(clear) {
-                        if (clear) {
-                            _this.resetFilter();
-                        }
-                    });
-                }
+                var _this__initialFilterSub, _subscription;
+                (_subscription = (_this__initialFilterSub = this._initialFilterSub).subscription) !== null && _subscription !== void 0 ? _subscription : _this__initialFilterSub.subscription = this._initialFilterTakesPriority.pipe(rxjs.switchMap(function(clearFilterOnInitialFilterPush) {
+                    if (clearFilterOnInitialFilterPush) {
+                        return _this._initialFilter.pipe(rxjs.switchMap(function(x) {
+                            return x !== null && x !== void 0 ? x : rxjs.EMPTY;
+                        }), filterMaybe(), rxjs.map(function() {
+                            return true;
+                        }), rxjs.skip(1) // skip the first emission
+                        );
+                    } else {
+                        return rxjs.EMPTY;
+                    }
+                }), rxjs.defaultIfEmpty(false)).subscribe(function(clear) {
+                    if (clear) {
+                        _this.resetFilter();
+                    }
+                });
             }
         },
         {
@@ -858,7 +889,7 @@ function _array_like_to_array$8(arr, len) {
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
-function _array_without_holes$4(arr) {
+function _array_without_holes$5(arr) {
     if (Array.isArray(arr)) return _array_like_to_array$8(arr);
 }
 function _class_call_check$6(instance, Constructor) {
@@ -892,14 +923,14 @@ function _define_property$a(obj, key, value) {
     }
     return obj;
 }
-function _iterable_to_array$4(iter) {
+function _iterable_to_array$5(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
-function _non_iterable_spread$4() {
+function _non_iterable_spread$5() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _to_consumable_array$4(arr) {
-    return _array_without_holes$4(arr) || _iterable_to_array$4(arr) || _unsupported_iterable_to_array$8(arr) || _non_iterable_spread$4();
+function _to_consumable_array$5(arr) {
+    return _array_without_holes$5(arr) || _iterable_to_array$5(arr) || _unsupported_iterable_to_array$8(arr) || _non_iterable_spread$5();
 }
 function _unsupported_iterable_to_array$8(o, minLen) {
     if (!o) return;
@@ -1058,6 +1089,8 @@ function _unsupported_iterable_to_array$8(o, minLen) {
         {
             /**
      * Sets the default filter observable for this key.
+     *
+     * @param filterObs - the observable to use as the default filter for this key
      */ key: "initWithFilter",
             value: function initWithFilter(filterObs) {
                 this.dbxFilterMap.addDefaultFilterObs(this.key, filterObs);
@@ -1066,6 +1099,8 @@ function _unsupported_iterable_to_array$8(o, minLen) {
         {
             /**
      * Connects a filter source, adding its filter observable to this key's merged filters.
+     *
+     * @param filterSource - the filter source whose filter$ will be added to this key's merged stream
      */ key: "connectWithSource",
             value: function connectWithSource(filterSource) {
                 this.dbxFilterMap.addFilterObs(this.key, filterSource.filter$);
@@ -1083,7 +1118,7 @@ var FilterMapItem = /*#__PURE__*/ function() {
         _define_property$a(this, "_source", new FilterSourceInstance());
         _define_property$a(this, "_obs", new rxjs.BehaviorSubject([]));
         _define_property$a(this, "_obs$", this._obs.pipe(rxjs.switchMap(function(x) {
-            return rxjs.merge.apply(void 0, _to_consumable_array$4(x.map(function(y) {
+            return rxjs.merge.apply(void 0, _to_consumable_array$5(x.map(function(y) {
                 return y.obs;
             })));
         }), rxjs.distinctUntilChanged()));
@@ -1124,7 +1159,7 @@ var FilterMapItem = /*#__PURE__*/ function() {
                     var deleteOnComplete = obs.pipe(rxjs.finalize(function() {
                         _this._deleteFilterObs(i);
                     })).subscribe();
-                    var nextObs = _to_consumable_array$4(currentObs).concat([
+                    var nextObs = _to_consumable_array$5(currentObs).concat([
                         {
                             i: i,
                             obs: obs,
@@ -1531,17 +1566,17 @@ function _array_like_to_array$7(arr, len) {
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
     return arr2;
 }
-function _array_without_holes$3(arr) {
+function _array_without_holes$4(arr) {
     if (Array.isArray(arr)) return _array_like_to_array$7(arr);
 }
-function _iterable_to_array$3(iter) {
+function _iterable_to_array$4(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
 }
-function _non_iterable_spread$3() {
+function _non_iterable_spread$4() {
     throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
-function _to_consumable_array$3(arr) {
-    return _array_without_holes$3(arr) || _iterable_to_array$3(arr) || _unsupported_iterable_to_array$7(arr) || _non_iterable_spread$3();
+function _to_consumable_array$4(arr) {
+    return _array_without_holes$4(arr) || _iterable_to_array$4(arr) || _unsupported_iterable_to_array$7(arr) || _non_iterable_spread$4();
 }
 function _unsupported_iterable_to_array$7(o, minLen) {
     if (!o) return;
@@ -1567,7 +1602,7 @@ function scanIntoArray() {
     return rxjs.scan(function(acc, next) {
         if (next != null) {
             if (immutable) {
-                acc = acc.concat(next);
+                acc = _to_consumable_array$4(acc).concat(_to_consumable_array$4(util.asArray(next)));
             } else {
                 acc = util.pushItemOrArrayItemsIntoArray(acc, next);
             }
@@ -1597,7 +1632,7 @@ function scanIntoArray() {
             }
             return acc;
         }, seed !== null && seed !== void 0 ? seed : []), distinctUntilArrayLengthChanges(), rxjs.map(function(x) {
-            return _to_consumable_array$3(x);
+            return _to_consumable_array$4(x);
         }), rxjs.shareReplay(1));
     });
 }
@@ -1687,7 +1722,7 @@ function scanIntoArray() {
                 if (!acc.fromMatch || requireConsecutive) {
                     fromMatch = isMatch(from, next);
                     value = next;
-                } else if (!requireConsecutive) {
+                } else {
                     value = acc.value;
                 }
             }
@@ -1721,6 +1756,8 @@ function scanIntoArray() {
 }
 /**
  * RxJS operator that negates each emitted boolean value.
+ *
+ * @returns operator that maps each boolean emission to its negated value
  */ function isNot() {
     return rxjs.map(function(x) {
         return !x;
@@ -1728,6 +1765,8 @@ function scanIntoArray() {
 }
 /**
  * RxJS operator that only emits when a boolean stream transitions from `true` to `false`.
+ *
+ * @returns operator that filters to only true-to-false transition emissions
  */ function onTrueToFalse() {
     return onMatchDelta({
         from: true,
@@ -1737,6 +1776,8 @@ function scanIntoArray() {
 }
 /**
  * RxJS operator that only emits when a boolean stream transitions from `false` to `true`.
+ *
+ * @returns operator that filters to only false-to-true transition emissions
  */ function onFalseToTrue() {
     return onMatchDelta({
         from: false,
@@ -1755,6 +1796,7 @@ function scanIntoArray() {
  * @returns the inverted (or original) decision function
  */ function invertObservableDecision(decisionFn) {
     var invert = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
+    // eslint-disable-line @typescript-eslint/no-explicit-any
     if (invert) {
         return function(value) {
             var obs = decisionFn(value);
@@ -1809,7 +1851,7 @@ function scanIntoArray() {
  * time relative to the current moment.
  *
  * @param expiresIn - duration in milliseconds until expiration
- * @returns an operator that maps values to Expires objects
+ * @returns an `OperatorFunction` that maps each emission to an {@link Expires} object
  */ function toExpiration(expiresIn) {
     return rxjs.map(function() {
         var now = new Date();
@@ -1824,6 +1866,8 @@ function scanIntoArray() {
 }
 /**
  * RxJS operator that filters out emissions whose {@link Expires} value has already expired.
+ *
+ * @returns operator that only passes through non-expired emissions
  */ function skipExpired() {
     return rxjs.filter(function(expires) {
         return !util.expirationDetails({
@@ -1835,6 +1879,7 @@ function scanIntoArray() {
  * RxJS operator that skips emissions until the elapsed time since the emitted date/timestamp has exceeded `expiresIn`.
  *
  * @param expiresIn - duration in milliseconds
+ * @returns operator that skips emissions until the time window has elapsed
  */ function skipUntilExpiration(expiresIn) {
     return rxjs.filter(function(x) {
         return util.expirationDetails({
@@ -1847,6 +1892,7 @@ function scanIntoArray() {
  * RxJS operator that skips emissions after the elapsed time since the emitted date/timestamp has exceeded `expiresIn`.
  *
  * @param expiresIn - duration in milliseconds
+ * @returns operator that passes through emissions only within the time window
  */ function skipAfterExpiration(expiresIn) {
     return rxjs.filter(function(x) {
         return !util.expirationDetails({
@@ -1860,6 +1906,7 @@ function scanIntoArray() {
  *
  * @param watch - observable whose emissions reset the time window
  * @param takeFor - duration in milliseconds of each time window
+ * @returns operator that limits source emissions to the active time window after each watch emission
  */ function skipUntilTimeElapsedAfterLastEmission(watch, takeFor) {
     return function(observable) {
         return watch.pipe(rxjs.switchMap(function() {
@@ -1879,6 +1926,7 @@ function scanIntoArray() {
  *
  * @param watch - observable whose emissions reset the skip window
  * @param skipFor - duration in milliseconds to skip after each watch emission
+ * @returns an operator that delays passing values through until time has elapsed since the last watch emission
  */ function takeAfterTimeElapsedSinceLastEmission(watch, skipFor) {
     return function(observable) {
         return watch.pipe(rxjs.switchMap(function() {
@@ -2030,7 +2078,7 @@ var DEFAULT_FACTORY_TIMER_INTERVAL = 1000;
             return result;
         }), rxjs.finalize(function() {
             if (currentInstance) {
-                destroy(currentInstance);
+                void destroy(currentInstance);
             }
         }));
     };
@@ -2106,6 +2154,8 @@ function tapLog(messageOrFunction) {
 
 /**
  * `distinctUntilChanged` variant that only emits when the model's `id` property changes.
+ *
+ * @returns operator that suppresses consecutive emissions with the same model `id`
  */ function distinctUntilModelIdChange() {
     return distinctUntilObjectKeyChange(function(x) {
         return x.id;
@@ -2113,6 +2163,8 @@ function tapLog(messageOrFunction) {
 }
 /**
  * `distinctUntilChanged` variant that only emits when the model's `key` property changes.
+ *
+ * @returns operator that suppresses consecutive emissions with the same model `key`
  */ function distinctUntilModelKeyChange() {
     return distinctUntilObjectKeyChange(function(x) {
         return x.key;
@@ -2428,6 +2480,12 @@ function _array_like_to_array$5(arr, len) {
 function _array_with_holes$2(arr) {
     if (Array.isArray(arr)) return arr;
 }
+function _array_without_holes$3(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$5(arr);
+}
+function _iterable_to_array$3(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
 function _iterable_to_array_limit$2(arr, i) {
     var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
     if (_i == null) return;
@@ -2455,9 +2513,15 @@ function _iterable_to_array_limit$2(arr, i) {
 function _non_iterable_rest$2() {
     throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
+function _non_iterable_spread$3() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
 function _sliced_to_array$2(arr, i) {
     return _array_with_holes$2(arr) || _iterable_to_array_limit$2(arr, i) || _unsupported_iterable_to_array$5(arr, i) || _non_iterable_rest$2();
 }
+function _to_consumable_array$3(arr) {
+    return _array_without_holes$3(arr) || _iterable_to_array$3(arr) || _unsupported_iterable_to_array$5(arr) || _non_iterable_spread$3();
+}
 function _unsupported_iterable_to_array$5(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _array_like_to_array$5(o, minLen);
@@ -2475,7 +2539,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  */ function combineLatestFromMapValuesObsFn(mapToObs) {
     var combineArrayFn = combineLatestFromArrayObsFn(mapToObs);
     return function(latestMap) {
-        var mapValues = Array.from(latestMap).map(function(y) {
+        var mapValues = _to_consumable_array$3(latestMap).map(function(y) {
             return y[1];
         });
         return combineArrayFn(mapValues);
@@ -2525,7 +2589,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
         var result = {};
         latestValues.forEach(function(param) {
             var _param = _sliced_to_array$2(param, 2), key = _param[0], value = _param[1];
-            result[key] = value;
+            result[key] = value; // eslint-disable-line @typescript-eslint/no-explicit-any
         });
         return result;
     }));
@@ -2568,7 +2632,7 @@ function _unsupported_iterable_to_array$5(o, minLen) {
  */ function errorOnEmissionsInPeriod(config) {
     var _config_period = config.period, period = _config_period === void 0 ? 1000 : _config_period, maxEmissionsPerPeriod = config.maxEmissionsPerPeriod, onError = config.onError, inputErrorFactory = config.errorFactory, inputErrorMessage = config.errorMessage, switchToObs = config.switchToObs;
     var errorMessage = inputErrorMessage !== null && inputErrorMessage !== void 0 ? inputErrorMessage : 'errorOnEmissionsInPeriod(): Too many emissions in time period.';
-    var errorFactory = inputErrorFactory ? inputErrorFactory : !switchToObs ? function() {
+    var errorFactory = inputErrorFactory !== null && inputErrorFactory !== void 0 ? inputErrorFactory : !switchToObs ? function() {
         return new Error(errorMessage);
     } : undefined;
     return function(source) {
@@ -2628,6 +2692,8 @@ function _unsupported_iterable_to_array$5(o, minLen) {
 }
 /**
  * `distinctUntilChanged` variant for iterables that only emits when the contained values change.
+ *
+ * @returns operator that suppresses consecutive iterable emissions with the same set of values
  */ function distinctUntilHasDifferentValues() {
     return rxjs.distinctUntilChanged(util.hasSameValues);
 }
@@ -2875,16 +2941,17 @@ function _unsupported_iterable_to_array$4(o, minLen) {
  * @param state - the loading state to check (may be null/undefined)
  * @returns true if loading is complete
  */ function isLoadingStateFinishedLoading(state) {
+    var result = false;
     if (state) {
         var loading = state.loading;
         if (loading === true) {
-            return false;
+            result = false;
         } else {
-            return loading === false || Boolean(state.value || state.error) || state.value === null;
+            var _state_value;
+            result = loading === false || Boolean((_state_value = state.value) !== null && _state_value !== void 0 ? _state_value : state.error) || state.value === null;
         }
-    } else {
-        return false;
     }
+    return result;
 }
 /**
  * Creates an idle {@link LoadingState} with `loading: false` and no value or error.
@@ -2897,6 +2964,8 @@ function _unsupported_iterable_to_array$4(o, minLen) {
  * // { loading: false }
  * loadingStateType(state); // LoadingStateType.IDLE
  * ```
+ *
+ * @returns a loading state with `loading: false` and no value or error
  */ function idleLoadingState() {
     return {
         loading: false
@@ -3021,11 +3090,7 @@ function beginLoading(state) {
  */ function isLoadingStateWithStateType(type) {
     var defaultResult = type === exports.LoadingStateType.IDLE ? true : false;
     return function(state) {
-        if (state) {
-            return loadingStateType(state) === type;
-        } else {
-            return defaultResult;
-        }
+        return state ? loadingStateType(state) === type : defaultResult;
     };
 }
 /**
@@ -3068,11 +3133,7 @@ function beginLoading(state) {
  * @param state - the loading state to check
  * @returns true if the state has a defined (non-undefined) value
  */ function isLoadingStateWithDefinedValue(state) {
-    if (state) {
-        return state.value !== undefined;
-    } else {
-        return false;
-    }
+    return state ? state.value !== undefined : false;
 }
 /**
  * Type guard that checks whether a {@link LoadingState} has a non-null error, regardless of loading status.
@@ -3086,11 +3147,7 @@ function beginLoading(state) {
  * @param state - the loading state to check
  * @returns true if the state has an error
  */ function isLoadingStateWithError(state) {
-    if (state) {
-        return state.error != null;
-    } else {
-        return false;
-    }
+    return state ? state.error != null : false;
 }
 /**
  * Type guard that checks whether a {@link LoadingState} has finished loading and has a defined value.
@@ -3098,11 +3155,7 @@ function beginLoading(state) {
  * @param state - the loading state to check
  * @returns true if finished loading with a non-undefined value
  */ function isLoadingStateFinishedLoadingWithDefinedValue(state) {
-    if (state) {
-        return isLoadingStateFinishedLoading(state) && state.value !== undefined;
-    } else {
-        return false;
-    }
+    return state ? isLoadingStateFinishedLoading(state) && state.value !== undefined : false;
 }
 /**
  * Type guard that checks whether a {@link LoadingState} has finished loading and has an error.
@@ -3110,11 +3163,7 @@ function beginLoading(state) {
  * @param state - the loading state to check
  * @returns true if finished loading with an error
  */ function isLoadingStateFinishedLoadingWithError(state) {
-    if (state) {
-        return isLoadingStateFinishedLoading(state) && state.error != null;
-    } else {
-        return false;
-    }
+    return state ? isLoadingStateFinishedLoading(state) && state.error != null : false;
 }
 /**
  * Compares the metadata (page, loading, error) of two {@link PageLoadingState} instances for equivalence.
@@ -3145,15 +3194,16 @@ function mergeLoadingStates() {
         args[_key] = arguments[_key];
     }
     var _loadingStates_find;
-    var validArgs = util.filterMaybeArrayValues(args); // filter out any undefined values
+    // eslint-disable-line jsdoc/require-jsdoc -- JSDoc is on the overload signatures above
+    /* eslint-enable @typescript-eslint/max-params, @typescript-eslint/no-explicit-any */ var validArgs = util.filterMaybeArrayValues(args); // filter out any undefined values
     var lastValueIsMergeFn = typeof validArgs[validArgs.length - 1] === 'function';
-    var loadingStates = lastValueIsMergeFn ? validArgs.slice(0, validArgs.length - 1) : validArgs;
+    var loadingStates = lastValueIsMergeFn ? validArgs.slice(0, validArgs.length - 1) : validArgs; // eslint-disable-line @typescript-eslint/no-explicit-any
     var mergeFn = lastValueIsMergeFn ? args[validArgs.length - 1] : function() {
         for(var _len = arguments.length, inputArgs = new Array(_len), _key = 0; _key < _len; _key++){
             inputArgs[_key] = arguments[_key];
         }
         return util.mergeObjects(inputArgs);
-    };
+    }; // eslint-disable-line @typescript-eslint/no-explicit-any
     var error = (_loadingStates_find = loadingStates.find(function(x) {
         return x.error;
     })) === null || _loadingStates_find === void 0 ? void 0 : _loadingStates_find.error; // find the first error
@@ -3161,7 +3211,7 @@ function mergeLoadingStates() {
     if (error) {
         // ignore all loading states, except for any error-prone item that is still loading
         var currentLoadings = loadingStates.map(function(x) {
-            return (x === null || x === void 0 ? void 0 : x.error) ? x.loading : false;
+            return x.error ? x.loading : false;
         });
         var nonMaybeLoadings = currentLoadings.filter(function(x) {
             return x != null;
@@ -3247,10 +3297,10 @@ function mergeLoadingStates() {
     var mapValues = config.mapValues, mapState = config.mapState;
     var loading = isAnyLoadingStateInLoadingState(input);
     var error = input.map(function(x) {
-        return x === null || x === void 0 ? void 0 : x.error;
-    }).filter(function(x) {
+        return x.error;
+    }).find(function(x) {
         return Boolean(x);
-    })[0];
+    });
     var result;
     if (!error && !loading) {
         if (mapValues) {
@@ -3272,7 +3322,7 @@ function mergeLoadingStates() {
 }
 function mapLoadingStateResults(input, config) {
     var mapValue = config.mapValue, mapState = config.mapState, _config_alwaysMapValue = config.alwaysMapValue, alwaysMapValue = _config_alwaysMapValue === void 0 ? false : _config_alwaysMapValue;
-    var inputValue = input === null || input === void 0 ? void 0 : input.value;
+    var inputValue = input.value;
     var value;
     if ((inputValue != null || alwaysMapValue) && mapValue) {
         value = mapValue(inputValue, input);
@@ -3412,24 +3462,20 @@ function combineLoadingStates() {
     for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
         args[_key] = arguments[_key];
     }
-    var validArgs = util.filterMaybeArrayValues(args); // filter out any undefined values
+    // eslint-disable-line jsdoc/require-jsdoc -- JSDoc is on the overload signatures above
+    /* eslint-enable @typescript-eslint/max-params, @typescript-eslint/no-explicit-any */ var validArgs = util.filterMaybeArrayValues(args); // filter out any undefined values
     var lastValueIsMergeFn = typeof validArgs[validArgs.length - 1] === 'function';
-    var obsArgs = lastValueIsMergeFn ? validArgs.slice(0, validArgs.length - 1) : validArgs;
+    var obsArgs = lastValueIsMergeFn ? validArgs.slice(0, validArgs.length - 1) : validArgs; // eslint-disable-line @typescript-eslint/no-explicit-any
     var mergeFn = lastValueIsMergeFn ? validArgs[validArgs.length - 1] : undefined;
     return rxjs.combineLatest(obsArgs).pipe(rxjs.distinctUntilChanged(function(x, y) {
-        if (x && y) {
-            var hasSameValues = x.findIndex(function(_, i) {
-                return x[i] !== y[i];
-            }) === -1;
-            return hasSameValues;
-        } else {
-            return x === y;
-        }
+        return !x.some(function(_, i) {
+            return x[i] !== y[i];
+        });
     }), rxjs.map(function(states) {
-        var result = mergeLoadingStates.apply(void 0, _to_consumable_array$1(states).concat([
+        // eslint-disable-line @typescript-eslint/no-explicit-any
+        return mergeLoadingStates.apply(void 0, _to_consumable_array$1(states).concat([
             mergeFn
         ]));
-        return result;
     }), rxjs.shareReplay(1) // Share the result.
     );
 }
@@ -3456,6 +3502,7 @@ function combineLoadingStates() {
  * @param sources - An array of LoadingState observables to combine.
  * @returns An observable emitting a {@link LoadingState}<boolean> representing the combined status.
  */ function combineLoadingStatesStatus(sources) {
+    // eslint-disable-line @typescript-eslint/no-explicit-any
     return rxjs.combineLatest(sources).pipe(rxjs.map(function(allLoadingStates) {
         var firstErrorState = allLoadingStates.find(function(x) {
             return x.error;
@@ -3464,7 +3511,7 @@ function combineLoadingStates() {
         if (firstErrorState) {
             result = errorResult(firstErrorState.error);
         } else {
-            var oneOrMoreStatesAreCurrentlyLoading = allLoadingStates.findIndex(isLoadingStateLoading) !== -1;
+            var oneOrMoreStatesAreCurrentlyLoading = allLoadingStates.some(isLoadingStateLoading);
             if (oneOrMoreStatesAreCurrentlyLoading) {
                 result = beginLoading(); // still loading
             } else {
@@ -3592,7 +3639,7 @@ function tapOnLoadingStateType(fn, type) {
         };
     }
     return rxjs.tap(function(state) {
-        if (state != null && decisionFunction(state)) {
+        if (decisionFunction(state)) {
             fn(state);
         }
     });
@@ -3744,6 +3791,10 @@ function distinctLoadingState(inputConfig) {
  *
  * Determines the `loading` flag based on whether an error is present, whether the value is defined,
  * and the `showLoadingOnUndefinedValue` setting. Loading progress is only included while loading.
+ *
+ * @param state - the current loading state to convert into a context event
+ * @param input - configuration input controlling how the loading flag is derived
+ * @returns a loading state context event derived from the given state
  */ var DEFAULT_LOADING_EVENT_FOR_LOADING_PAIR_FUNCTION = function DEFAULT_LOADING_EVENT_FOR_LOADING_PAIR_FUNCTION(state, input) {
     var showLoadingOnUndefinedValue = input.showLoadingOnUndefinedValue;
     var error = state.error, value = state.value, loadingProgress = state.loadingProgress;
@@ -3814,7 +3865,7 @@ function distinctLoadingState(inputConfig) {
         return result;
     }), rxjs.distinctUntilChanged(isLoadingStateEqual), rxjs.shareReplay(1));
     var currentState$ = currentStateStream$.pipe(rxjs.switchMap(function(x) {
-        return x ? x : rxjs.of(undefined);
+        return x !== null && x !== void 0 ? x : rxjs.of(undefined);
     }));
     var state$ = currentState$.pipe(filterMaybe(), rxjs.shareReplay(1));
     var loading$ = eventStream$.pipe(rxjs.map(isLoadingStateLoading));
@@ -3858,7 +3909,8 @@ function distinctLoadingState(inputConfig) {
  * @param listLoadingState - the list loading state to check
  * @returns true if the value is empty or absent
  */ function isListLoadingStateWithEmptyValue(listLoadingState) {
-    return Boolean(!listLoadingState.value || !listLoadingState.value.length);
+    var _listLoadingState_value;
+    return Boolean(!((_listLoadingState_value = listLoadingState.value) === null || _listLoadingState_value === void 0 ? void 0 : _listLoadingState_value.length));
 }
 /**
  * RxJS operator that maps each emitted {@link ListLoadingState} to a boolean indicating whether the list is empty.
@@ -4140,6 +4192,8 @@ function _object_spread_props$3(target, source) {
         {
             /**
      * Whether the current state has a non-null error.
+     *
+     * @returns true if the current state contains an error
      */ key: "hasError",
             value: function hasError() {
                 return isLoadingStateWithError(this._subject.value);
@@ -4632,55 +4686,48 @@ function itemAccumulator(itemIteration, inputMapItem) {
             return rxjs.from(util.asPromise(countResults(allItems)));
         })).subscribe({
             next: function next(currentResultsCount) {
-                return _async_to_generator(function() {
-                    return _ts_generator(this, function(_state) {
-                        util.performTaskLoop({
-                            initValue: currentResultsCount,
-                            checkContinue: function checkContinue(x, i) {
-                                return _async_to_generator(function() {
-                                    var result;
-                                    return _ts_generator(this, function(_state) {
-                                        switch(_state.label){
-                                            case 0:
-                                                return [
-                                                    4,
-                                                    checkResultsLimit()
-                                                ];
-                                            case 1:
-                                                result = _state.sent();
-                                                currentResultsCount = result.currentCount;
-                                                return [
-                                                    2,
-                                                    result.shouldContinue
-                                                ];
-                                        }
-                                    });
-                                })();
-                            },
-                            next: function next() {
-                                return _async_to_generator(function() {
-                                    return _ts_generator(this, function(_state) {
+                util.performTaskLoop({
+                    initValue: currentResultsCount,
+                    checkContinue: function checkContinue(_x, _i) {
+                        return _async_to_generator(function() {
+                            var result;
+                            return _ts_generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        return [
+                                            4,
+                                            checkResultsLimit()
+                                        ];
+                                    case 1:
+                                        result = _state.sent();
+                                        currentResultsCount = result.currentCount;
                                         return [
                                             2,
-                                            accumulator.itemIteration.nextPage()
+                                            result.shouldContinue
                                         ];
-                                    });
-                                })();
-                            }
-                        }).then(function(page) {
-                            resolve({
-                                page: page,
-                                resultsCount: currentResultsCount
+                                }
                             });
-                        }).catch(function(error) {
-                            reject(error);
-                            throw error;
-                        });
-                        return [
-                            2
-                        ];
+                        })();
+                    },
+                    next: function next() {
+                        return _async_to_generator(function() {
+                            return _ts_generator(this, function(_state) {
+                                return [
+                                    2,
+                                    accumulator.itemIteration.nextPage()
+                                ];
+                            });
+                        })();
+                    }
+                }).then(function(page) {
+                    resolve({
+                        page: page,
+                        resultsCount: currentResultsCount
                     });
-                })();
+                }).catch(function(error) {
+                    reject(error);
+                    throw error;
+                });
             },
             error: function error(error) {
                 reject(error);
@@ -4747,7 +4794,7 @@ function _unsupported_iterable_to_array$1(o, minLen) {
     return accumulator.currentAllItemPairs$.pipe(scanBuildArray(function(allItems) {
         var pairs = allItems;
         var firstLatestItemPair = util.lastValue(allItems);
-        var skipValue = firstLatestItemPair === null || firstLatestItemPair === void 0 ? void 0 : firstLatestItemPair.input;
+        var skipValue = firstLatestItemPair === null || firstLatestItemPair === void 0 ? void 0 : firstLatestItemPair.input; // eslint-disable-line @typescript-eslint/no-unnecessary-condition -- lastValue() can return undefined at runtime for empty arrays
         var seed = util.flattenArray(pairs.map(function(x) {
             return x.output;
         }));
@@ -4814,6 +4861,7 @@ function _unsupported_iterable_to_array$1(o, minLen) {
  * @param pageItemAccumulator - accumulator to observe the current page from
  * @returns observable emitting the most recently loaded page number
  */ function pageItemAccumulatorCurrentPage(pageItemAccumulator) {
+    // eslint-disable-line @typescript-eslint/no-explicit-any
     return pageItemAccumulator.itemIteration.latestLoadedPage$;
 }
 
@@ -5179,11 +5227,10 @@ function _unsupported_iterable_to_array(o, minLen) {
                         hasNextPage: util.invertMaybeBoolean(end)
                     });
                 }
-                var result = {
+                return {
                     n: request.n,
                     state: state
                 };
-                return result;
             }));
         }), rxjs.scan(function(acc, x) {
             var n = x.n, curr = x.state;
@@ -5196,19 +5243,15 @@ function _unsupported_iterable_to_array(o, minLen) {
                 lastSuccessful: acc.lastSuccessful
             };
             // If it was a replay of the previous result, change nothing.
-            if (acc.current !== curr) {
-                if (isLoadingStateFinishedLoading(curr)) {
-                    // only set first finished once
-                    if (!next.firstFinished) {
-                        next.firstFinished = curr;
-                    }
-                    next.latestFinished = curr;
-                    if (!isLoadingStateWithError(curr)) {
-                        next.lastSuccessful = curr;
-                        if (!next.firstSuccessful) {
-                            next.firstSuccessful = curr;
-                        }
-                    }
+            if (acc.current !== curr && isLoadingStateFinishedLoading(curr)) {
+                var // only set first finished once
+                _next, _firstFinished;
+                (_firstFinished = (_next = next).firstFinished) !== null && _firstFinished !== void 0 ? _firstFinished : _next.firstFinished = curr;
+                next.latestFinished = curr;
+                if (!isLoadingStateWithError(curr)) {
+                    var _next1, _firstSuccessful;
+                    next.lastSuccessful = curr;
+                    (_firstSuccessful = (_next1 = next).firstSuccessful) !== null && _firstSuccessful !== void 0 ? _firstSuccessful : _next1.firstSuccessful = curr;
                 }
             }
             return next;
@@ -5517,6 +5560,10 @@ function _type_of(obj) {
  * Useful for deferring an action until all locks are released, with a safety timeout to avoid waiting indefinitely.
  *
  * @param config - configuration specifying the lock set, callback, timeout, and optional delay
+ * @param config.lockSet - the lock set to monitor for the next unlock event
+ * @param config.fn - optional callback to invoke when the lock set unlocks or the timeout is reached
+ * @param config.timeout - maximum time in milliseconds to wait before timing out
+ * @param config.delayTime - optional delay in milliseconds after unlock before invoking the callback
  * @returns subscription that can be unsubscribed to cancel the wait
  *
  * @example
@@ -5944,14 +5991,14 @@ function _define_property(obj, key, value) {
      *
      * If the loading state returns an error, the error is forwarded.
      *
-     * @param loadingStateObs
+     * @param loadingStateObs - observable of the loading state to track as the work result
      */ key: "startWorkingWithLoadingStateObservable",
             value: function startWorkingWithLoadingStateObservable(loadingStateObs) {
                 var _this = this;
                 var obs = preventComplete(loadingStateObs).pipe(filterMaybe(), rxjs.shareReplay(1));
                 this._sub.subscription = obs.pipe(rxjs.delay(0), rxjs.first()).subscribe(function() {
                     _this.startWorkingWithObservable(obs.pipe(rxjs.filter(function(x) {
-                        return x && !isLoadingStateLoading(x);
+                        return !isLoadingStateLoading(x);
                     }), rxjs.map(function(x) {
                         if (x.error) {
                             throw x.error;
@@ -5970,11 +6017,12 @@ function _define_property(obj, key, value) {
      *
      * It is used in conjunction with startWorking() and ideal for cases where multiple observables or promises are used.
      *
-     * @param loadingStateObs
+     * @param loadingStateObs - promise or observable of the loading state to track for errors
+     * @returns a promise that resolves with the value from the loading state or rejects on error
      */ key: "performTaskWithLoadingState",
             value: function performTaskWithLoadingState(loadingStateObs) {
                 var _this = this;
-                return promiseFromLoadingState(rxjs.from(loadingStateObs).pipe(filterMaybe(), rxjs.tap(function(x) {
+                return promiseFromLoadingState(rxjs.from(loadingStateObs).pipe(filterMaybe(), rxjs.tap(function(_x) {
                     _this._setWorking(true); // mark as working if not already marked.
                 }))).catch(function(e) {
                     // catch and throw any errors.
@@ -5989,7 +6037,7 @@ function _define_property(obj, key, value) {
      *
      * If an error is thrown, the error is forwarded to the reject function.
      *
-     * @param fn
+     * @param fn - synchronous function that returns the result value or throws an error
      */ key: "performTaskWithReturnValue",
             value: function performTaskWithReturnValue(fn) {
                 try {
@@ -6004,6 +6052,8 @@ function _define_property(obj, key, value) {
         {
             /**
      * Begins working using a promise.
+     *
+     * @param promise - the promise that represents the asynchronous work
      */ key: "startWorkingWithPromise",
             value: function startWorkingWithPromise(promise) {
                 this.startWorkingWithObservable(rxjs.from(promise));
@@ -6012,6 +6062,8 @@ function _define_property(obj, key, value) {
         {
             /**
      * Begins working using an observable.
+     *
+     * @param workObs - the observable that represents the asynchronous work and emits the result
      */ key: "startWorkingWithObservable",
             value: function startWorkingWithObservable(workObs) {
                 var _this = this;
@@ -6038,6 +6090,8 @@ function _define_property(obj, key, value) {
         {
             /**
      * Sets success on the work.
+     *
+     * @param result - the successful result value to pass to the delegate
      */ key: "success",
             value: function success(result) {
                 this._setComplete(successResult(result));
@@ -6047,6 +6101,8 @@ function _define_property(obj, key, value) {
         {
             /**
      * Sets rejected on the work.
+     *
+     * @param error - the error to pass to the delegate as the rejection reason
      */ key: "reject",
             value: function reject(error) {
                 this._setComplete(errorResult(error));
@@ -6108,6 +6164,8 @@ function _define_property(obj, key, value) {
  * ```
  *
  * @param config - work function and delegate configuration
+ * @param config.work - the work function to execute for each input value
+ * @param config.delegate - delegate that receives lifecycle callbacks (start, success, reject)
  * @returns a factory function that creates WorkInstance for each input
  */ function workFactory(param) {
     var work = param.work, delegate = param.delegate;
@@ -6121,13 +6179,11 @@ function _define_property(obj, key, value) {
             handler.reject(e);
             return;
         }
-        if (!handler.isComplete) {
-            if (fnResult && rxjs.isObservable(fnResult)) {
-                if (handler.hasStarted) {
-                    throw new Error('Work already marked as begun from returned result. Either return an observable or use the handler directly.');
-                }
-                handler.startWorkingWithObservable(fnResult);
+        if (!handler.isComplete && fnResult && rxjs.isObservable(fnResult)) {
+            if (handler.hasStarted) {
+                throw new Error('Work already marked as begun from returned result. Either return an observable or use the handler directly.');
             }
+            handler.startWorkingWithObservable(fnResult);
         }
         return handler;
     };