@dereekb/rxjs 10.0.20 → 10.0.22

package/index.cjs.js

@@ -3193,7 +3193,13 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
  * @returns
  */
 function iterationHasNextAndCanLoadMore(iteration) {
-  return rxjs.combineLatest([iteration.hasNext$, iteration.canLoadMore$]).pipe(rxjs.map(util.reduceBooleansWithAndFn(true)), rxjs.shareReplay(1));
+  return iteration.canLoadMore$.pipe(rxjs.switchMap(canLoadMore => {
+    if (canLoadMore) {
+      return iteration.hasNext$;
+    } else {
+      return rxjs.of(false);
+    }
+  }), rxjs.shareReplay(1));
 }
 /**
  * Automatically calls next up to the current maxPageLoadLimit configured on the iterator.
@@ -3233,16 +3239,23 @@ function iteratorNextPageUntilPage(iteration, page) {
     const maxLimit = Math.min(pageLimit, (_a = iteration.maxPageLoadLimit) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER);
     return page + 1 < maxLimit;
   }
-  return new Promise(resolve => {
-    iteration.latestLoadedPage$.pipe(rxjs.first()).subscribe(firstLatestPage => {
-      const promise = util.performTaskLoop({
-        initValue: firstLatestPage,
-        checkContinue: latestPage => checkPageLimit(latestPage),
-        next: () => __awaiter(this, void 0, void 0, function* () {
-          return yield iteration.nextPage();
-        })
-      });
-      resolve(promise);
+  return new Promise((resolve, reject) => {
+    iteration.latestLoadedPage$.pipe(rxjs.first()).subscribe({
+      next: firstLatestPage => {
+        const promise = util.performTaskLoop({
+          initValue: firstLatestPage,
+          checkContinue: latestPage => __awaiter(this, void 0, void 0, function* () {
+            return rxjs.firstValueFrom(iterationHasNextAndCanLoadMore(iteration)).then(canLoadMore => canLoadMore && checkPageLimit(latestPage));
+          }),
+          next: () => __awaiter(this, void 0, void 0, function* () {
+            return yield iteration.nextPage();
+          })
+        });
+        resolve(promise);
+      },
+      error: error => {
+        reject(error);
+      }
     });
   });
 }
@@ -4775,6 +4788,67 @@ function itemAccumulator(itemIteration, mapItem) {
   }
   return new ItemAccumulatorInstance(itemIteration, mapItem);
 }
+/**
+ * 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 {
+    accumulator,
+    maxResultsLimit,
+    countResultsFunction: countResults
+  } = config;
+  const getMaxResultsLimit = util.asGetter(maxResultsLimit);
+  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* () {
+        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* () {
+            return accumulator.itemIteration.nextPage();
+          })
+        }).then(page => {
+          resolve({
+            page,
+            resultsCount: currentResultsCount
+          });
+        }).catch(error => {
+          reject(error);
+          throw error;
+        });
+      }),
+      error: error => {
+        reject(error);
+      }
+    });
+  });
+}
 
 /**
  * Used for ItemAccumulators that have an array of results returned per page instead of a single item.
@@ -4815,6 +4889,15 @@ function accumulatorCurrentPageListLoadingState(accumulator) {
     mapValue: () => values
   })), rxjs.shareReplay(1));
 }
+/**
+ * Returns the latest loaded page number from the input PageItemAccumulator.
+ *
+ * @param pageItemAccumulator
+ * @returns
+ */
+function pageItemAccumulatorCurrentPage(pageItemAccumulator) {
+  return pageItemAccumulator.itemIteration.latestLoadedPage$;
+}
 
 class MappedItemIterationInstance {
   constructor(itemIterator, config) {
@@ -5043,12 +5126,12 @@ class ItemPageIterationInstance {
     this.latestSuccessfulPageResults$ = this.state$.pipe(rxjs.map(x => x.lastSuccessful), filterMaybe(), rxjs.shareReplay(1));
     this.currentState$ = this.currentPageResultState$.pipe(mapItemPageLoadingStateFromResultPageLoadingState(), rxjs.shareReplay(1));
     this.latestLoadedPage$ = this.latestPageResultState$.pipe(rxjs.map(x => x.page), rxjs.distinctUntilChanged(), rxjs.shareReplay(1));
-    this.numberOfPagesLoaded$ = this.latestLoadedPage$.pipe(rxjs.map(x => x + 1), rxjs.shareReplay(1));
+    this.numberOfPagesLoaded$ = this.latestLoadedPage$.pipe(rxjs.map(x => x + 1), rxjs.defaultIfEmpty(0), rxjs.shareReplay(1));
     // MARK: ItemIteration
     /**
      * Whether or not there are more results to load.
      */
-    this.hasNext$ = this.hasReachedEndResult$.pipe(rxjs.map(x => !x), rxjs.shareReplay(1));
+    this.hasNext$ = this.hasReachedEndResult$.pipe(rxjs.map(x => !x), rxjs.defaultIfEmpty(false), rxjs.shareReplay(1));
     /**
      * Whether or not the successfulPageResultsCount has passed the maxPageLoadLimit
      */
@@ -5070,18 +5153,24 @@ class ItemPageIterationInstance {
     this._maxPageLoadLimit.next(limit);
   }
   nextPage(request = {}) {
-    return new Promise((resolve, reject) => {
-      this._nextFinished$.pipe(rxjs.exhaustMap(() => this.latestPageResultState$), rxjs.first()).subscribe({
+    return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+      this._nextFinished$.pipe(rxjs.exhaustMap(() => this.latestPageResultState$), rxjs.defaultIfEmpty({
+        error: undefined,
+        page: -1
+      }), rxjs.first()).subscribe({
         next: latestState => {
           if (latestState.error) {
             reject(latestState.error);
           } else {
             resolve(latestState.page);
           }
+        },
+        error: error => {
+          reject(error);
         }
       });
       this.next(request);
-    });
+    }));
   }
   next(request = {}) {
     this._pushNext(request);
@@ -5535,6 +5624,7 @@ exports.isLoading = isLoading;
 exports.isNot = isNot;
 exports.isSuccessLoadingState = isSuccessLoadingState;
 exports.itemAccumulator = itemAccumulator;
+exports.itemAccumulatorNextPageUntilResultsCount = itemAccumulatorNextPageUntilResultsCount;
 exports.iterationHasNextAndCanLoadMore = iterationHasNextAndCanLoadMore;
 exports.iteratorNextPageUntilMaxPageLoadLimit = iteratorNextPageUntilMaxPageLoadLimit;
 exports.iteratorNextPageUntilPage = iteratorNextPageUntilPage;
@@ -5576,6 +5666,7 @@ exports.onFalseToTrue = onFalseToTrue;
 exports.onLockSetNextUnlock = onLockSetNextUnlock;
 exports.onMatchDelta = onMatchDelta;
 exports.onTrueToFalse = onTrueToFalse;
+exports.pageItemAccumulatorCurrentPage = pageItemAccumulatorCurrentPage;
 exports.pageLoadingStateFromObs = pageLoadingStateFromObs;
 exports.pipeIf = pipeIf;
 exports.preventComplete = preventComplete;

package/index.esm.js

@@ -1,5 +1,5 @@
-import { isObservable, of, switchMap, map, filter, skipWhile, EMPTY, combineLatest, delay, startWith, distinctUntilChanged, mergeMap, BehaviorSubject, shareReplay, skip, first, merge, finalize, scan, exhaustMap, identity, throttleTime, timeout, tap, throwError, timer, takeWhile, delayWhen, asyncScheduler, from, catchError, firstValueFrom, defaultIfEmpty } from 'rxjs';
-import { getValueFromGetter, isMaybeSo, areEqualPOJOValues, convertToArray, reduceBooleansWithAndFn, asGetter, performTaskLoop, isMaybeNot, pushItemOrArrayItemsIntoArray, pushArrayItemsIntoArray, forEachWithArray, asArray, filterAndMapFunction, objectKeysEqualityComparatorFunction, objectKeyEqualityComparatorFunction, asPromise, randomNumberFactory, mapKeysIntersectionObjectToArray, mapsHaveSameKeys, incrementingNumberFactory, filterUniqueFunction, build, cachedGetter, allKeyValueTuples, keyValueMapFactory, multiKeyValueMapFactory, 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 } from '@dereekb/util';
+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 { 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, 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 } from '@dereekb/util';
 import ms from 'ms';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -3283,7 +3283,13 @@ $$1({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
  * @returns
  */
 function iterationHasNextAndCanLoadMore(iteration) {
-  return combineLatest([iteration.hasNext$, iteration.canLoadMore$]).pipe(map(reduceBooleansWithAndFn(true)), shareReplay(1));
+  return iteration.canLoadMore$.pipe(switchMap(canLoadMore => {
+    if (canLoadMore) {
+      return iteration.hasNext$;
+    } else {
+      return of(false);
+    }
+  }), shareReplay(1));
 }
 
 /**
@@ -3325,14 +3331,19 @@ function iteratorNextPageUntilPage(iteration, page) {
     const maxLimit = Math.min(pageLimit, (_iteration$maxPageLoa = iteration.maxPageLoadLimit) != null ? _iteration$maxPageLoa : Number.MAX_SAFE_INTEGER);
     return page + 1 < maxLimit;
   }
-  return new Promise(resolve => {
-    iteration.latestLoadedPage$.pipe(first()).subscribe(firstLatestPage => {
-      const promise = performTaskLoop({
-        initValue: firstLatestPage,
-        checkContinue: latestPage => checkPageLimit(latestPage),
-        next: async () => await iteration.nextPage()
-      });
-      resolve(promise);
+  return new Promise((resolve, reject) => {
+    iteration.latestLoadedPage$.pipe(first()).subscribe({
+      next: firstLatestPage => {
+        const promise = performTaskLoop({
+          initValue: firstLatestPage,
+          checkContinue: async latestPage => firstValueFrom(iterationHasNextAndCanLoadMore(iteration)).then(canLoadMore => canLoadMore && checkPageLimit(latestPage)),
+          next: async () => await iteration.nextPage()
+        });
+        resolve(promise);
+      },
+      error: error => {
+        reject(error);
+      }
     });
   });
 }
@@ -5097,6 +5108,66 @@ function itemAccumulator(itemIteration, mapItem) {
   return new ItemAccumulatorInstance(itemIteration, mapItem);
 }
 
+// MARK: Utility
+
+/**
+ * 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 {
+    accumulator,
+    maxResultsLimit,
+    countResultsFunction: countResults
+  } = config;
+  const getMaxResultsLimit = asGetter(maxResultsLimit);
+  const canLoadMoreObs = iterationHasNextAndCanLoadMore(accumulator.itemIteration).pipe(timeoutStartWith(false, 100),
+  // TODO: This can fail to emit anything if the iterator has been destroyed
+  shareReplay(1));
+  async function checkResultsLimit() {
+    const allItems = await firstValueFrom(accumulator.currentAllItems$);
+    const canLoadMore = await firstValueFrom(canLoadMoreObs);
+    const currentCount = await countResults(allItems);
+    const maxResultsLimit = getMaxResultsLimit();
+    const shouldContinue = canLoadMore && currentCount < maxResultsLimit;
+    return {
+      shouldContinue,
+      currentCount
+    };
+  }
+  return new Promise((resolve, reject) => {
+    accumulator.currentAllItems$.pipe(first(), switchMap(allItems => from(asPromise(countResults(allItems))))).subscribe({
+      next: async currentResultsCount => {
+        performTaskLoop({
+          initValue: currentResultsCount,
+          checkContinue: async (x, i) => {
+            const result = await checkResultsLimit();
+            currentResultsCount = result.currentCount;
+            return result.shouldContinue;
+          },
+          next: async () => accumulator.itemIteration.nextPage()
+        }).then(page => {
+          resolve({
+            page,
+            resultsCount: currentResultsCount
+          });
+        }).catch(error => {
+          reject(error);
+          throw error;
+        });
+      },
+      error: error => {
+        reject(error);
+      }
+    });
+  });
+}
+
 /**
  * Used for ItemAccumulators that have an array of results returned per page instead of a single item.
  *
@@ -5139,6 +5210,16 @@ function accumulatorCurrentPageListLoadingState(accumulator) {
   })), shareReplay(1));
 }
 
+/**
+ * Returns the latest loaded page number from the input PageItemAccumulator.
+ *
+ * @param pageItemAccumulator
+ * @returns
+ */
+function pageItemAccumulatorCurrentPage(pageItemAccumulator) {
+  return pageItemAccumulator.itemIteration.latestLoadedPage$;
+}
+
 /**
  * An object that maps loading states from one mapping to another.
  */
@@ -5384,12 +5465,12 @@ class ItemPageIterationInstance {
     this.latestSuccessfulPageResults$ = this.state$.pipe(map(x => x.lastSuccessful), filterMaybe(), shareReplay(1));
     this.currentState$ = this.currentPageResultState$.pipe(mapItemPageLoadingStateFromResultPageLoadingState(), shareReplay(1));
     this.latestLoadedPage$ = this.latestPageResultState$.pipe(map(x => x.page), distinctUntilChanged(), shareReplay(1));
-    this.numberOfPagesLoaded$ = this.latestLoadedPage$.pipe(map(x => x + 1), shareReplay(1));
+    this.numberOfPagesLoaded$ = this.latestLoadedPage$.pipe(map(x => x + 1), defaultIfEmpty(0), shareReplay(1));
     // MARK: ItemIteration
     /**
      * Whether or not there are more results to load.
      */
-    this.hasNext$ = this.hasReachedEndResult$.pipe(map(x => !x), shareReplay(1));
+    this.hasNext$ = this.hasReachedEndResult$.pipe(map(x => !x), defaultIfEmpty(false), shareReplay(1));
     /**
      * Whether or not the successfulPageResultsCount has passed the maxPageLoadLimit
      */
@@ -5411,17 +5492,24 @@ class ItemPageIterationInstance {
     this._maxPageLoadLimit.next(limit);
   }
   nextPage(request = {}) {
-    return new Promise((resolve, reject) => {
-      this._nextFinished$.pipe(exhaustMap(() => this.latestPageResultState$), first()).subscribe({
+    var _this = this;
+    return new Promise(async function (resolve, reject) {
+      _this._nextFinished$.pipe(exhaustMap(() => _this.latestPageResultState$), defaultIfEmpty({
+        error: undefined,
+        page: -1
+      }), first()).subscribe({
         next: latestState => {
           if (latestState.error) {
             reject(latestState.error);
           } else {
             resolve(latestState.page);
           }
+        },
+        error: error => {
+          reject(error);
         }
       });
-      this.next(request);
+      _this.next(request);
     });
   }
   next(request = {}) {
@@ -5839,4 +5927,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, errorPageResult, errorResult, factoryTimer, filterIfObjectValuesUnchanged, filterItemsWithObservableDecision, filterMaybe, filterUnique, filterWithSearchString, flattenAccumulatorResultItemArray, idleLoadingState, incrementingNumberTimer, initialize, invertObservableDecision, isErrorLoadingState, isItemPageIteratorResultEndResult, isListLoadingStateEmpty, isLoading, isNot, isSuccessLoadingState, itemAccumulator, 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, 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, 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, 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/rxjs",
-  "version": "10.0.20",
+  "version": "10.0.22",
   "exports": {
     ".": {
       "types": "./src/index.d.ts",

package/src/lib/iterator/iteration.accumulator.d.ts

@@ -1,5 +1,5 @@
 import { type Observable } from 'rxjs';
-import { type MapFunctionOutputPair, type Destroyable, type IndexRef } from '@dereekb/util';
+import { type MapFunctionOutputPair, type Destroyable, type IndexRef, type GetterOrValue, type MapFunction, type PromiseOrValue, type Page } from '@dereekb/util';
 import { type ItemIteration, type PageItemIteration } from './iteration';
 import { type LoadingState, type MapLoadingStateValueMapFunction } from '../loading';
 export type ItemAccumulatorMapFunction<O, I> = MapLoadingStateValueMapFunction<O, I>;
@@ -83,3 +83,22 @@ export declare class ItemAccumulatorInstance<O, I = unknown, N extends ItemItera
  */
 export declare function itemAccumulator<I, N extends ItemIteration<I> = ItemIteration<I>>(itemIteration: N): ItemAccumulatorInstance<I, I, N>;
 export declare function itemAccumulator<O, I, N extends ItemIteration<I> = ItemIteration<I>>(itemIteration: N, mapItem?: ItemAccumulatorMapFunction<O, I>): ItemAccumulatorInstance<O, I, N>;
+export type ItemAccumulatorNextPageUntilResultsCountFunction<O> = MapFunction<O[], PromiseOrValue<number>>;
+export interface ItemAccumulatorNextPageUntilResultsCountConfig<O> {
+    readonly accumulator: ItemAccumulator<O, any, PageItemIteration<any>>;
+    readonly maxResultsLimit: GetterOrValue<number>;
+    readonly countResultsFunction: ItemAccumulatorNextPageUntilResultsCountFunction<O>;
+}
+export interface ItemAccumulatorNextPageUntilResultsCountResult extends Page {
+    readonly resultsCount: number;
+}
+/**
+ * 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
+ */
+export declare function itemAccumulatorNextPageUntilResultsCount<O>(config: ItemAccumulatorNextPageUntilResultsCountConfig<O>): Promise<ItemAccumulatorNextPageUntilResultsCountResult>;

package/src/lib/iterator/iteration.accumulator.rxjs.d.ts

@@ -16,3 +16,10 @@ export declare function accumulatorFlattenPageListLoadingState<T, I = unknown>(a
  * A PageListLoadingState that captures all the values that have been loaded so far, and the current loading state of currentPageResult$.
  */
 export declare function accumulatorCurrentPageListLoadingState<V, I = unknown>(accumulator: PageItemAccumulator<V, I>): Observable<PageListLoadingState<V>>;
+/**
+ * Returns the latest loaded page number from the input PageItemAccumulator.
+ *
+ * @param pageItemAccumulator
+ * @returns
+ */
+export declare function pageItemAccumulatorCurrentPage(pageItemAccumulator: PageItemAccumulator<any, any>): Observable<number>;

package/src/lib/iterator/iteration.d.ts

@@ -14,7 +14,21 @@ export interface ItemIteratorNextRequest {
     retry?: boolean;
 }
 export interface ItemIteration<V = unknown, L extends LoadingState<V> = LoadingState<V>> extends Destroyable {
+    /**
+     * Whether or not there are more items to be loaded.
+     *
+     * This emits every time a page has finished loading.
+     *
+     * This will not return false when the max page limit has been reached.
+     */
     readonly hasNext$: Observable<boolean>;
+    /**
+     * Whether or not more items can be loaded.
+     *
+     * Similar to hasNext$ but does not emit until the value changes.
+     *
+     * This returns false if the max page limit has been reached.
+     */
     readonly canLoadMore$: Observable<boolean>;
     /**
      * The first stable state that has finished loading.
@@ -50,7 +64,7 @@ export interface PageItemIteration<V = unknown, L extends PageLoadingState<V> =
     /**
      * Attempts to loads the next page of results and returns a promise.
      *
-     * The promise will return when the next action has completed.
+     * The promise will return when the next action has completed, and returns the page number of the loaded page.
      *
      * If the page result ends in an error, this promise will throw that error.
      *

package/src/lib/iterator/iteration.next.d.ts

@@ -1,6 +1,6 @@
 import { type Observable } from 'rxjs';
 import { type ItemIteration, type PageItemIteration } from './iteration';
-import { type Maybe, type GetterOrValue } from '@dereekb/util';
+import { type Maybe, type GetterOrValue, type PageNumber } from '@dereekb/util';
 /**
  * Creates an observable from the input iteration that checks both the hasNext$ and canLoadMore$ states.
  *
@@ -29,4 +29,4 @@ export declare function iteratorNextPageUntilMaxPageLoadLimit(iterator: PageItem
  * @param page
  * @returns
  */
-export declare function iteratorNextPageUntilPage(iteration: PageItemIteration, page: GetterOrValue<number>): Promise<number>;
+export declare function iteratorNextPageUntilPage(iteration: PageItemIteration, page: GetterOrValue<number>): Promise<PageNumber>;

package/src/lib/iterator/iterator.page.d.ts

@@ -165,7 +165,7 @@ export declare class ItemPageIterationInstance<V, F, C extends ItemPageIteration
     nextPage(request?: ItemIteratorNextRequest): Promise<number>;
     readonly currentState$: Observable<PageLoadingState<V>>;
     readonly latestLoadedPage$: Observable<PageNumber>;
-    readonly numberOfPagesLoaded$: Observable<PageNumber>;
+    readonly numberOfPagesLoaded$: Observable<number>;
     /**
      * Whether or not there are more results to load.
      */