@dereekb/rxjs 10.1.30 → 11.0.0

package/index.esm.js

@@ -1,4 +1,4 @@
-import { isObservable, of, switchMap, map, filter, skipWhile, EMPTY, combineLatest, delay, startWith, distinctUntilChanged, mergeMap, BehaviorSubject, shareReplay, skip, first, merge, finalize, firstValueFrom, scan, exhaustMap, identity, throttleTime, timeout, tap, throwError, timer, takeWhile, delayWhen, asyncScheduler, from, catchError, defaultIfEmpty } from 'rxjs';
+import { isObservable, of, switchMap, map, filter, skipWhile, EMPTY, combineLatest, delay, startWith, distinctUntilChanged, mergeMap, BehaviorSubject, shareReplay, skip, first, merge, finalize, firstValueFrom, scan, exhaustMap, identity, throttleTime, timeout, tap, throwError, timer, takeWhile, delayWhen, asyncScheduler, from, combineLatestWith, catchError, defaultIfEmpty } from 'rxjs';
 import { getValueFromGetter, isMaybeSo, areEqualPOJOValues, convertToArray, asGetter, performTaskLoop, isMaybeNot, pushItemOrArrayItemsIntoArray, pushArrayItemsIntoArray, forEachWithArray, asArray, filterAndMapFunction, objectKeysEqualityComparatorFunction, objectKeyEqualityComparatorFunction, asPromise, randomNumberFactory, mapKeysIntersectionObjectToArray, mapsHaveSameKeys, incrementingNumberFactory, filterUniqueFunction, build, cachedGetter, allKeyValueTuples, keyValueMapFactory, multiKeyValueMapFactory, timePeriodCounter, setContainsAllValues, setContainsAnyValue, setContainsNoneOfValue, hasSameValues, compareEqualityWithValueFromItemsFunction, searchStringFilterFunction, objectHasKey, toReadableError, reduceBooleansWithOr, reduceBooleansWithAnd, valuesAreBothNullishOrEquivalent, filterMaybeValues, mergeObjects, safeCompareEquality, limitArray, hasNonNullValue, mapFunctionOutputPair, lastValue, flattenArray, filteredPage, FIRST_PAGE, hasValueOrNotEmpty, getNextPageNumber, reduceBooleansWithOrFn, MS_IN_SECOND } from '@dereekb/util';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -1803,7 +1803,9 @@ function emitAfterDelay(value, delayTime) {
 }
 
 /**
- * Equivalent to distinctUntilChanged() using isEqualObject()
+ * Equivalent to distinctUntilChanged() using areEqualPOJOValues().
+ *
+ * The compared objects should only be POJOs or compatable with the areEqualPOJOValues() function.
  */
 function distinctUntilObjectValuesChanged() {
   return distinctUntilChanged((a, b) => areEqualPOJOValues(a, b));
@@ -1811,6 +1813,8 @@ function distinctUntilObjectValuesChanged() {
 
 /**
  * Observable filter that filters the input if the object is unchanged/equal to the input.
+ *
+ * The compared objects should only be POJOs or compatable with the areEqualPOJOValues() function.
  */
 
 function filterIfObjectValuesUnchanged(input) {
@@ -2008,6 +2012,7 @@ class FilterMapKeyInstance {
   constructor(dbxFilterMap, key) {
     this.dbxFilterMap = dbxFilterMap;
     this.key = key;
+    this.filter$ = void 0;
     this.filter$ = this.dbxFilterMap.filterForKey(this.key);
   }
   initWithFilter(filterObs) {
@@ -4185,7 +4190,7 @@ function useFirst(obs, useFn) {
  */
 
 /**
- * Replaces the value type of the input loading state.
+ * Replaces the value type of the input LoadingState.
  */
 
 /**
@@ -4239,14 +4244,31 @@ let LoadingStateType = /*#__PURE__*/function (LoadingStateType) {
  * @returns
  */
 function loadingStateType(loadingState) {
-  if (loadingState.loading) {
-    return LoadingStateType.LOADING;
-  } else if (objectHasKey(loadingState, 'value')) {
-    return LoadingStateType.SUCCESS;
-  } else if (objectHasKey(loadingState, 'error')) {
-    return LoadingStateType.ERROR;
+  const isLoading = !isLoadingStateFinishedLoading(loadingState);
+  let type;
+  if (isLoading) {
+    type = LoadingStateType.LOADING;
+  } else {
+    if (objectHasKey(loadingState, 'value')) {
+      type = LoadingStateType.SUCCESS;
+    } else if (objectHasKey(loadingState, 'error')) {
+      type = LoadingStateType.ERROR;
+    } else {
+      type = LoadingStateType.IDLE;
+    }
+  }
+  return type;
+}
+function isLoadingStateFinishedLoading(state) {
+  if (state) {
+    const loading = state.loading;
+    if (loading === true) {
+      return false;
+    } else {
+      return loading === false || Boolean(state.value || state.error) || state.value === null;
+    }
   } else {
-    return LoadingStateType.IDLE;
+    return false;
   }
 }
 
@@ -4297,56 +4319,81 @@ function errorPageResult(page, error) {
     page
   });
 }
-function unknownLoadingStatesIsLoading(states) {
-  return reduceBooleansWithOr(states.map(loadingStateIsLoading), false);
-}
-function allLoadingStatesHaveFinishedLoading(states) {
-  return reduceBooleansWithAnd(states.map(loadingStateHasFinishedLoading), true);
-}
-function loadingStateIsIdle(state) {
-  if (state) {
-    return loadingStateType(state) === LoadingStateType.IDLE;
-  } else {
-    return true;
-  }
-}
-function loadingStateIsLoading(state) {
-  return !loadingStateHasFinishedLoading(state);
-}
-function isSuccessLoadingState(state) {
-  if (state) {
-    return loadingStateType(state) === LoadingStateType.SUCCESS;
-  } else {
-    return false;
-  }
+
+/**
+ * Returns true if any of the input LoadingStates return true for isLoadingStateLoading().
+ *
+ * @param states
+ * @returns
+ */
+function isAnyLoadingStateInLoadingState(states) {
+  return reduceBooleansWithOr(states.map(isLoadingStateLoading), false);
 }
-function isErrorLoadingState(state) {
-  if (state) {
-    return loadingStateType(state) === LoadingStateType.ERROR;
-  } else {
-    return false;
-  }
+
+/**
+ * Returns true if all input LoadingStates return true for isLoadingStateLoading().
+ *
+ * @param states
+ * @returns
+ */
+function areAllLoadingStatesFinishedLoading(states) {
+  return reduceBooleansWithAnd(states.map(isLoadingStateFinishedLoading), true);
 }
-function loadingStateHasFinishedLoading(state) {
-  if (state) {
-    const loading = state.loading;
-    if (loading === true) {
-      return false;
+function isLoadingStateWithStateType(type) {
+  const defaultResult = type === LoadingStateType.IDLE ? true : false;
+  return state => {
+    if (state) {
+      return loadingStateType(state) === type;
     } else {
-      return loading === false || Boolean(state.value || state.error) || state.value === null;
+      return defaultResult;
     }
-  } else {
-    return false;
-  }
+  };
 }
 
 /**
- * Whether or not the input loading state has a non-undefined value.
+ * Returns true if the input LoadingState passed to loadingStateType() returns IDLE.
+ *
+ * @param state
+ * @returns
+ */
+const isLoadingStateInIdleState = isLoadingStateWithStateType(LoadingStateType.IDLE);
+
+/**
+ * Returns true if the input LoadingState passed to loadingStateType() returns LOADING.
  *
  * @param state
  * @returns
  */
-function loadingStateHasValue(state) {
+const isLoadingStateLoading = isLoadingStateWithStateType(LoadingStateType.LOADING);
+
+/**
+ * Alias of isLoadingStateLoading.
+ */
+const isLoadingStateInLoadingState = isLoadingStateLoading;
+
+/**
+ * Returns true if the input LoadingState passed to loadingStateType() returns SUCCESS.
+ *
+ * @param state
+ * @returns
+ */
+const isLoadingStateInSuccessState = isLoadingStateWithStateType(LoadingStateType.SUCCESS);
+
+/**
+ * Returns true if the input LoadingState passed to loadingStateType() returns ERROR.
+ *
+ * @param state
+ * @returns
+ */
+const isLoadingStateInErrorState = isLoadingStateWithStateType(LoadingStateType.ERROR);
+
+/**
+ * Whether or not the input LoadingState has a non-undefined value.
+ *
+ * @param state
+ * @returns
+ */
+function isLoadingStateWithDefinedValue(state) {
   if (state) {
     return state.value !== undefined;
   } else {
@@ -4355,12 +4402,12 @@ function loadingStateHasValue(state) {
 }
 
 /**
- * Whether or not the input loading state has a non-null error.
+ * Whether or not the input LoadingState has a non-null error defined. It may be loading.
  *
  * @param state
  * @returns
  */
-function loadingStateHasError(state) {
+function isLoadingStateWithError(state) {
   if (state) {
     return state.error != null;
   } else {
@@ -4369,28 +4416,28 @@ function loadingStateHasError(state) {
 }
 
 /**
- * Whether or not the input loading state is not loading and has a non-null value.
+ * Whether or not the input LoadingState is not loading and has a non-null value.
  *
  * @param state
  * @returns
  */
-function loadingStateHasFinishedLoadingWithValue(state) {
+function isLoadingStateFinishedLoadingWithDefinedValue(state) {
   if (state) {
-    return loadingStateHasFinishedLoading(state) && state.value !== undefined;
+    return isLoadingStateFinishedLoading(state) && state.value !== undefined;
   } else {
     return false;
   }
 }
 
 /**
- * Whether or not the input loading state is not loading and has an error defined.
+ * Whether or not the input LoadingState is not loading and has an error defined.
  *
  * @param state
  * @returns
  */
-function loadingStateHasFinishedLoadingWithError(state) {
+function isLoadingStateFinishedLoadingWithError(state) {
   if (state) {
-    return loadingStateHasFinishedLoading(state) && state.error != null;
+    return isLoadingStateFinishedLoading(state) && state.error != null;
   } else {
     return false;
   }
@@ -4404,14 +4451,14 @@ function loadingStateHasFinishedLoadingWithError(state) {
  * @param a
  * @param b
  */
-function loadingStatesHaveEquivalentMetadata(a, b) {
+function isPageLoadingStateMetadataEqual(a, b) {
   return valuesAreBothNullishOrEquivalent(a.page, b.page) && a.loading == b.loading && valuesAreBothNullishOrEquivalent(a.error, b.error);
 }
 
-// TODO: Fix all LoadingState types to use the LoadingStateValue inference
+// TODO(BREAKING_CHANGE): Fix all LoadingState types to use the LoadingStateValue inference typings
 
 /**
- * Merges the input loading states.
+ * Merges the input LoadingStates.
  *
  * If one is unavailable, it is considered loading.
  * If one is loading, will return the loading state.
@@ -4437,7 +4484,7 @@ function mergeLoadingStates(...args) {
       error
     };
   } else {
-    const loading = reduceBooleansWithOr(loadingStates.map(loadingStateIsLoading));
+    const loading = reduceBooleansWithOr(loadingStates.map(isLoadingStateLoading));
     if (loading) {
       result = {
         loading: true
@@ -4455,9 +4502,9 @@ function mergeLoadingStates(...args) {
 }
 
 /**
- * Updates the input state to start loading.
+ * Returns a new merged state to be loading or idle, and clears the current/error value. It will have a LoadingStateType of LOADING if loading is true.
  */
-function updatedStateForSetLoading(state, loading = true) {
+function mergeLoadingStateWithLoading(state, loading = true) {
   return Object.assign({}, state, {
     value: undefined,
     loading,
@@ -4466,9 +4513,9 @@ function updatedStateForSetLoading(state, loading = true) {
 }
 
 /**
- * Updates the input state with the input error.
+ * Returns a new merged state with the input value. It will have a LoadingStateType of SUCCESS now.
  */
-function updatedStateForSetValue(state, value) {
+function mergeLoadingStateWithValue(state, value) {
   return Object.assign({}, state, {
     value: value != null ? value : undefined,
     loading: false,
@@ -4477,9 +4524,9 @@ function updatedStateForSetValue(state, value) {
 }
 
 /**
- * Updates the input state with the input error.
+ * Returns a new merged state with the input error. It will have a LoadingStateType of ERROR now.
  */
-function updatedStateForSetError(state, error) {
+function mergeLoadingStateWithError(state, error) {
   return Object.assign({}, state, {
     loading: false,
     error
@@ -4490,7 +4537,7 @@ function mapMultipleLoadingStateResults(input, config) {
     mapValues,
     mapState
   } = config;
-  const loading = unknownLoadingStatesIsLoading(input);
+  const loading = isAnyLoadingStateInLoadingState(input);
   const error = input.map(x => x == null ? void 0 : x.error).filter(x => Boolean(x))[0];
   let result;
   if (!error && !loading) {
@@ -4542,21 +4589,102 @@ function mapLoadingStateValueFunction(mapFn) {
   };
 }
 
+// MARK: Compat
+/**
+ * @deprecated use unknownLoadingStatesIsLoading instead.
+ */
+const unknownLoadingStatesIsLoading = isAnyLoadingStateInLoadingState;
+
+/**
+ * @deprecated use areAllLoadingStatesFinishedLoading instead.
+ */
+const allLoadingStatesHaveFinishedLoading = areAllLoadingStatesFinishedLoading;
+
+/**
+ * @deprecated use isLoadingStateInIdleState instead.
+ */
+const loadingStateIsIdle = isLoadingStateInIdleState;
+
+/**
+ * @deprecated use isLoadingStateInSuccessState instead.
+ */
+const isSuccessLoadingState = isLoadingStateInSuccessState;
+
+/**
+ * @deprecated use isLoadingStateInErrorState instead.
+ */
+const isErrorLoadingState = isLoadingStateInErrorState;
+
+/**
+ * @deprecated Use isLoadingStateLoading instead.
+ */
+const loadingStateIsLoading = isLoadingStateLoading;
+
+/**
+ * @deprecated use isLoadingStateFinishedLoading instead.
+ */
+const loadingStateHasFinishedLoading = isLoadingStateFinishedLoading;
+
+/**
+ * @deprecated use isLoadingStateWithError instead.
+ */
+const loadingStateHasError = isLoadingStateWithError;
+
+/**
+ * @deprecated use isLoadingStateWithDefinedValue instead.
+ */
+const loadingStateHasValue = isLoadingStateWithDefinedValue;
+
+/**
+ * @deprecated use isLoadingStateFinishedLoadingWithDefinedValue instead.
+ */
+const loadingStateHasFinishedLoadingWithValue = isLoadingStateFinishedLoadingWithDefinedValue;
+
+/**
+ * @deprecated use isLoadingStateFinishedLoadingWithError instead.
+ */
+const loadingStateHasFinishedLoadingWithError = isLoadingStateFinishedLoadingWithError;
+
+/**
+ * @deprecated use isPageLoadingStateMetadataEqual instead.
+ */
+const loadingStatesHaveEquivalentMetadata = isPageLoadingStateMetadataEqual;
+
+/**
+ * @deprecated use LoadingStateWithDefinedValue instead.
+ */
+
+/**
+ * @deprecated use mergeLoadingStateWithLoading instead.
+ */
+const updatedStateForSetLoading = mergeLoadingStateWithLoading;
+
+/**
+ * @deprecated use updatedStateForSetValue instead.
+ */
+const updatedStateForSetValue = mergeLoadingStateWithValue;
+
+/**
+ * @deprecated use mergeLoadingStateWithError instead.
+ */
+const updatedStateForSetError = mergeLoadingStateWithError;
+
 /**
  * Abstract LoadingContext implementation using LoadingState.
  */
 class AbstractLoadingStateContextInstance {
-  constructor(config) {
-    this._stateSubject$ = new BehaviorSubject(undefined);
-    this._config = void 0;
-    this.stateSubject$ = this._stateSubject$.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));
+  constructor(_config) {
+    this._stateSubject = new BehaviorSubject(undefined);
+    this._config = new BehaviorSubject(undefined);
+    this.config$ = this._config.pipe(filterMaybe(), shareReplay(1));
+    this.stateSubject$ = this._stateSubject.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));
     this.state$ = this.stateSubject$.pipe(switchMap(x => x), shareReplay(1));
-    this.stateObs$ = this._stateSubject$.asObservable();
-    this.stream$ = this._stateSubject$.pipe(mergeMap(obs => {
+    this.stateObs$ = this._stateSubject.asObservable();
+    this.stream$ = this.stateObs$.pipe(mergeMap(obs => {
       if (obs) {
         return obs.pipe(
         // If the observable did not pass a value immediately, we start with the start value.
-        timeoutStartWith(beginLoading()), map(x => this.loadingEventForLoadingPair(x, this._config)));
+        timeoutStartWith(beginLoading()), combineLatestWith(this.config$), map(([x, config]) => this.loadingEventForLoadingPair(x, config)));
       } else {
         return of(beginLoading());
       }
@@ -4566,30 +4694,35 @@ class AbstractLoadingStateContextInstance {
     /**
      * Emits when the input state has changed.
      */
-    this.stateChange$ = this._stateSubject$.pipe(map(() => undefined));
+    this.stateChange$ = this._stateSubject.pipe(map(() => undefined));
     this.loading$ = this.stream$.pipe(map(x => x.loading), shareReplay(1));
-    if (isObservable(config)) {
-      this._config = {
-        obs: config
+    let nextConfig;
+    if (isObservable(_config)) {
+      nextConfig = {
+        obs: _config
       };
     } else {
-      this._config = config != null ? config : {
+      nextConfig = _config != null ? _config : {
         showLoadingOnNoValue: false
       };
     }
-    if (this._config.obs) {
-      this.setStateObs(this._config.obs);
+    this._config.next(nextConfig);
+
+    // Only set once
+    if (nextConfig.obs) {
+      this.setStateObs(nextConfig.obs);
     }
   }
   setStateObs(state) {
-    this._stateSubject$.next(state);
+    this._stateSubject.next(state);
   }
   destroy() {
-    this._stateSubject$.complete();
+    this._stateSubject.complete();
+    this._config.complete();
   }
 }
 
-// TODO: Fix all LoadingState types to use the LoadingStateValue inference
+// TODO(BREAKING_CHANGE): Fix all LoadingState types to use the LoadingStateValue inference typings
 
 /**
  * Wraps an observable output and maps the value to a LoadingState.
@@ -4600,16 +4733,7 @@ function loadingStateFromObs(obs, firstOnly) {
   if (firstOnly) {
     obs = obs.pipe(first());
   }
-  return obs.pipe(map(value => ({
-    loading: false,
-    value,
-    error: undefined
-  })), catchError(error => of({
-    loading: false,
-    error
-  })), timeoutStartWith({
-    loading: true
-  }, 50), shareReplay(1));
+  return obs.pipe(map(value => successResult(value)), catchError(error => of(errorResult(error))), timeoutStartWith(beginLoading(), 50), shareReplay(1));
 }
 
 /**
@@ -4650,7 +4774,7 @@ function combineLoadingStatesStatus(sources) {
     if (firstErrorState) {
       result = errorResult(firstErrorState.error);
     } else {
-      const oneOrMoreStatesAreCurrentlyLoading = allLoadingStates.findIndex(loadingStateIsLoading) !== -1;
+      const oneOrMoreStatesAreCurrentlyLoading = allLoadingStates.findIndex(isLoadingStateLoading) !== -1;
       if (oneOrMoreStatesAreCurrentlyLoading) {
         result = beginLoading(); // still loading
       } else {
@@ -4678,7 +4802,7 @@ function startWithBeginLoading(state) {
  */
 function valueFromLoadingState() {
   return obs => {
-    return obs.pipe(filter(loadingStateHasValue), map(x => x.value));
+    return obs.pipe(filter(isLoadingStateWithDefinedValue), map(x => x.value));
   };
 }
 
@@ -4687,7 +4811,7 @@ function valueFromLoadingState() {
  */
 function errorFromLoadingState() {
   return obs => {
-    return obs.pipe(filter(loadingStateHasError), map(x => x.error));
+    return obs.pipe(filter(isLoadingStateWithError), map(x => x.error));
   };
 }
 
@@ -4696,7 +4820,7 @@ function errorFromLoadingState() {
  */
 function valueFromFinishedLoadingState() {
   return obs => {
-    return obs.pipe(filter(loadingStateHasFinishedLoading), map(x => x.value));
+    return obs.pipe(filter(isLoadingStateFinishedLoading), map(x => x.value));
   };
 }
 
@@ -4709,7 +4833,7 @@ function valueFromFinishedLoadingState() {
 function tapOnLoadingStateType(fn, type) {
   let decisionFunction;
   if (type === LoadingStateType.LOADING) {
-    decisionFunction = loadingStateIsLoading;
+    decisionFunction = isLoadingStateLoading;
   } else {
     decisionFunction = state => loadingStateType(state) === type;
   }
@@ -4746,7 +4870,7 @@ function mapLoadingStateValueWithOperator(operator, mapOnUndefined = false) {
   return obs => {
     return obs.pipe(switchMap(state => {
       let mappedObs;
-      if (loadingStateHasValue(state) || mapOnUndefined && loadingStateHasFinishedLoading(state) && !loadingStateHasError(state)) {
+      if (isLoadingStateWithDefinedValue(state) || mapOnUndefined && isLoadingStateFinishedLoading(state) && !isLoadingStateWithError(state)) {
         // map the value
         mappedObs = of(state.value).pipe(operator, map(value => Object.assign({}, state, {
           value
@@ -4758,7 +4882,7 @@ function mapLoadingStateValueWithOperator(operator, mapOnUndefined = false) {
         }), 0));
       } else {
         // only pass through if there is an error, otherwise show loading.
-        if (loadingStateHasError(state)) {
+        if (isLoadingStateWithError(state)) {
           mappedObs = of(Object.assign({}, state, {
             value: undefined
           }));
@@ -4795,14 +4919,14 @@ function distinctLoadingState(inputConfig) {
     valueComparator: inputConfig
   } : inputConfig;
   const passRetainedValue = inputPassRetainedValue != null ? inputPassRetainedValue : x => x !== null;
-  const metadataComparator = inputMetadataComparator != null ? inputMetadataComparator : loadingStatesHaveEquivalentMetadata;
+  const metadataComparator = inputMetadataComparator != null ? inputMetadataComparator : isPageLoadingStateMetadataEqual;
   return obs => {
     return obs.pipe(scan((acc, state) => {
       const nextValue = state.value;
 
       // determine the value change
       let isSameValue = false;
-      if (loadingStateHasValue(state) || compareOnUndefinedValue && loadingStateHasFinishedLoading(state) && !loadingStateHasError(state)) {
+      if (isLoadingStateWithDefinedValue(state) || compareOnUndefinedValue && isLoadingStateFinishedLoading(state) && !isLoadingStateWithError(state)) {
         // if the value is the same, then
         isSameValue = valueComparator(nextValue, acc.value);
       } else if (passRetainedValue(nextValue, acc.value, state, acc.previous)) {
@@ -4846,7 +4970,7 @@ function distinctLoadingState(inputConfig) {
  * @returns
  */
 function promiseFromLoadingState(obs) {
-  return firstValueFrom(obs.pipe(filter(loadingStateHasFinishedLoading))).then(x => {
+  return firstValueFrom(obs.pipe(filter(isLoadingStateFinishedLoading))).then(x => {
     let result;
     if (x.error) {
       throw x.error;
@@ -4857,19 +4981,23 @@ function promiseFromLoadingState(obs) {
   });
 }
 
-// TODO: breaking change refactor: Switch the names of these functions below, so the isListLoadingStateEmpty is the non-operator function.
-
 /**
  * Returns true if the loading state is not loading and is empty.
  *
  * @param listLoadingState
  * @returns
  */
-function listLoadingStateIsEmpty(listLoadingState) {
+function isListLoadingStateWithEmptyValue(listLoadingState) {
   return Boolean(!listLoadingState.value || !listLoadingState.value.length);
 }
-function isListLoadingStateEmpty() {
-  return map(listLoadingStateIsEmpty);
+
+/**
+ * Convenience function that merges map() with isListLoadingStateWithEmptyValue()
+ *
+ * @returns
+ */
+function mapIsListLoadingStateWithEmptyValue() {
+  return map(isListLoadingStateWithEmptyValue);
 }
 
 /**
@@ -4882,6 +5010,17 @@ function pageLoadingStateFromObs(obs, firstOnly, page = 0) {
   }));
 }
 
+// MARK: Compat
+/**
+ * @deprecated use isListLoadingStateWithEmptyValue instead.
+ */
+const listLoadingStateIsEmpty = isListLoadingStateWithEmptyValue;
+
+/**
+ * @deprecated use mapIsListLoadingStateWithEmptyValue instead.
+ */
+const isListLoadingStateEmpty = mapIsListLoadingStateWithEmptyValue;
+
 /**
  * LoadingContext implementation that uses a ListLoadingState observable.
  */
@@ -4898,7 +5037,7 @@ class ListLoadingStateContextInstance extends AbstractLoadingStateContextInstanc
     /**
      * Returns true while loading and the current value is considered empty.
      */
-    this.isEmptyLoading$ = this.stream$.pipe(map(x => loadingStateIsLoading(x) && listLoadingStateIsEmpty(x)), distinctUntilChanged(), shareReplay(1));
+    this.isEmptyLoading$ = this.stream$.pipe(map(x => isLoadingStateLoading(x) && isListLoadingStateWithEmptyValue(x)), distinctUntilChanged(), shareReplay(1));
     /**
      * Whether or not the current value is empty.
      *
@@ -4906,9 +5045,9 @@ class ListLoadingStateContextInstance extends AbstractLoadingStateContextInstanc
      *
      * After that, will return true if the value is empty even if loading a new value.
      */
-    this.isEmpty$ = this.stream$.pipe(skipWhile(x => loadingStateIsLoading(x)),
+    this.isEmpty$ = this.stream$.pipe(skipWhile(x => isLoadingStateLoading(x)),
     // skip until the first non-loading event has occured
-    isListLoadingStateEmpty(), distinctUntilChanged());
+    mapIsListLoadingStateWithEmptyValue(), distinctUntilChanged());
     /**
      * Whether or not the current value is empty and not loading.
      *
@@ -4916,9 +5055,9 @@ class ListLoadingStateContextInstance extends AbstractLoadingStateContextInstanc
      *
      * After that, will return true if the value is empty even if loading a new value.
      */
-    this.isEmptyAndNotLoading$ = this.stream$.pipe(skipWhile(x => loadingStateIsLoading(x)),
+    this.isEmptyAndNotLoading$ = this.stream$.pipe(skipWhile(x => isLoadingStateLoading(x)),
     // skip until the first non-loading event has occured
-    map(x => !loadingStateIsLoading(x) && listLoadingStateIsEmpty(x)), distinctUntilChanged());
+    map(x => !isLoadingStateLoading(x) && isListLoadingStateWithEmptyValue(x)), distinctUntilChanged());
   }
   loadingEventForLoadingPair(state, config = {}) {
     const {
@@ -4937,7 +5076,7 @@ class ListLoadingStateContextInstance extends AbstractLoadingStateContextInstanc
       if (showLoadingOnNoValue) {
         loading = !hasValue;
       } else {
-        loading = loadingStateIsLoading(state);
+        loading = isLoadingStateLoading(state);
       }
     }
     return {
@@ -4970,7 +5109,7 @@ class LoadingStateContextInstance extends AbstractLoadingStateContextInstance {
       if (showLoadingOnNoValue) {
         loading = !hasNonNullValue(value);
       } else {
-        loading = loadingStateIsLoading(pair);
+        loading = isLoadingStateLoading(pair);
       }
     }
     return {
@@ -5079,68 +5218,65 @@ class ValuesLoadingContext extends SimpleLoadingContext {
  */
 
 /**
- * ItemAccumulator implementation.
- */
-class ItemAccumulatorInstance {
-  constructor(itemIteration, mapItemFunction) {
-    this.itemIteration = itemIteration;
-    this.mapItemFunction = mapItemFunction;
-    this.hasCompletedInitialLoad$ = this.itemIteration.firstState$.pipe(map(() => true), startWith(false), distinctUntilChanged(), shareReplay(1));
-    this.latestSuccessfulState$ = this.itemIteration.latestState$.pipe(filter(x => !loadingStateHasError(x)), distinctUntilChanged(), shareReplay(1));
-    /**
-     * All successful page results in a single array.
-     */
-    this.allSuccessfulStates$ = this.latestSuccessfulState$.pipe(scanIntoArray({
-      immutable: false
-    }),
-    /**
-     * Don't wait for the first successful state in order to avoid never returning a value on immediate failures.
-     */
-    startWith([]), distinctUntilArrayLengthChanges(), shareReplay(1));
-    this.successfulLoadCount$ = this.allSuccessfulStates$.pipe(map(x => x.length), shareReplay(1));
-    // MARK: ItemAccumulator
-    this.currentAllItemPairs$ = this.allSuccessfulStates$.pipe(scanBuildArray(allSuccessfulStates => {
-      const mapStateToItem = mapFunctionOutputPair(mapLoadingStateValueFunction(this.mapItemFunction));
-
-      /* 
-      Start with allSuccessfulPageResults$ since it contains all page results since the start of the iterator,
-      and subscription to allItems may not have started at the same time.
-       We use scan to add in all models coming in afterwards by pushing them into the accumulator.
-      This is to prevent performance issues with very large iteration sets, since we can
-      append onto the array, rather than concat/copy the array each time.
-      */
-      const allPageResultsUpToFirstSubscription = allSuccessfulStates;
-      const firstLatestState = lastValue(allPageResultsUpToFirstSubscription);
-      const seed = allPageResultsUpToFirstSubscription.map(mapStateToItem).filter(x => isMaybeSo(x.output));
-      const accumulatorObs = this.latestSuccessfulState$.pipe(skipWhile(x => x === firstLatestState), map(mapStateToItem), filter(x => isMaybeSo(x.output)));
-      return {
-        seed,
-        accumulatorObs
-      };
-    }), shareReplay(1));
-    this.currentAllItems$ = this.currentAllItemPairs$.pipe(map(x => x.map(y => y.output)), shareReplay(1));
-    this.allItemPairs$ = this.hasCompletedInitialLoad$.pipe(switchMapWhileTrue(this.currentAllItemPairs$), shareReplay(1));
-    this.allItems$ = this.hasCompletedInitialLoad$.pipe(switchMapWhileTrue(this.currentAllItems$), shareReplay(1));
-    this._sub = new SubscriptionObject(this.allSuccessfulStates$.subscribe());
-  }
-  destroy() {
-    this._sub.destroy();
-  }
-}
-
-/**
- * Creates a new ItemAccumulator instance give the input ItemIteration.
+ * Creates a new ItemAccumulatorInstance give the input ItemIteration and optional map function.
  *
  * @param itemIteration
  * @param mapItem
  * @returns
  */
 
-function itemAccumulator(itemIteration, mapItem) {
-  if (!mapItem) {
-    mapItem = a => a;
-  }
-  return new ItemAccumulatorInstance(itemIteration, mapItem);
+function itemAccumulator(itemIteration, inputMapItem) {
+  const mapItemFunction = inputMapItem != null ? inputMapItem : a => a;
+  const hasCompletedInitialLoad$ = itemIteration.firstState$.pipe(map(() => true), startWith(false), distinctUntilChanged(), shareReplay(1));
+  const latestSuccessfulState$ = itemIteration.latestState$.pipe(filter(x => !isLoadingStateWithError(x)), distinctUntilChanged(), shareReplay(1));
+  const allSuccessfulStates$ = latestSuccessfulState$.pipe(scanIntoArray({
+    immutable: false
+  }),
+  /**
+   * Don't wait for the first successful state in order to avoid never returning a value on immediate failures.
+   */
+  startWith([]), distinctUntilArrayLengthChanges(), shareReplay(1));
+  const successfulLoadCount$ = allSuccessfulStates$.pipe(map(x => x.length), shareReplay(1));
+
+  // MARK: ItemAccumulator
+  const currentAllItemPairs$ = allSuccessfulStates$.pipe(scanBuildArray(allSuccessfulStates => {
+    const mapStateToItem = mapFunctionOutputPair(mapLoadingStateValueFunction(mapItemFunction));
+
+    /* 
+    Start with allSuccessfulPageResults$ since it contains all page results since the start of the iterator,
+    and subscription to allItems may not have started at the same time.
+     We use scan to add in all models coming in afterwards by pushing them into the accumulator.
+    This is to prevent performance issues with very large iteration sets, since we can
+    append onto the array, rather than concat/copy the array each time.
+    */
+    const allPageResultsUpToFirstSubscription = allSuccessfulStates;
+    const firstLatestState = lastValue(allPageResultsUpToFirstSubscription);
+    const seed = allPageResultsUpToFirstSubscription.map(mapStateToItem).filter(x => isMaybeSo(x.output));
+    const accumulatorObs = latestSuccessfulState$.pipe(skipWhile(x => x === firstLatestState), map(mapStateToItem), filter(x => isMaybeSo(x.output)));
+    return {
+      seed,
+      accumulatorObs
+    };
+  }), shareReplay(1));
+  const currentAllItems$ = currentAllItemPairs$.pipe(map(x => x.map(y => y.output)), shareReplay(1));
+  const allItemPairs$ = hasCompletedInitialLoad$.pipe(switchMapWhileTrue(currentAllItemPairs$), shareReplay(1));
+  const allItems$ = hasCompletedInitialLoad$.pipe(switchMapWhileTrue(currentAllItems$), shareReplay(1));
+  const sub = new SubscriptionObject(allSuccessfulStates$.subscribe());
+  const destroy = () => sub.destroy();
+  const result = {
+    itemIteration,
+    mapItemFunction,
+    hasCompletedInitialLoad$,
+    latestSuccessfulState$,
+    allSuccessfulStates$,
+    successfulLoadCount$,
+    currentAllItemPairs$,
+    currentAllItems$,
+    allItemPairs$,
+    allItems$,
+    destroy
+  };
+  return result;
 }
 
 // MARK: Utility
@@ -5263,6 +5399,11 @@ class MappedItemIterationInstance {
   constructor(itemIterator, config) {
     this.itemIterator = itemIterator;
     this.config = config;
+    this.hasNext$ = void 0;
+    this.canLoadMore$ = void 0;
+    this.firstState$ = void 0;
+    this.latestState$ = void 0;
+    this.currentState$ = void 0;
     this.hasNext$ = this.itemIterator.hasNext$;
     this.canLoadMore$ = this.itemIterator.canLoadMore$;
     this.firstState$ = this.itemIterator.firstState$.pipe(map(state => mapLoadingStateResults(state, this.config)), shareReplay(1));
@@ -5373,7 +5514,7 @@ class ItemPageIterationInstance {
     this._next = new BehaviorSubject({
       n: 0
     });
-    this._maxPageLoadLimit = new BehaviorSubject((_this$config$maxPageL = this.config.maxPageLoadLimit) != null ? _this$config$maxPageL : this.iterator.maxPageLoadLimit);
+    this._maxPageLoadLimit = new BehaviorSubject(undefined);
     // MARK: State
     this.state$ = this._next.pipe(delay(0), exhaustMap(request => combineLatest([this.hasNextAndCanLoadMore$, this._lastFinishedPageResultState$]).pipe(first(), map(([hasNextAndCanLoadMore, prevResult]) => [itemPageIteratorShouldLoadNextPage(request, hasNextAndCanLoadMore, prevResult), prevResult]), mergeMap(([shouldLoadNextPage, prevResult]) => {
       if (shouldLoadNextPage) {
@@ -5423,13 +5564,13 @@ class ItemPageIterationInstance {
 
       // If it was a replay of the previous result, change nothing.
       if (acc.current !== curr) {
-        if (loadingStateHasFinishedLoading(curr)) {
+        if (isLoadingStateFinishedLoading(curr)) {
           // only set first finished once
           if (!next.firstFinished) {
             next.firstFinished = curr;
           }
           next.latestFinished = curr;
-          if (!loadingStateHasError(curr)) {
+          if (!isLoadingStateWithError(curr)) {
             next.lastSuccessful = curr;
             if (!next.firstSuccessful) {
               next.firstSuccessful = curr;
@@ -5459,7 +5600,7 @@ class ItemPageIterationInstance {
     /**
      * Same as _nextTrigger$, but catches finished loading events.
      */
-    this._nextFinished$ = this._nextTrigger$.pipe(filter(x => loadingStateHasFinishedLoading(x.current)));
+    this._nextFinished$ = this._nextTrigger$.pipe(filter(x => isLoadingStateFinishedLoading(x.current)));
     /**
      * The first page results that finished loading.
      */
@@ -5486,7 +5627,7 @@ class ItemPageIterationInstance {
     /**
      * Whether or not items are currently being loaded.
      */
-    this.isLoading$ = this._currentPageResultState$.pipe(map(x => loadingStateIsLoading(x)), distinctUntilChanged(), shareReplay(1));
+    this.isLoading$ = this._currentPageResultState$.pipe(map(x => isLoadingStateLoading(x)), distinctUntilChanged(), shareReplay(1));
     this._lastFinishedPageResultState$ = this.latestPageResultState$.pipe(startWith(undefined), shareReplay(1));
     this._lastFinishedPageResult$ = this._lastFinishedPageResultState$.pipe(map(x => x == null ? void 0 : x.value));
     this._lastFinishedPageResultItem$ = this._lastFinishedPageResult$.pipe(map(x => x == null ? void 0 : x.value));
@@ -5517,6 +5658,7 @@ class ItemPageIterationInstance {
     this.firstState$ = this.firstPageResultState$.pipe(mapItemPageLoadingStateFromResultPageLoadingState(), shareReplay(1));
     this.latestState$ = this.latestPageResultState$.pipe(mapItemPageLoadingStateFromResultPageLoadingState(), shareReplay(1));
     this.latestItems$ = this.latestState$.pipe(distinctUntilChanged(), map(x => x.value), shareReplay(1));
+    this._maxPageLoadLimit.next((_this$config$maxPageL = this.config.maxPageLoadLimit) != null ? _this$config$maxPageL : this.iterator.maxPageLoadLimit);
   }
   // MARK: PageItemIteration
   get maxPageLoadLimit() {
@@ -5587,13 +5729,13 @@ function isItemPageIteratorResultEndResult(result) {
 function itemPageIteratorShouldLoadNextPage(request, hasNextAndCanLoadMore, prevResult) {
   return hasNextAndCanLoadMore &&
   // Must be able to load more
-  Boolean(!loadingStateHasError(prevResult) || request.retry) &&
+  Boolean(!isLoadingStateWithError(prevResult) || request.retry) &&
   // Must not have any errors
   Boolean(request.page == null || nextIteratorPageNumber(prevResult) === request.page); // Must match the page, if provided
 }
 
 function nextIteratorPageNumber(prevResult) {
-  return loadingStateHasError(prevResult) ? prevResult.page : getNextPageNumber(prevResult);
+  return isLoadingStateWithError(prevResult) ? prevResult.page : getNextPageNumber(prevResult);
 }
 function mapItemPageLoadingStateFromResultPageLoadingState() {
   return map(itemPageLoadingStateFromResultPageLoadingState);
@@ -5765,7 +5907,7 @@ class WorkInstance {
     this._sub = new SubscriptionObject();
     this.loadingState$ = this._loadingState.pipe(filterMaybe());
     this._hasStarted$ = this._loadingState.pipe(map(x => Boolean(x)), shareReplay(1));
-    this._isComplete$ = this.loadingState$.pipe(map(x => loadingStateHasFinishedLoading(x)), shareReplay(1));
+    this._isComplete$ = this.loadingState$.pipe(map(x => isLoadingStateFinishedLoading(x)), shareReplay(1));
     // Schedule to cleanup self once isComplete is true.
     this.result$.subscribe(loadingState => {
       this._result = loadingState;
@@ -5779,7 +5921,7 @@ class WorkInstance {
     return this._done ? of(this._doneActionBegan) : this._hasStarted$;
   }
   get isComplete() {
-    return this._done || loadingStateHasFinishedLoading(this._loadingState.value);
+    return this._done || isLoadingStateFinishedLoading(this._loadingState.value);
   }
   get isComplete$() {
     return this._done ? of(true) : this._isComplete$;
@@ -5803,7 +5945,7 @@ class WorkInstance {
     this._sub.subscription = obs.pipe(delay(0),
     // delay to prevent an immediate start working, which can override the _sub.subscription value
     first()).subscribe(() => {
-      this.startWorkingWithObservable(obs.pipe(filter(x => x && !loadingStateIsLoading(x)),
+      this.startWorkingWithObservable(obs.pipe(filter(x => x && !isLoadingStateLoading(x)),
       // don't return until it has finished loading.
       map(x => {
         if (x.error) {
@@ -5979,4 +6121,4 @@ function workFactoryForConfigFactory(configFactory) {
   };
 }
 
-export { AbstractLoadingStateContextInstance, DEFAULT_ASYNC_PUSHER_THROTTLE, DEFAULT_FACTORY_TIMER_INTERVAL, DEFAULT_ITEM_PAGE_ITERATOR_MAX, DEFAULT_LOCK_SET_TIME_LOCK_KEY, FilterMap, FilterMapKeyInstance, FilterSource, FilterSourceConnector, FilterSourceInstance, ItemAccumulatorInstance, ItemPageIterationInstance, ItemPageIterator, ListLoadingStateContextInstance, LoadingStateContextInstance, LoadingStateType, LockSet, MappedItemIterationInstance, MappedPageItemIterationInstance, MultiSubscriptionObject, PresetFilterSource, SimpleLoadingContext, SubscriptionObject, ValuesLoadingContext, WorkInstance, accumulatorCurrentPageListLoadingState, accumulatorFlattenPageListLoadingState, allLoadingStatesHaveFinishedLoading, asObservable, asObservableFromGetter, asyncPusher, asyncPusherCache, beginLoading, beginLoadingPage, checkIs, cleanup, cleanupDestroyable, combineLatestFromArrayObsFn, combineLatestFromMapValuesObsFn, combineLatestFromObject, combineLatestMapFrom, combineLoadingStates, combineLoadingStatesStatus, distinctLoadingState, distinctUntilArrayLengthChanges, distinctUntilHasDifferentValues, distinctUntilItemsHaveDifferentValues, distinctUntilItemsValueChanges, distinctUntilKeysChange, distinctUntilMapHasDifferentKeys, distinctUntilModelIdChange, distinctUntilModelKeyChange, distinctUntilObjectKeyChange, distinctUntilObjectValuesChanged, emitAfterDelay, emitDelayObs, errorFromLoadingState, errorOnEmissionsInPeriod, errorPageResult, errorResult, factoryTimer, filterIfObjectValuesUnchanged, filterItemsWithObservableDecision, filterMaybe, filterUnique, filterWithSearchString, flattenAccumulatorResultItemArray, idleLoadingState, incrementingNumberTimer, initialize, invertObservableDecision, isErrorLoadingState, isItemPageIteratorResultEndResult, isListLoadingStateEmpty, isLoading, isNot, isSuccessLoadingState, itemAccumulator, itemAccumulatorNextPageUntilResultsCount, iterationHasNextAndCanLoadMore, iteratorNextPageUntilMaxPageLoadLimit, iteratorNextPageUntilPage, keyValueMap, lazyFrom, listLoadingStateContext, listLoadingStateIsEmpty, loadingStateContext, loadingStateFromObs, loadingStateHasError, loadingStateHasFinishedLoading, loadingStateHasFinishedLoadingWithError, loadingStateHasFinishedLoadingWithValue, loadingStateHasValue, loadingStateIsIdle, loadingStateIsLoading, loadingStateType, loadingStatesHaveEquivalentMetadata, makeCheckIsFunction, makeMapFilterWithPresetFn, makeReturnIfIsFunction, mapEachAsync, mapFilterWithPreset, mapForEach, mapIf, mapItemIteration, mapKeysIntersectionToArray, mapLoadingState, mapLoadingStateResults, mapLoadingStateValueFunction, mapLoadingStateValueWithOperator, mapMaybe, mapMultipleLoadingStateResults, mapPageItemIteration, maybeValueFromObservableOrValueGetter, mergeLoadingStates, multiKeyValueMap, onFalseToTrue, onLockSetNextUnlock, onMatchDelta, onTrueToFalse, pageItemAccumulatorCurrentPage, pageLoadingStateFromObs, pipeIf, preventComplete, promiseFromLoadingState, randomDelay, randomDelayWithRandomFunction, returnIfIs, scanBuildArray, scanCount, scanIntoArray, setContainsAllValuesFrom, setContainsAnyValueFrom, setContainsNoValueFrom, skipFirstMaybe, startWithBeginLoading, successPageResult, successResult, switchMapMaybeDefault, switchMapMaybeObs, switchMapObject, switchMapOnBoolean, switchMapToDefault, switchMapWhileFalse, switchMapWhileTrue, tapAfterTimeout, tapFirst, tapLog, tapOnLoadingStateSuccess, tapOnLoadingStateType, throwErrorAfterTimeout, timeoutStartWith, unknownLoadingStatesIsLoading, updatedStateForSetError, updatedStateForSetLoading, updatedStateForSetValue, useAsObservable, useFirst, valueFromFinishedLoadingState, valueFromLoadingState, valueFromObservableOrValue, valueFromObservableOrValueGetter, workFactory, workFactoryForConfigFactory };
+export { AbstractLoadingStateContextInstance, DEFAULT_ASYNC_PUSHER_THROTTLE, DEFAULT_FACTORY_TIMER_INTERVAL, DEFAULT_ITEM_PAGE_ITERATOR_MAX, DEFAULT_LOCK_SET_TIME_LOCK_KEY, FilterMap, FilterMapKeyInstance, FilterSource, FilterSourceConnector, FilterSourceInstance, ItemPageIterationInstance, ItemPageIterator, ListLoadingStateContextInstance, LoadingStateContextInstance, LoadingStateType, LockSet, MappedItemIterationInstance, MappedPageItemIterationInstance, MultiSubscriptionObject, PresetFilterSource, SimpleLoadingContext, SubscriptionObject, ValuesLoadingContext, WorkInstance, accumulatorCurrentPageListLoadingState, accumulatorFlattenPageListLoadingState, allLoadingStatesHaveFinishedLoading, areAllLoadingStatesFinishedLoading, asObservable, asObservableFromGetter, asyncPusher, asyncPusherCache, beginLoading, beginLoadingPage, checkIs, cleanup, cleanupDestroyable, combineLatestFromArrayObsFn, combineLatestFromMapValuesObsFn, combineLatestFromObject, combineLatestMapFrom, combineLoadingStates, combineLoadingStatesStatus, distinctLoadingState, distinctUntilArrayLengthChanges, distinctUntilHasDifferentValues, distinctUntilItemsHaveDifferentValues, distinctUntilItemsValueChanges, distinctUntilKeysChange, distinctUntilMapHasDifferentKeys, distinctUntilModelIdChange, distinctUntilModelKeyChange, distinctUntilObjectKeyChange, distinctUntilObjectValuesChanged, emitAfterDelay, emitDelayObs, errorFromLoadingState, errorOnEmissionsInPeriod, errorPageResult, errorResult, factoryTimer, filterIfObjectValuesUnchanged, filterItemsWithObservableDecision, filterMaybe, filterUnique, filterWithSearchString, flattenAccumulatorResultItemArray, idleLoadingState, incrementingNumberTimer, initialize, invertObservableDecision, isAnyLoadingStateInLoadingState, isErrorLoadingState, isItemPageIteratorResultEndResult, isListLoadingStateEmpty, isListLoadingStateWithEmptyValue, isLoading, isLoadingStateFinishedLoading, isLoadingStateFinishedLoadingWithDefinedValue, isLoadingStateFinishedLoadingWithError, isLoadingStateInErrorState, isLoadingStateInIdleState, isLoadingStateInLoadingState, isLoadingStateInSuccessState, isLoadingStateLoading, isLoadingStateWithDefinedValue, isLoadingStateWithError, isLoadingStateWithStateType, isNot, isPageLoadingStateMetadataEqual, isSuccessLoadingState, itemAccumulator, itemAccumulatorNextPageUntilResultsCount, iterationHasNextAndCanLoadMore, iteratorNextPageUntilMaxPageLoadLimit, iteratorNextPageUntilPage, keyValueMap, lazyFrom, listLoadingStateContext, listLoadingStateIsEmpty, loadingStateContext, loadingStateFromObs, loadingStateHasError, loadingStateHasFinishedLoading, loadingStateHasFinishedLoadingWithError, loadingStateHasFinishedLoadingWithValue, loadingStateHasValue, loadingStateIsIdle, loadingStateIsLoading, loadingStateType, loadingStatesHaveEquivalentMetadata, makeCheckIsFunction, makeMapFilterWithPresetFn, makeReturnIfIsFunction, mapEachAsync, mapFilterWithPreset, mapForEach, mapIf, mapIsListLoadingStateWithEmptyValue, mapItemIteration, mapKeysIntersectionToArray, mapLoadingState, mapLoadingStateResults, mapLoadingStateValueFunction, mapLoadingStateValueWithOperator, mapMaybe, mapMultipleLoadingStateResults, mapPageItemIteration, maybeValueFromObservableOrValueGetter, mergeLoadingStateWithError, mergeLoadingStateWithLoading, mergeLoadingStateWithValue, mergeLoadingStates, multiKeyValueMap, onFalseToTrue, onLockSetNextUnlock, onMatchDelta, onTrueToFalse, pageItemAccumulatorCurrentPage, pageLoadingStateFromObs, pipeIf, preventComplete, promiseFromLoadingState, randomDelay, randomDelayWithRandomFunction, returnIfIs, scanBuildArray, scanCount, scanIntoArray, setContainsAllValuesFrom, setContainsAnyValueFrom, setContainsNoValueFrom, skipFirstMaybe, startWithBeginLoading, successPageResult, successResult, switchMapMaybeDefault, switchMapMaybeObs, switchMapObject, switchMapOnBoolean, switchMapToDefault, switchMapWhileFalse, switchMapWhileTrue, tapAfterTimeout, tapFirst, tapLog, tapOnLoadingStateSuccess, tapOnLoadingStateType, throwErrorAfterTimeout, timeoutStartWith, unknownLoadingStatesIsLoading, updatedStateForSetError, updatedStateForSetLoading, updatedStateForSetValue, useAsObservable, useFirst, valueFromFinishedLoadingState, valueFromLoadingState, valueFromObservableOrValue, valueFromObservableOrValueGetter, workFactory, workFactoryForConfigFactory };