@dereekb/rxjs 10.1.30 → 11.0.0

package/index.cjs.js

@@ -1729,7 +1729,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 rxjs.distinctUntilChanged((a, b) => util.areEqualPOJOValues(a, b));
@@ -1749,6 +1751,7 @@ function filterIfObjectValuesUnchanged(input) {
  */
 class SubscriptionObject {
   constructor(sub) {
+    this._subscription = void 0;
     if (sub) {
       this.setSub(sub);
     }
@@ -1780,13 +1783,14 @@ class SubscriptionObject {
  */
 class MultiSubscriptionObject {
   constructor(subs) {
+    this._subscriptions = void 0;
     if (subs) {
       this.setSubs(subs);
     }
   }
   get hasSubscription() {
-    var _a;
-    return Boolean((_a = this._subscriptions) === null || _a === void 0 ? void 0 : _a.length);
+    var _this$_subscriptions;
+    return Boolean((_this$_subscriptions = this._subscriptions) == null ? void 0 : _this$_subscriptions.length);
   }
   set subscriptions(subs) {
     this.setSubs(subs);
@@ -1817,7 +1821,7 @@ class FilterSourceInstance {
     this._initialFilter = new rxjs.BehaviorSubject(undefined);
     this._defaultFilter = new rxjs.BehaviorSubject(undefined);
     this.defaultFilter$ = this._defaultFilter.pipe(switchMapMaybeObs());
-    this.initialFilter$ = rxjs.combineLatest([this._initialFilter, this._defaultFilter]).pipe(rxjs.map(([a, b]) => a !== null && a !== void 0 ? a : b), switchMapMaybeObs(), rxjs.distinctUntilChanged(), rxjs.shareReplay(1));
+    this.initialFilter$ = rxjs.combineLatest([this._initialFilter, this._defaultFilter]).pipe(rxjs.map(([a, b]) => a != null ? a : b), switchMapMaybeObs(), rxjs.distinctUntilChanged(), rxjs.shareReplay(1));
     /**
      * filter$ uses the latest value from any filter.
      */
@@ -1914,6 +1918,9 @@ class FilterMap {
 }
 class FilterMapKeyInstance {
   constructor(dbxFilterMap, key) {
+    this.dbxFilterMap = void 0;
+    this.key = void 0;
+    this.filter$ = void 0;
     this.dbxFilterMap = dbxFilterMap;
     this.key = key;
     this.filter$ = this.dbxFilterMap.filterForKey(this.key);
@@ -1927,13 +1934,15 @@ class FilterMapKeyInstance {
 }
 class FilterMapItem {
   constructor(dbxFilterMap, key) {
-    this.dbxFilterMap = dbxFilterMap;
-    this.key = key;
+    this.dbxFilterMap = void 0;
+    this.key = void 0;
     this._i = 0;
     this._source = new FilterSourceInstance();
     this._obs = new rxjs.BehaviorSubject([]);
     this.obs$ = this._obs.pipe(rxjs.switchMap(x => rxjs.merge(...x.map(y => y.obs))), rxjs.distinctUntilChanged());
     this.filter$ = this._source.initialFilter$;
+    this.dbxFilterMap = dbxFilterMap;
+    this.key = key;
   }
   setDefaultFilterObs(obs) {
     this._source.setDefaultFilter(obs);
@@ -3151,42 +3160,35 @@ $$1({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
   }
 });
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 /**
  * Creates an observable from the input iteration that checks both the hasNext$ and canLoadMore$ states.
  *
  * @param iteration
  * @returns
  */
+
+function _async$2(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+} /**
+   * Automatically calls next up to the current maxPageLoadLimit configured on the iterator.
+   *
+   * If no maximum limit is defined, uses the defaultLimit. If default limit is not defined or null, this will result in an error.
+   *
+   * The promise will reject with an error if an error is encountered.
+   *
+   * @param iterator
+   * @param defaultLimit
+   * @returns
+   */
 function iterationHasNextAndCanLoadMore(iteration) {
   return iteration.canLoadMore$.pipe(rxjs.switchMap(canLoadMore => {
     if (canLoadMore) {
@@ -3196,21 +3198,10 @@ function iterationHasNextAndCanLoadMore(iteration) {
     }
   }), rxjs.shareReplay(1));
 }
-/**
- * Automatically calls next up to the current maxPageLoadLimit configured on the iterator.
- *
- * If no maximum limit is defined, uses the defaultLimit. If default limit is not defined or null, this will result in an error.
- *
- * The promise will reject with an error if an error is encountered.
- *
- * @param iterator
- * @param defaultLimit
- * @returns
- */
 function iteratorNextPageUntilMaxPageLoadLimit(iterator, defaultLimit = 100) {
   return iteratorNextPageUntilPage(iterator, () => {
-    var _a;
-    const limit = (_a = iterator.maxPageLoadLimit) !== null && _a !== void 0 ? _a : defaultLimit;
+    var _iterator$maxPageLoad;
+    const limit = (_iterator$maxPageLoad = iterator.maxPageLoadLimit) != null ? _iterator$maxPageLoad : defaultLimit;
     if (util.isMaybeNot(limit)) {
       throw new Error('iteratorNextPageUntilMaxPageLoadLimit() failed. There was no maximum defined.');
     }
@@ -3229,9 +3220,9 @@ function iteratorNextPageUntilMaxPageLoadLimit(iterator, defaultLimit = 100) {
 function iteratorNextPageUntilPage(iteration, page) {
   const getPageLimit = util.asGetter(page);
   function checkPageLimit(page) {
-    var _a;
+    var _iteration$maxPageLoa;
     const pageLimit = getPageLimit();
-    const maxLimit = Math.min(pageLimit, (_a = iteration.maxPageLoadLimit) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER);
+    const maxLimit = Math.min(pageLimit, (_iteration$maxPageLoa = iteration.maxPageLoadLimit) != null ? _iteration$maxPageLoa : Number.MAX_SAFE_INTEGER);
     return page + 1 < maxLimit;
   }
   return new Promise((resolve, reject) => {
@@ -3239,11 +3230,11 @@ function iteratorNextPageUntilPage(iteration, page) {
       next: firstLatestPage => {
         const promise = util.performTaskLoop({
           initValue: firstLatestPage,
-          checkContinue: latestPage => __awaiter(this, void 0, void 0, function* () {
+          checkContinue: _async$2(function (latestPage) {
             return rxjs.firstValueFrom(iterationHasNextAndCanLoadMore(iteration)).then(canLoadMore => canLoadMore && checkPageLimit(latestPage));
           }),
-          next: () => __awaiter(this, void 0, void 0, function* () {
-            return yield iteration.nextPage();
+          next: _async$2(function () {
+            return iteration.nextPage();
           })
         });
         resolve(promise);
@@ -3256,7 +3247,7 @@ function iteratorNextPageUntilPage(iteration, page) {
 }
 
 function distinctUntilArrayLengthChanges(inputGetArray) {
-  const getArray = inputGetArray !== null && inputGetArray !== void 0 ? inputGetArray : value => util.asArray(value);
+  const getArray = inputGetArray != null ? inputGetArray : value => util.asArray(value);
   return rxjs.distinctUntilChanged((a, b) => a === b, x => getArray(x).length);
 }
 function scanIntoArray(config = {}) {
@@ -3303,7 +3294,7 @@ function scanBuildArray(init) {
         }
       }
       return acc;
-    }, seed !== null && seed !== void 0 ? seed : []), distinctUntilArrayLengthChanges(), rxjs.shareReplay(1));
+    }, seed != null ? seed : []), distinctUntilArrayLengthChanges(), rxjs.shareReplay(1));
   });
 }
 // MARK: MapForEach
@@ -3322,7 +3313,7 @@ function mapForEach(forEach) {
 function mapEachAsync(mapFunction, config) {
   const {
     onlyFirst = false
-  } = config !== null && config !== void 0 ? config : {};
+  } = config != null ? config : {};
   return rxjs.switchMap(values => {
     if (values.length) {
       const mappedObs = values.map(mapFunction);
@@ -3349,7 +3340,7 @@ function onMatchDelta(config) {
     to,
     requireConsecutive
   } = config;
-  const isMatch = inputIsSame !== null && inputIsSame !== void 0 ? inputIsSame : (a, b) => a === b;
+  const isMatch = inputIsSame != null ? inputIsSame : (a, b) => a === b;
   return obs => {
     return obs.pipe(rxjs.scan((acc, next) => {
       let emit = false;
@@ -3726,7 +3717,7 @@ function scanCount(startAt = 0) {
  * @returns
  */
 function incrementingNumberTimer(config = {}) {
-  return factoryTimer(Object.assign(Object.assign({}, config), {
+  return factoryTimer(Object.assign({}, config, {
     factory: util.incrementingNumberFactory(config)
   }));
 }
@@ -3927,7 +3918,7 @@ function errorOnEmissionsInPeriod(config) {
     errorMessage: inputErrorMessage,
     switchToObs
   } = config;
-  const errorMessage = inputErrorMessage !== null && inputErrorMessage !== void 0 ? inputErrorMessage : 'errorOnEmissionsInPeriod(): Too many emissions in time period.';
+  const errorMessage = inputErrorMessage != null ? inputErrorMessage : 'errorOnEmissionsInPeriod(): Too many emissions in time period.';
   const errorFactory = inputErrorFactory ? inputErrorFactory : !switchToObs ? () => new Error(errorMessage) : undefined;
   return source => {
     const counter = util.timePeriodCounter(period);
@@ -3935,7 +3926,7 @@ function errorOnEmissionsInPeriod(config) {
       return source.pipe(rxjs.map(x => {
         if (counter() > maxEmissionsPerPeriod) {
           const error = errorFactory();
-          onError === null || onError === void 0 ? void 0 : onError(error);
+          onError == null || onError(error);
           throw error;
         } else {
           return x;
@@ -3955,13 +3946,13 @@ function errorOnEmissionsInPeriod(config) {
 }
 
 function setContainsAllValuesFrom(valuesObs) {
-  return combineLatestMapFrom(valuesObs, (set, values) => util.setContainsAllValues(set, values !== null && values !== void 0 ? values : []));
+  return combineLatestMapFrom(valuesObs, (set, values) => util.setContainsAllValues(set, values != null ? values : []));
 }
 function setContainsAnyValueFrom(valuesObs) {
-  return combineLatestMapFrom(valuesObs, (set, values) => util.setContainsAnyValue(set, values !== null && values !== void 0 ? values : []));
+  return combineLatestMapFrom(valuesObs, (set, values) => util.setContainsAnyValue(set, values != null ? values : []));
 }
 function setContainsNoValueFrom(valuesObs) {
-  return combineLatestMapFrom(valuesObs, (set, values) => util.setContainsNoneOfValue(set, values !== null && values !== void 0 ? values : []));
+  return combineLatestMapFrom(valuesObs, (set, values) => util.setContainsNoneOfValue(set, values != null ? values : []));
 }
 function distinctUntilHasDifferentValues() {
   return rxjs.distinctUntilChanged(util.hasSameValues);
@@ -4032,14 +4023,31 @@ exports.LoadingStateType = void 0;
  * @returns
  */
 function loadingStateType(loadingState) {
-  if (loadingState.loading) {
-    return exports.LoadingStateType.LOADING;
-  } else if (util.objectHasKey(loadingState, 'value')) {
-    return exports.LoadingStateType.SUCCESS;
-  } else if (util.objectHasKey(loadingState, 'error')) {
-    return exports.LoadingStateType.ERROR;
+  const isLoading = !isLoadingStateFinishedLoading(loadingState);
+  let type;
+  if (isLoading) {
+    type = exports.LoadingStateType.LOADING;
   } else {
-    return exports.LoadingStateType.IDLE;
+    if (util.objectHasKey(loadingState, 'value')) {
+      type = exports.LoadingStateType.SUCCESS;
+    } else if (util.objectHasKey(loadingState, 'error')) {
+      type = exports.LoadingStateType.ERROR;
+    } else {
+      type = exports.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 false;
   }
 }
 /**
@@ -4051,16 +4059,16 @@ function idleLoadingState() {
   };
 }
 function beginLoading(state) {
-  return state ? Object.assign(Object.assign({}, state), {
+  return state ? Object.assign({}, state, {
     loading: true
   }) : {
     loading: true
   };
 }
 function beginLoadingPage(page, state) {
-  return state ? Object.assign(Object.assign({
+  return state ? Object.assign({
     page
-  }, state), {
+  }, state, {
     loading: true
   }) : {
     page,
@@ -4074,7 +4082,7 @@ function successResult(value) {
   };
 }
 function successPageResult(page, value) {
-  return Object.assign(Object.assign({}, successResult(value)), {
+  return Object.assign({}, successResult(value), {
     page
   });
 }
@@ -4085,59 +4093,77 @@ function errorResult(error) {
   };
 }
 function errorPageResult(page, error) {
-  return Object.assign(Object.assign({}, errorResult(error)), {
+  return Object.assign({}, errorResult(error), {
     page
   });
 }
-function unknownLoadingStatesIsLoading(states) {
-  return util.reduceBooleansWithOr(states.map(loadingStateIsLoading), false);
-}
-function allLoadingStatesHaveFinishedLoading(states) {
-  return util.reduceBooleansWithAnd(states.map(loadingStateHasFinishedLoading), true);
-}
-function loadingStateIsIdle(state) {
-  if (state) {
-    return loadingStateType(state) === exports.LoadingStateType.IDLE;
-  } else {
-    return true;
-  }
-}
-function loadingStateIsLoading(state) {
-  return !loadingStateHasFinishedLoading(state);
-}
-function isSuccessLoadingState(state) {
-  if (state) {
-    return loadingStateType(state) === exports.LoadingStateType.SUCCESS;
-  } else {
-    return false;
-  }
+/**
+ * Returns true if any of the input LoadingStates return true for isLoadingStateLoading().
+ *
+ * @param states
+ * @returns
+ */
+function isAnyLoadingStateInLoadingState(states) {
+  return util.reduceBooleansWithOr(states.map(isLoadingStateLoading), false);
 }
-function isErrorLoadingState(state) {
-  if (state) {
-    return loadingStateType(state) === exports.LoadingStateType.ERROR;
-  } else {
-    return false;
-  }
+/**
+ * Returns true if all input LoadingStates return true for isLoadingStateLoading().
+ *
+ * @param states
+ * @returns
+ */
+function areAllLoadingStatesFinishedLoading(states) {
+  return util.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 === exports.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
  */
-function loadingStateHasValue(state) {
+const isLoadingStateInIdleState = isLoadingStateWithStateType(exports.LoadingStateType.IDLE);
+/**
+ * Returns true if the input LoadingState passed to loadingStateType() returns LOADING.
+ *
+ * @param state
+ * @returns
+ */
+const isLoadingStateLoading = isLoadingStateWithStateType(exports.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(exports.LoadingStateType.SUCCESS);
+/**
+ * Returns true if the input LoadingState passed to loadingStateType() returns ERROR.
+ *
+ * @param state
+ * @returns
+ */
+const isLoadingStateInErrorState = isLoadingStateWithStateType(exports.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 {
@@ -4145,12 +4171,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 {
@@ -4158,27 +4184,27 @@ 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;
   }
@@ -4191,20 +4217,20 @@ function loadingStateHasFinishedLoadingWithError(state) {
  * @param a
  * @param b
  */
-function loadingStatesHaveEquivalentMetadata(a, b) {
+function isPageLoadingStateMetadataEqual(a, b) {
   return util.valuesAreBothNullishOrEquivalent(a.page, b.page) && a.loading == b.loading && util.valuesAreBothNullishOrEquivalent(a.error, b.error);
 }
 function mergeLoadingStates(...args) {
-  var _a;
+  var _loadingStates$find;
   const validArgs = util.filterMaybeValues(args); // filter out any undefined values
   const lastValueIsMergeFn = typeof validArgs[validArgs.length - 1] === 'function';
   const loadingStates = lastValueIsMergeFn ? validArgs.slice(0, validArgs.length - 1) : validArgs;
   const mergeFn = lastValueIsMergeFn ? args[validArgs.length - 1] : (...inputArgs) => util.mergeObjects(inputArgs);
-  const error = (_a = loadingStates.find(x => x.error)) === null || _a === void 0 ? void 0 : _a.error; // find the first error
+  const error = (_loadingStates$find = loadingStates.find(x => x.error)) == null ? void 0 : _loadingStates$find.error; // find the first error
   let result;
   if (error) {
     // ignore all loading states, except for any error-prone item that is still loading
-    const currentLoadings = loadingStates.map(x => (x === null || x === void 0 ? void 0 : x.error) ? x.loading : false);
+    const currentLoadings = loadingStates.map(x => x != null && x.error ? x.loading : false);
     const nonMaybeLoadings = currentLoadings.filter(x => x != null);
     const loading = nonMaybeLoadings.length > 0 ? util.reduceBooleansWithOr(nonMaybeLoadings) : undefined;
     result = {
@@ -4213,7 +4239,7 @@ function mergeLoadingStates(...args) {
       error
     };
   } else {
-    const loading = util.reduceBooleansWithOr(loadingStates.map(loadingStateIsLoading));
+    const loading = util.reduceBooleansWithOr(loadingStates.map(isLoadingStateLoading));
     if (loading) {
       result = {
         loading: true
@@ -4230,30 +4256,30 @@ function mergeLoadingStates(...args) {
   return result;
 }
 /**
- * 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) {
-  return Object.assign(Object.assign({}, state), {
+function mergeLoadingStateWithLoading(state, loading = true) {
+  return Object.assign({}, state, {
     value: undefined,
     loading,
     error: undefined
   });
 }
 /**
- * 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) {
-  return Object.assign(Object.assign({}, state), {
-    value: value !== null && value !== void 0 ? value : undefined,
+function mergeLoadingStateWithValue(state, value) {
+  return Object.assign({}, state, {
+    value: value != null ? value : undefined,
     loading: false,
     error: undefined
   });
 }
 /**
- * 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) {
-  return Object.assign(Object.assign({}, state), {
+function mergeLoadingStateWithError(state, error) {
+  return Object.assign({}, state, {
     loading: false,
     error
   });
@@ -4263,8 +4289,8 @@ function mapMultipleLoadingStateResults(input, config) {
     mapValues,
     mapState
   } = config;
-  const loading = unknownLoadingStatesIsLoading(input);
-  const error = input.map(x => x === null || x === void 0 ? void 0 : x.error).filter(x => Boolean(x))[0];
+  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) {
     if (mapValues) {
@@ -4288,7 +4314,7 @@ function mapLoadingStateResults(input, config) {
     mapState,
     alwaysMapValue = false
   } = config;
-  const inputValue = input === null || input === void 0 ? void 0 : input.value;
+  const inputValue = input == null ? void 0 : input.value;
   let value;
   if ((inputValue != null || alwaysMapValue) && mapValue) {
     value = mapValue(inputValue, input);
@@ -4297,7 +4323,7 @@ function mapLoadingStateResults(input, config) {
   }
   let result;
   if (!mapState) {
-    result = Object.assign(Object.assign({}, input), {
+    result = Object.assign({}, input, {
       value
     });
   } else {
@@ -4314,21 +4340,84 @@ function mapLoadingStateValueFunction(mapFn) {
     return result;
   };
 }
+// 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 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 rxjs.BehaviorSubject(undefined);
-    this.stateSubject$ = this._stateSubject$.pipe(filterMaybe(), rxjs.distinctUntilChanged(), rxjs.shareReplay(1));
+  constructor(_config) {
+    this._stateSubject = new rxjs.BehaviorSubject(undefined);
+    this._config = new rxjs.BehaviorSubject(undefined);
+    this.config$ = this._config.pipe(filterMaybe(), rxjs.shareReplay(1));
+    this.stateSubject$ = this._stateSubject.pipe(filterMaybe(), rxjs.distinctUntilChanged(), rxjs.shareReplay(1));
     this.state$ = this.stateSubject$.pipe(rxjs.switchMap(x => x), rxjs.shareReplay(1));
-    this.stateObs$ = this._stateSubject$.asObservable();
-    this.stream$ = this._stateSubject$.pipe(rxjs.mergeMap(obs => {
+    this.stateObs$ = this._stateSubject.asObservable();
+    this.stream$ = this.stateObs$.pipe(rxjs.mergeMap(obs => {
       if (obs) {
         return obs.pipe(
         // If the observable did not pass a value immediately, we start with the start value.
-        timeoutStartWith(beginLoading()), rxjs.map(x => this.loadingEventForLoadingPair(x, this._config)));
+        timeoutStartWith(beginLoading()), rxjs.combineLatestWith(this.config$), rxjs.map(([x, config]) => this.loadingEventForLoadingPair(x, config)));
       } else {
         return rxjs.of(beginLoading());
       }
@@ -4338,30 +4427,34 @@ class AbstractLoadingStateContextInstance {
     /**
      * Emits when the input state has changed.
      */
-    this.stateChange$ = this._stateSubject$.pipe(rxjs.map(() => undefined));
+    this.stateChange$ = this._stateSubject.pipe(rxjs.map(() => undefined));
     this.loading$ = this.stream$.pipe(rxjs.map(x => x.loading), rxjs.shareReplay(1));
-    if (rxjs.isObservable(config)) {
-      this._config = {
-        obs: config
+    let nextConfig;
+    if (rxjs.isObservable(_config)) {
+      nextConfig = {
+        obs: _config
       };
     } else {
-      this._config = config !== null && config !== void 0 ? 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.
  *
@@ -4371,16 +4464,7 @@ function loadingStateFromObs(obs, firstOnly) {
   if (firstOnly) {
     obs = obs.pipe(rxjs.first());
   }
-  return obs.pipe(rxjs.map(value => ({
-    loading: false,
-    value,
-    error: undefined
-  })), rxjs.catchError(error => rxjs.of({
-    loading: false,
-    error
-  })), timeoutStartWith({
-    loading: true
-  }, 50), rxjs.shareReplay(1));
+  return obs.pipe(rxjs.map(value => successResult(value)), rxjs.catchError(error => rxjs.of(errorResult(error))), timeoutStartWith(beginLoading(), 50), rxjs.shareReplay(1));
 }
 function combineLoadingStates(...args) {
   const validArgs = util.filterMaybeValues(args); // filter out any undefined values
@@ -4415,7 +4499,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 {
@@ -4433,7 +4517,7 @@ function startWithBeginLoading(state) {
  */
 function valueFromLoadingState() {
   return obs => {
-    return obs.pipe(rxjs.filter(loadingStateHasValue), rxjs.map(x => x.value));
+    return obs.pipe(rxjs.filter(isLoadingStateWithDefinedValue), rxjs.map(x => x.value));
   };
 }
 /**
@@ -4441,7 +4525,7 @@ function valueFromLoadingState() {
  */
 function errorFromLoadingState() {
   return obs => {
-    return obs.pipe(rxjs.filter(loadingStateHasError), rxjs.map(x => x.error));
+    return obs.pipe(rxjs.filter(isLoadingStateWithError), rxjs.map(x => x.error));
   };
 }
 /**
@@ -4449,13 +4533,13 @@ function errorFromLoadingState() {
  */
 function valueFromFinishedLoadingState() {
   return obs => {
-    return obs.pipe(rxjs.filter(loadingStateHasFinishedLoading), rxjs.map(x => x.value));
+    return obs.pipe(rxjs.filter(isLoadingStateFinishedLoading), rxjs.map(x => x.value));
   };
 }
 function tapOnLoadingStateType(fn, type) {
   let decisionFunction;
   if (type === exports.LoadingStateType.LOADING) {
-    decisionFunction = loadingStateIsLoading;
+    decisionFunction = isLoadingStateLoading;
   } else {
     decisionFunction = state => loadingStateType(state) === type;
   }
@@ -4475,25 +4559,25 @@ function mapLoadingStateValueWithOperator(operator, mapOnUndefined = false) {
   return obs => {
     return obs.pipe(rxjs.switchMap(state => {
       let mappedObs;
-      if (loadingStateHasValue(state) || mapOnUndefined && loadingStateHasFinishedLoading(state) && !loadingStateHasError(state)) {
+      if (isLoadingStateWithDefinedValue(state) || mapOnUndefined && isLoadingStateFinishedLoading(state) && !isLoadingStateWithError(state)) {
         // map the value
-        mappedObs = rxjs.of(state.value).pipe(operator, rxjs.map(value => Object.assign(Object.assign({}, state), {
+        mappedObs = rxjs.of(state.value).pipe(operator, rxjs.map(value => Object.assign({}, state, {
           value
         })),
         // if the operator does not return nearly instantly, then return the current state, minus a value
-        timeoutStartWith(Object.assign(Object.assign({}, state), {
+        timeoutStartWith(Object.assign({}, state, {
           loading: true,
           value: undefined
         }), 0));
       } else {
         // only pass through if there is an error, otherwise show loading.
-        if (loadingStateHasError(state)) {
-          mappedObs = rxjs.of(Object.assign(Object.assign({}, state), {
+        if (isLoadingStateWithError(state)) {
+          mappedObs = rxjs.of(Object.assign({}, state, {
             value: undefined
           }));
         } else {
           // never pass through the non-mapped state's value as-is.
-          mappedObs = rxjs.of(Object.assign(Object.assign({}, state), {
+          mappedObs = rxjs.of(Object.assign({}, state, {
             loading: true,
             value: undefined
           }));
@@ -4512,14 +4596,14 @@ function distinctLoadingState(inputConfig) {
   } = typeof inputConfig === 'function' ? {
     valueComparator: inputConfig
   } : inputConfig;
-  const passRetainedValue = inputPassRetainedValue !== null && inputPassRetainedValue !== void 0 ? inputPassRetainedValue : x => x !== null;
-  const metadataComparator = inputMetadataComparator !== null && inputMetadataComparator !== void 0 ? inputMetadataComparator : loadingStatesHaveEquivalentMetadata;
+  const passRetainedValue = inputPassRetainedValue != null ? inputPassRetainedValue : x => x !== null;
+  const metadataComparator = inputMetadataComparator != null ? inputMetadataComparator : isPageLoadingStateMetadataEqual;
   return obs => {
     return obs.pipe(rxjs.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)) {
@@ -4529,12 +4613,11 @@ function distinctLoadingState(inputConfig) {
       const isSameLoadingStateMetadata = util.safeCompareEquality(state, acc.previous, metadataComparator);
       // pick the value
       const value = isSameValue ? acc.value : nextValue;
-      const current = Object.assign(Object.assign({}, state), {
-        // copy all metadata over
+      const current = Object.assign({}, state, {
         value // set the new value
       });
 
-      return Object.assign(Object.assign({}, acc), {
+      return Object.assign({}, acc, {
         value,
         isSameValue,
         isSameLoadingStateMetadata,
@@ -4560,7 +4643,7 @@ function distinctLoadingState(inputConfig) {
  * @returns
  */
 function promiseFromLoadingState(obs) {
-  return rxjs.firstValueFrom(obs.pipe(rxjs.filter(loadingStateHasFinishedLoading))).then(x => {
+  return rxjs.firstValueFrom(obs.pipe(rxjs.filter(isLoadingStateFinishedLoading))).then(x => {
     let result;
     if (x.error) {
       throw x.error;
@@ -4571,18 +4654,22 @@ 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 rxjs.map(listLoadingStateIsEmpty);
+/**
+ * Convenience function that merges map() with isListLoadingStateWithEmptyValue()
+ *
+ * @returns
+ */
+function mapIsListLoadingStateWithEmptyValue() {
+  return rxjs.map(isListLoadingStateWithEmptyValue);
 }
 /**
  * Wraps an observable output and maps the value to a PageLoadingState.
@@ -4593,24 +4680,33 @@ function pageLoadingStateFromObs(obs, firstOnly, page = 0) {
     return x;
   }));
 }
+// MARK: Compat
+/**
+ * @deprecated use isListLoadingStateWithEmptyValue instead.
+ */
+const listLoadingStateIsEmpty = isListLoadingStateWithEmptyValue;
+/**
+ * @deprecated use mapIsListLoadingStateWithEmptyValue instead.
+ */
+const isListLoadingStateEmpty = mapIsListLoadingStateWithEmptyValue;
 
 /**
  * LoadingContext implementation that uses a ListLoadingState observable.
  */
 class ListLoadingStateContextInstance extends AbstractLoadingStateContextInstance {
-  constructor() {
-    super(...arguments);
+  constructor(...args) {
+    super(...args);
     /**
      * Returns the current values or an empty list.
      */
     this.list$ = this.stream$.pipe(rxjs.map(x => {
-      var _a;
-      return (_a = x.value) !== null && _a !== void 0 ? _a : [];
+      var _x$value;
+      return (_x$value = x.value) != null ? _x$value : [];
     }), rxjs.shareReplay(1));
     /**
      * Returns true while loading and the current value is considered empty.
      */
-    this.isEmptyLoading$ = this.stream$.pipe(rxjs.map(x => loadingStateIsLoading(x) && listLoadingStateIsEmpty(x)), rxjs.distinctUntilChanged(), rxjs.shareReplay(1));
+    this.isEmptyLoading$ = this.stream$.pipe(rxjs.map(x => isLoadingStateLoading(x) && isListLoadingStateWithEmptyValue(x)), rxjs.distinctUntilChanged(), rxjs.shareReplay(1));
     /**
      * Whether or not the current value is empty.
      *
@@ -4618,9 +4714,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(rxjs.skipWhile(x => loadingStateIsLoading(x)),
+    this.isEmpty$ = this.stream$.pipe(rxjs.skipWhile(x => isLoadingStateLoading(x)),
     // skip until the first non-loading event has occured
-    isListLoadingStateEmpty(), rxjs.distinctUntilChanged());
+    mapIsListLoadingStateWithEmptyValue(), rxjs.distinctUntilChanged());
     /**
      * Whether or not the current value is empty and not loading.
      *
@@ -4628,17 +4724,17 @@ 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(rxjs.skipWhile(x => loadingStateIsLoading(x)),
+    this.isEmptyAndNotLoading$ = this.stream$.pipe(rxjs.skipWhile(x => isLoadingStateLoading(x)),
     // skip until the first non-loading event has occured
-    rxjs.map(x => !loadingStateIsLoading(x) && listLoadingStateIsEmpty(x)), rxjs.distinctUntilChanged());
+    rxjs.map(x => !isLoadingStateLoading(x) && isListLoadingStateWithEmptyValue(x)), rxjs.distinctUntilChanged());
   }
   loadingEventForLoadingPair(state, config = {}) {
     const {
       showLoadingOnNoValue
     } = config;
-    let loading = state === null || state === void 0 ? void 0 : state.loading;
-    const error = state === null || state === void 0 ? void 0 : state.error;
-    let value = state === null || state === void 0 ? void 0 : state.value;
+    let loading = state == null ? void 0 : state.loading;
+    const error = state == null ? void 0 : state.error;
+    let value = state == null ? void 0 : state.value;
     const hasValue = value != null;
     if (hasValue) {
       value = util.limitArray(value, config); // Always limit the value/results.
@@ -4648,7 +4744,7 @@ class ListLoadingStateContextInstance extends AbstractLoadingStateContextInstanc
       if (showLoadingOnNoValue) {
         loading = !hasValue;
       } else {
-        loading = loadingStateIsLoading(state);
+        loading = isLoadingStateLoading(state);
       }
     }
     return {
@@ -4666,8 +4762,8 @@ function listLoadingStateContext(config) {
  * LoadingContext implementation for a LoadingState.
  */
 class LoadingStateContextInstance extends AbstractLoadingStateContextInstance {
-  constructor() {
-    super(...arguments);
+  constructor(...args) {
+    super(...args);
     this.value$ = this.stream$.pipe(rxjs.map(x => x.value), rxjs.shareReplay(1));
     this.valueAfterLoaded$ = this.stream$.pipe(rxjs.filter(x => !x.loading), rxjs.map(x => x.value), rxjs.shareReplay(1));
   }
@@ -4675,13 +4771,13 @@ class LoadingStateContextInstance extends AbstractLoadingStateContextInstance {
     showLoadingOnNoValue
   } = {}) {
     let loading = false;
-    const error = pair === null || pair === void 0 ? void 0 : pair.error;
-    const value = pair === null || pair === void 0 ? void 0 : pair.value;
+    const error = pair == null ? void 0 : pair.error;
+    const value = pair == null ? void 0 : pair.value;
     if (!util.hasNonNullValue(error)) {
       if (showLoadingOnNoValue) {
         loading = !util.hasNonNullValue(value);
       } else {
-        loading = loadingStateIsLoading(pair);
+        loading = isLoadingStateLoading(pair);
       }
     }
     return {
@@ -4700,6 +4796,8 @@ function loadingStateContext(config) {
  */
 class SimpleLoadingContext {
   constructor(loading = true) {
+    this._subject = void 0;
+    this._error = void 0;
     this._subject = new rxjs.BehaviorSubject({
       loading
     });
@@ -4741,6 +4839,7 @@ class ValuesLoadingContext extends SimpleLoadingContext {
     loading = true
   } = {}) {
     super(loading);
+    this._checkDone = void 0;
     this._checkDone = checkDone;
   }
   /**
@@ -4765,70 +4864,113 @@ class ValuesLoadingContext extends SimpleLoadingContext {
   }
 }
 
-/**
- * ItemAccumulator implementation.
- */
-class ItemAccumulatorInstance {
-  constructor(itemIteration, mapItemFunction) {
-    this.itemIteration = itemIteration;
-    this.mapItemFunction = mapItemFunction;
-    this.hasCompletedInitialLoad$ = this.itemIteration.firstState$.pipe(rxjs.map(() => true), rxjs.startWith(false), rxjs.distinctUntilChanged(), rxjs.shareReplay(1));
-    this.latestSuccessfulState$ = this.itemIteration.latestState$.pipe(rxjs.filter(x => !loadingStateHasError(x)), rxjs.distinctUntilChanged(), rxjs.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.
-     */
-    rxjs.startWith([]), distinctUntilArrayLengthChanges(), rxjs.shareReplay(1));
-    this.successfulLoadCount$ = this.allSuccessfulStates$.pipe(rxjs.map(x => x.length), rxjs.shareReplay(1));
-    // MARK: ItemAccumulator
-    this.currentAllItemPairs$ = this.allSuccessfulStates$.pipe(scanBuildArray(allSuccessfulStates => {
-      const mapStateToItem = util.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 = util.lastValue(allPageResultsUpToFirstSubscription);
-      const seed = allPageResultsUpToFirstSubscription.map(mapStateToItem).filter(x => util.isMaybeSo(x.output));
-      const accumulatorObs = this.latestSuccessfulState$.pipe(rxjs.skipWhile(x => x === firstLatestState), rxjs.map(mapStateToItem), rxjs.filter(x => util.isMaybeSo(x.output)));
-      return {
-        seed,
-        accumulatorObs
-      };
-    }), rxjs.shareReplay(1));
-    this.currentAllItems$ = this.currentAllItemPairs$.pipe(rxjs.map(x => x.map(y => y.output)), rxjs.shareReplay(1));
-    this.allItemPairs$ = this.hasCompletedInitialLoad$.pipe(switchMapWhileTrue(this.currentAllItemPairs$), rxjs.shareReplay(1));
-    this.allItems$ = this.hasCompletedInitialLoad$.pipe(switchMapWhileTrue(this.currentAllItems$), rxjs.shareReplay(1));
-    this._sub = new SubscriptionObject(this.allSuccessfulStates$.subscribe());
+function _await$1(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
   }
-  destroy() {
-    this._sub.destroy();
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
   }
+  return then ? value.then(then) : value;
+} /**
+   * Automatically calls next on the accumulator's page item iteration up to the target number of results. Returns the total number of items loaded.
+   *
+   * The promise will reject with an error if an error is encountered.
+   *
+   * @param iteration
+   * @param maxResultsLimit
+   * @returns
+   */
+
+function _async$1(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
 }
-function itemAccumulator(itemIteration, mapItem) {
-  if (!mapItem) {
-    mapItem = a => a;
+function _call(body, then, direct) {
+  if (direct) {
+    return then ? then(body()) : body();
   }
-  return new ItemAccumulatorInstance(itemIteration, mapItem);
+  try {
+    var result = Promise.resolve(body());
+    return then ? result.then(then) : result;
+  } catch (e) {
+    return Promise.reject(e);
+  }
+}
+function itemAccumulator(itemIteration, inputMapItem) {
+  const mapItemFunction = inputMapItem != null ? inputMapItem : a => a;
+  const hasCompletedInitialLoad$ = itemIteration.firstState$.pipe(rxjs.map(() => true), rxjs.startWith(false), rxjs.distinctUntilChanged(), rxjs.shareReplay(1));
+  const latestSuccessfulState$ = itemIteration.latestState$.pipe(rxjs.filter(x => !isLoadingStateWithError(x)), rxjs.distinctUntilChanged(), rxjs.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.
+   */
+  rxjs.startWith([]), distinctUntilArrayLengthChanges(), rxjs.shareReplay(1));
+  const successfulLoadCount$ = allSuccessfulStates$.pipe(rxjs.map(x => x.length), rxjs.shareReplay(1));
+  // MARK: ItemAccumulator
+  const currentAllItemPairs$ = allSuccessfulStates$.pipe(scanBuildArray(allSuccessfulStates => {
+    const mapStateToItem = util.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 = util.lastValue(allPageResultsUpToFirstSubscription);
+    const seed = allPageResultsUpToFirstSubscription.map(mapStateToItem).filter(x => util.isMaybeSo(x.output));
+    const accumulatorObs = latestSuccessfulState$.pipe(rxjs.skipWhile(x => x === firstLatestState), rxjs.map(mapStateToItem), rxjs.filter(x => util.isMaybeSo(x.output)));
+    return {
+      seed,
+      accumulatorObs
+    };
+  }), rxjs.shareReplay(1));
+  const currentAllItems$ = currentAllItemPairs$.pipe(rxjs.map(x => x.map(y => y.output)), rxjs.shareReplay(1));
+  const allItemPairs$ = hasCompletedInitialLoad$.pipe(switchMapWhileTrue(currentAllItemPairs$), rxjs.shareReplay(1));
+  const allItems$ = hasCompletedInitialLoad$.pipe(switchMapWhileTrue(currentAllItems$), rxjs.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;
 }
-/**
- * Automatically calls next on the accumulator's page item iteration up to the target number of results. Returns the total number of items loaded.
- *
- * The promise will reject with an error if an error is encountered.
- *
- * @param iteration
- * @param maxResultsLimit
- * @returns
- */
 function itemAccumulatorNextPageUntilResultsCount(config) {
+  const checkResultsLimit = _async$1(function () {
+    return _await$1(rxjs.firstValueFrom(accumulator.currentAllItems$), function (allItems) {
+      return _await$1(rxjs.firstValueFrom(canLoadMoreObs), function (canLoadMore) {
+        return _await$1(countResults(allItems), function (currentCount) {
+          const maxResultsLimit = getMaxResultsLimit();
+          const shouldContinue = canLoadMore && currentCount < maxResultsLimit;
+          return {
+            shouldContinue,
+            currentCount
+          };
+        });
+      });
+    });
+  });
   const {
     accumulator,
     maxResultsLimit,
@@ -4838,30 +4980,18 @@ function itemAccumulatorNextPageUntilResultsCount(config) {
   const canLoadMoreObs = iterationHasNextAndCanLoadMore(accumulator.itemIteration).pipe(timeoutStartWith(false, 100),
   // TODO: This can fail to emit anything if the iterator has been destroyed
   rxjs.shareReplay(1));
-  function checkResultsLimit() {
-    return __awaiter(this, void 0, void 0, function* () {
-      const allItems = yield rxjs.firstValueFrom(accumulator.currentAllItems$);
-      const canLoadMore = yield rxjs.firstValueFrom(canLoadMoreObs);
-      const currentCount = yield countResults(allItems);
-      const maxResultsLimit = getMaxResultsLimit();
-      const shouldContinue = canLoadMore && currentCount < maxResultsLimit;
-      return {
-        shouldContinue,
-        currentCount
-      };
-    });
-  }
   return new Promise((resolve, reject) => {
     accumulator.currentAllItems$.pipe(rxjs.first(), rxjs.switchMap(allItems => rxjs.from(util.asPromise(countResults(allItems))))).subscribe({
-      next: currentResultsCount => __awaiter(this, void 0, void 0, function* () {
+      next: _async$1(function (currentResultsCount) {
         util.performTaskLoop({
           initValue: currentResultsCount,
-          checkContinue: (x, i) => __awaiter(this, void 0, void 0, function* () {
-            const result = yield checkResultsLimit();
-            currentResultsCount = result.currentCount;
-            return result.shouldContinue;
-          }),
-          next: () => __awaiter(this, void 0, void 0, function* () {
+          checkContinue: function (x, i) {
+            return _call(checkResultsLimit, function (result) {
+              currentResultsCount = result.currentCount;
+              return result.shouldContinue;
+            });
+          },
+          next: _async$1(function () {
             return accumulator.itemIteration.nextPage();
           })
         }).then(page => {
@@ -4873,6 +5003,7 @@ function itemAccumulatorNextPageUntilResultsCount(config) {
           reject(error);
           throw error;
         });
+        return _await$1();
       }),
       error: error => {
         reject(error);
@@ -4891,7 +5022,7 @@ function flattenAccumulatorResultItemArray(accumulator) {
   return accumulator.currentAllItemPairs$.pipe(scanBuildArray(allItems => {
     const pairs = allItems;
     const firstLatestItemPair = util.lastValue(allItems);
-    const skipValue = firstLatestItemPair === null || firstLatestItemPair === void 0 ? void 0 : firstLatestItemPair.input;
+    const skipValue = firstLatestItemPair == null ? void 0 : firstLatestItemPair.input;
     const seed = util.flattenArray(pairs.map(x => x.output));
     const mapStateToItem = mapLoadingStateValueFunction(accumulator.mapItemFunction);
     const accumulatorObs = accumulator.itemIteration.latestState$.pipe(rxjs.skipWhile(x => x.value === skipValue), rxjs.map(mapStateToItem), filterMaybe());
@@ -4932,6 +5063,13 @@ function pageItemAccumulatorCurrentPage(pageItemAccumulator) {
 
 class MappedItemIterationInstance {
   constructor(itemIterator, config) {
+    this.itemIterator = void 0;
+    this.config = void 0;
+    this.hasNext$ = void 0;
+    this.canLoadMore$ = void 0;
+    this.firstState$ = void 0;
+    this.latestState$ = void 0;
+    this.currentState$ = void 0;
     this.itemIterator = itemIterator;
     this.config = config;
     this.hasNext$ = this.itemIterator.hasNext$;
@@ -4964,8 +5102,8 @@ function mapItemIteration(itemIteration, config) {
  * MappedItemIterationInstance extension that implements PageItemIteration.
  */
 class MappedPageItemIterationInstance extends MappedItemIterationInstance {
-  constructor() {
-    super(...arguments);
+  constructor(...args) {
+    super(...args);
     this.latestLoadedPage$ = this.itemIterator.latestLoadedPage$;
   }
   // MARK: PageItemIteration
@@ -4994,10 +5132,32 @@ function mapPageItemIteration(itemIteration, config) {
 /**
  * Default number of pages that can be loaded.
  */
+
+function _await(value, then, direct) {
+  if (direct) {
+    return then ? then(value) : value;
+  }
+  if (!value || !value.then) {
+    value = Promise.resolve(value);
+  }
+  return then ? value.then(then) : value;
+} /**
+   * Used for generating new iterations.
+   */
+
+function _async(f) {
+  return function () {
+    for (var args = [], i = 0; i < arguments.length; i++) {
+      args[i] = arguments[i];
+    }
+    try {
+      return Promise.resolve(f.apply(this, args));
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+}
 const DEFAULT_ITEM_PAGE_ITERATOR_MAX = 100;
-/**
- * Used for generating new iterations.
- */
 class ItemPageIterator {
   get maxPageLoadLimit() {
     return this._maxPageLoadLimit;
@@ -5006,6 +5166,8 @@ class ItemPageIterator {
     this._maxPageLoadLimit = maxPageLoadLimit;
   }
   constructor(delegate) {
+    this.delegate = void 0;
+    this._maxPageLoadLimit = void 0;
     this.delegate = delegate;
   }
   /**
@@ -5023,16 +5185,16 @@ class ItemPageIterator {
  */
 class ItemPageIterationInstance {
   constructor(iterator, config) {
-    var _a;
-    this.iterator = iterator;
-    this.config = config;
+    var _this$config$maxPageL;
+    this.iterator = void 0;
+    this.config = void 0;
     /**
      * Used for triggering loading of more content.
      */
     this._next = new rxjs.BehaviorSubject({
       n: 0
     });
-    this._maxPageLoadLimit = new rxjs.BehaviorSubject((_a = this.config.maxPageLoadLimit) !== null && _a !== void 0 ? _a : this.iterator.maxPageLoadLimit);
+    this._maxPageLoadLimit = new rxjs.BehaviorSubject(undefined);
     // MARK: State
     this.state$ = this._next.pipe(rxjs.delay(0), rxjs.exhaustMap(request => rxjs.combineLatest([this.hasNextAndCanLoadMore$, this._lastFinishedPageResultState$]).pipe(rxjs.first(), rxjs.map(([hasNextAndCanLoadMore, prevResult]) => [itemPageIteratorShouldLoadNextPage(request, hasNextAndCanLoadMore, prevResult), prevResult]), rxjs.mergeMap(([shouldLoadNextPage, prevResult]) => {
       if (shouldLoadNextPage) {
@@ -5081,13 +5243,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;
@@ -5116,7 +5278,7 @@ class ItemPageIterationInstance {
     /**
      * Same as _nextTrigger$, but catches finished loading events.
      */
-    this._nextFinished$ = this._nextTrigger$.pipe(rxjs.filter(x => loadingStateHasFinishedLoading(x.current)));
+    this._nextFinished$ = this._nextTrigger$.pipe(rxjs.filter(x => isLoadingStateFinishedLoading(x.current)));
     /**
      * The first page results that finished loading.
      */
@@ -5143,10 +5305,10 @@ class ItemPageIterationInstance {
     /**
      * Whether or not items are currently being loaded.
      */
-    this.isLoading$ = this._currentPageResultState$.pipe(rxjs.map(x => loadingStateIsLoading(x)), rxjs.distinctUntilChanged(), rxjs.shareReplay(1));
+    this.isLoading$ = this._currentPageResultState$.pipe(rxjs.map(x => isLoadingStateLoading(x)), rxjs.distinctUntilChanged(), rxjs.shareReplay(1));
     this._lastFinishedPageResultState$ = this.latestPageResultState$.pipe(rxjs.startWith(undefined), rxjs.shareReplay(1));
-    this._lastFinishedPageResult$ = this._lastFinishedPageResultState$.pipe(rxjs.map(x => x === null || x === void 0 ? void 0 : x.value));
-    this._lastFinishedPageResultItem$ = this._lastFinishedPageResult$.pipe(rxjs.map(x => x === null || x === void 0 ? void 0 : x.value));
+    this._lastFinishedPageResult$ = this._lastFinishedPageResultState$.pipe(rxjs.map(x => x == null ? void 0 : x.value));
+    this._lastFinishedPageResultItem$ = this._lastFinishedPageResult$.pipe(rxjs.map(x => x == null ? void 0 : x.value));
     /**
      * The first page results that has finished loading without an error.
      */
@@ -5174,6 +5336,9 @@ class ItemPageIterationInstance {
     this.firstState$ = this.firstPageResultState$.pipe(mapItemPageLoadingStateFromResultPageLoadingState(), rxjs.shareReplay(1));
     this.latestState$ = this.latestPageResultState$.pipe(mapItemPageLoadingStateFromResultPageLoadingState(), rxjs.shareReplay(1));
     this.latestItems$ = this.latestState$.pipe(rxjs.distinctUntilChanged(), rxjs.map(x => x.value), rxjs.shareReplay(1));
+    this.iterator = iterator;
+    this.config = config;
+    this._maxPageLoadLimit.next((_this$config$maxPageL = this.config.maxPageLoadLimit) != null ? _this$config$maxPageL : this.iterator.maxPageLoadLimit);
   }
   // MARK: PageItemIteration
   get maxPageLoadLimit() {
@@ -5184,8 +5349,9 @@ class ItemPageIterationInstance {
     this._maxPageLoadLimit.next(limit);
   }
   nextPage(request = {}) {
-    return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-      this._nextFinished$.pipe(rxjs.exhaustMap(() => this.latestPageResultState$), rxjs.defaultIfEmpty({
+    const _this = this;
+    return new Promise(_async(function (resolve, reject) {
+      _this._nextFinished$.pipe(rxjs.exhaustMap(() => _this.latestPageResultState$), rxjs.defaultIfEmpty({
         error: undefined,
         page: -1
       }), rxjs.first()).subscribe({
@@ -5200,7 +5366,8 @@ class ItemPageIterationInstance {
           reject(error);
         }
       });
-      this.next(request);
+      _this.next(request);
+      return _await();
     }));
   }
   next(request = {}) {
@@ -5241,13 +5408,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 : util.getNextPageNumber(prevResult);
+  return isLoadingStateWithError(prevResult) ? prevResult.page : util.getNextPageNumber(prevResult);
 }
 function mapItemPageLoadingStateFromResultPageLoadingState() {
   return rxjs.map(itemPageLoadingStateFromResultPageLoadingState);
@@ -5268,8 +5435,8 @@ function onLockSetNextUnlock({
   timeout: inputTimeout,
   delayTime
 }) {
-  const timeoutTime = inputTimeout !== null && inputTimeout !== void 0 ? inputTimeout : util.MS_IN_SECOND * 50;
-  return lockSet.isUnlocked$.pipe(rxjs.filter(x => x), rxjs.delay(delayTime !== null && delayTime !== void 0 ? delayTime : 0), rxjs.timeout({
+  const timeoutTime = inputTimeout != null ? inputTimeout : util.MS_IN_SECOND * 50;
+  return lockSet.isUnlocked$.pipe(rxjs.filter(x => x), rxjs.delay(delayTime != null ? delayTime : 0), rxjs.timeout({
     first: timeoutTime,
     with: () => rxjs.of(false).pipe(rxjs.tap(() => console.warn('LockSet time out. Potential issue detected.')))
   }), rxjs.first()).subscribe(fn);
@@ -5296,13 +5463,12 @@ class LockSet {
     return this._locks.value;
   }
   setLocked(key, config, duration) {
-    var _a;
     let lockedConfig;
     if (typeof config === 'object') {
       lockedConfig = config;
     } else {
       lockedConfig = {
-        locked: (_a = config) !== null && _a !== void 0 ? _a : true,
+        locked: config != null ? config : true,
         duration
       };
     }
@@ -5323,7 +5489,7 @@ class LockSet {
     this.lockForTime(seconds * 1000);
   }
   lockForTime(milliseconds, key) {
-    this.addLock(key !== null && key !== void 0 ? key : DEFAULT_LOCK_SET_TIME_LOCK_KEY, rxjs.of(false).pipe(rxjs.delay(milliseconds), rxjs.startWith(true)));
+    this.addLock(key != null ? key : DEFAULT_LOCK_SET_TIME_LOCK_KEY, rxjs.of(false).pipe(rxjs.delay(milliseconds), rxjs.startWith(true)));
   }
   addLock(key, obs) {
     obs = obs.pipe(rxjs.defaultIfEmpty(false) // empty observables count as unlocked.
@@ -5361,7 +5527,7 @@ class LockSet {
       }
       return removeFn;
     }), cleanup(removeLockSet => {
-      removeLockSet === null || removeLockSet === void 0 ? void 0 : removeLockSet();
+      removeLockSet == null || removeLockSet();
     })).subscribe();
   }
   /**
@@ -5382,9 +5548,9 @@ class LockSet {
         mergeConfig = config;
       }
     }
-    this.onNextUnlock(Object.assign(Object.assign({}, mergeConfig), {
+    this.onNextUnlock(Object.assign({}, mergeConfig, {
       fn: unlocked => {
-        fn === null || fn === void 0 ? void 0 : fn(unlocked);
+        fn == null || fn(unlocked);
         setTimeout(() => this.destroy(), 100);
       },
       delayTime
@@ -5402,15 +5568,18 @@ LockSet.LOCK_SET_CHILD_INDEX_STEPPER = 0;
  */
 class WorkInstance {
   constructor(value, delegate) {
-    this.value = value;
-    this.delegate = delegate;
+    this.value = void 0;
+    this.delegate = void 0;
     this._done = false;
     this._doneActionBegan = false;
+    this._result = void 0;
     this._loadingState = new rxjs.BehaviorSubject(undefined);
     this._sub = new SubscriptionObject();
     this.loadingState$ = this._loadingState.pipe(filterMaybe());
     this._hasStarted$ = this._loadingState.pipe(rxjs.map(x => Boolean(x)), rxjs.shareReplay(1));
-    this._isComplete$ = this.loadingState$.pipe(rxjs.map(x => loadingStateHasFinishedLoading(x)), rxjs.shareReplay(1));
+    this._isComplete$ = this.loadingState$.pipe(rxjs.map(x => isLoadingStateFinishedLoading(x)), rxjs.shareReplay(1));
+    this.value = value;
+    this.delegate = delegate;
     // Schedule to cleanup self once isComplete is true.
     this.result$.subscribe(loadingState => {
       this._result = loadingState;
@@ -5424,7 +5593,7 @@ class WorkInstance {
     return this._done ? rxjs.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 ? rxjs.of(true) : this._isComplete$;
@@ -5447,7 +5616,7 @@ class WorkInstance {
     this._sub.subscription = obs.pipe(rxjs.delay(0),
     // delay to prevent an immediate start working, which can override the _sub.subscription value
     rxjs.first()).subscribe(() => {
-      this.startWorkingWithObservable(obs.pipe(rxjs.filter(x => x && !loadingStateIsLoading(x)),
+      this.startWorkingWithObservable(obs.pipe(rxjs.filter(x => x && !isLoadingStateLoading(x)),
       // don't return until it has finished loading.
       rxjs.map(x => {
         if (x.error) {
@@ -5605,7 +5774,6 @@ exports.FilterMapKeyInstance = FilterMapKeyInstance;
 exports.FilterSource = FilterSource;
 exports.FilterSourceConnector = FilterSourceConnector;
 exports.FilterSourceInstance = FilterSourceInstance;
-exports.ItemAccumulatorInstance = ItemAccumulatorInstance;
 exports.ItemPageIterationInstance = ItemPageIterationInstance;
 exports.ItemPageIterator = ItemPageIterator;
 exports.ListLoadingStateContextInstance = ListLoadingStateContextInstance;
@@ -5622,6 +5790,7 @@ exports.WorkInstance = WorkInstance;
 exports.accumulatorCurrentPageListLoadingState = accumulatorCurrentPageListLoadingState;
 exports.accumulatorFlattenPageListLoadingState = accumulatorFlattenPageListLoadingState;
 exports.allLoadingStatesHaveFinishedLoading = allLoadingStatesHaveFinishedLoading;
+exports.areAllLoadingStatesFinishedLoading = areAllLoadingStatesFinishedLoading;
 exports.asObservable = asObservable;
 exports.asObservableFromGetter = asObservableFromGetter;
 exports.asyncPusher = asyncPusher;
@@ -5665,11 +5834,25 @@ exports.idleLoadingState = idleLoadingState;
 exports.incrementingNumberTimer = incrementingNumberTimer;
 exports.initialize = initialize;
 exports.invertObservableDecision = invertObservableDecision;
+exports.isAnyLoadingStateInLoadingState = isAnyLoadingStateInLoadingState;
 exports.isErrorLoadingState = isErrorLoadingState;
 exports.isItemPageIteratorResultEndResult = isItemPageIteratorResultEndResult;
 exports.isListLoadingStateEmpty = isListLoadingStateEmpty;
+exports.isListLoadingStateWithEmptyValue = isListLoadingStateWithEmptyValue;
 exports.isLoading = isLoading;
+exports.isLoadingStateFinishedLoading = isLoadingStateFinishedLoading;
+exports.isLoadingStateFinishedLoadingWithDefinedValue = isLoadingStateFinishedLoadingWithDefinedValue;
+exports.isLoadingStateFinishedLoadingWithError = isLoadingStateFinishedLoadingWithError;
+exports.isLoadingStateInErrorState = isLoadingStateInErrorState;
+exports.isLoadingStateInIdleState = isLoadingStateInIdleState;
+exports.isLoadingStateInLoadingState = isLoadingStateInLoadingState;
+exports.isLoadingStateInSuccessState = isLoadingStateInSuccessState;
+exports.isLoadingStateLoading = isLoadingStateLoading;
+exports.isLoadingStateWithDefinedValue = isLoadingStateWithDefinedValue;
+exports.isLoadingStateWithError = isLoadingStateWithError;
+exports.isLoadingStateWithStateType = isLoadingStateWithStateType;
 exports.isNot = isNot;
+exports.isPageLoadingStateMetadataEqual = isPageLoadingStateMetadataEqual;
 exports.isSuccessLoadingState = isSuccessLoadingState;
 exports.itemAccumulator = itemAccumulator;
 exports.itemAccumulatorNextPageUntilResultsCount = itemAccumulatorNextPageUntilResultsCount;
@@ -5698,6 +5881,7 @@ exports.mapEachAsync = mapEachAsync;
 exports.mapFilterWithPreset = mapFilterWithPreset;
 exports.mapForEach = mapForEach;
 exports.mapIf = mapIf;
+exports.mapIsListLoadingStateWithEmptyValue = mapIsListLoadingStateWithEmptyValue;
 exports.mapItemIteration = mapItemIteration;
 exports.mapKeysIntersectionToArray = mapKeysIntersectionToArray;
 exports.mapLoadingState = mapLoadingState;
@@ -5708,6 +5892,9 @@ exports.mapMaybe = mapMaybe;
 exports.mapMultipleLoadingStateResults = mapMultipleLoadingStateResults;
 exports.mapPageItemIteration = mapPageItemIteration;
 exports.maybeValueFromObservableOrValueGetter = maybeValueFromObservableOrValueGetter;
+exports.mergeLoadingStateWithError = mergeLoadingStateWithError;
+exports.mergeLoadingStateWithLoading = mergeLoadingStateWithLoading;
+exports.mergeLoadingStateWithValue = mergeLoadingStateWithValue;
 exports.mergeLoadingStates = mergeLoadingStates;
 exports.multiKeyValueMap = multiKeyValueMap;
 exports.onFalseToTrue = onFalseToTrue;