@dereekb/rxjs 13.43.0 → 14.0.1

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@dereekb/rxjs",
-  "version": "13.43.0",
+  "version": "14.0.1",
   "type": "module",
   "sideEffects": false,
   "peerDependencies": {
     "rxjs": "^7.8.2",
-    "@dereekb/util": "13.43.0"
+    "@dereekb/util": "14.0.1"
   },
   "exports": {
     "./package.json": "./package.json",

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

@@ -1,16 +1,16 @@
 import { type Observable } from 'rxjs';
 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';
+import { type LoadingState, type PageLoadingState, type MapLoadingStateValueMapFunction } from '../loading';
 /**
  * Function that maps loaded values from their raw iteration type to the accumulator's output type.
  */
-export type ItemAccumulatorMapFunction<O, I> = MapLoadingStateValueMapFunction<O, I>;
+export type ItemAccumulatorMapFunction<O, I> = MapLoadingStateValueMapFunction<LoadingState<I>, O>;
 /**
  * Accumulates values from an {@link ItemIteration} into a growing collection,
  * optionally mapping each value through a transform function.
  */
-export interface ItemAccumulator<O, I = unknown, N extends ItemIteration<I> = ItemIteration<I>> {
+export interface ItemAccumulator<O, I = unknown, N extends ItemIteration<LoadingState<I>> = ItemIteration<LoadingState<I>>> {
     /**
      * Iteration being accumulated.
      */
@@ -43,15 +43,15 @@ export interface ItemAccumulator<O, I = unknown, N extends ItemIteration<I> = It
 /**
  * An object that accumulates and exposes values from a PageItemIteration.
  */
-export type PageItemAccumulator<O, I = unknown, N extends PageItemIteration<I> = PageItemIteration<I>> = ItemAccumulator<O, I, N>;
+export type PageItemAccumulator<O, I = unknown, N extends PageItemIteration<PageLoadingState<I>> = PageItemIteration<PageLoadingState<I>>> = ItemAccumulator<O, I, N>;
 /**
  * An accumulator with no mapping.
  */
-export type MonotypeItemAccumulator<I, N extends ItemIteration<I> = ItemIteration<I>> = ItemAccumulator<I, I, N>;
+export type MonotypeItemAccumulator<I, N extends ItemIteration<LoadingState<I>> = ItemIteration<LoadingState<I>>> = ItemAccumulator<I, I, N>;
 /**
  * A page accumulator with no mapping.
  */
-export type MonotypePageItemAccumulator<I, N extends PageItemIteration<I> = PageItemIteration<I>> = ItemAccumulator<I, I, N>;
+export type MonotypePageItemAccumulator<I, N extends PageItemIteration<PageLoadingState<I>> = PageItemIteration<PageLoadingState<I>>> = ItemAccumulator<I, I, N>;
 /**
  * Value of an item accumulator.
  */
@@ -61,7 +61,7 @@ export interface ItemAccumulatorValuePair<O, I = unknown> extends MapFunctionOut
  * Concrete accumulator instance with additional observables for tracking load progress
  * and successful states.
  */
-export interface ItemAccumulatorInstance<O, I = unknown, N extends ItemIteration<I> = ItemIteration<I>> extends ItemAccumulator<O, I, N>, Destroyable {
+export interface ItemAccumulatorInstance<O, I = unknown, N extends ItemIteration<LoadingState<I>> = ItemIteration<LoadingState<I>>> extends ItemAccumulator<O, I, N>, Destroyable {
     /**
      * Emits `true` once the first load has completed.
      */
@@ -90,8 +90,8 @@ export interface ItemAccumulatorInstance<O, I = unknown, N extends ItemIteration
  * @param inputMapItem - optional function to transform raw values into the desired output type
  * @returns accumulator instance with observables for all collected items
  */
-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 declare function itemAccumulator<I, N extends ItemIteration<LoadingState<I>> = ItemIteration<LoadingState<I>>>(itemIteration: N): ItemAccumulatorInstance<I, I, N>;
+export declare function itemAccumulator<O, I, N extends ItemIteration<LoadingState<I>> = ItemIteration<LoadingState<I>>>(itemIteration: N, mapItem?: ItemAccumulatorMapFunction<O, I>): ItemAccumulatorInstance<O, I, N>;
 /**
  * Function that counts the number of meaningful results in the accumulated items array.
  */
@@ -103,7 +103,7 @@ export interface ItemAccumulatorNextPageUntilResultsCountConfig<O> {
     /**
      * The accumulator whose iteration will be advanced.
      */
-    readonly accumulator: ItemAccumulator<O, any, PageItemIteration<any>>;
+    readonly accumulator: ItemAccumulator<O, any, PageItemIteration<PageLoadingState<any>>>;
     /**
      * Target number of results to accumulate before stopping.
      */

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

@@ -21,7 +21,7 @@ export interface ItemIteratorNextRequest {
  * Consumers call {@link next} to trigger loading of the next batch and observe results
  * through the various state observables.
  */
-export interface ItemIteration<V = unknown, L extends LoadingState<V> = LoadingState<V>> extends Destroyable {
+export interface ItemIteration<L extends LoadingState = LoadingState> extends Destroyable {
     /**
      * Whether or not there are more items to be loaded.
      *
@@ -61,7 +61,7 @@ export interface ItemIteration<V = unknown, L extends LoadingState<V> = LoadingS
  * Adds page-specific operations like {@link nextPage} (promise-based) and page load limits
  * to prevent unbounded iteration.
  */
-export interface PageItemIteration<V = unknown, L extends PageLoadingState<V> = PageLoadingState<V>> extends ItemIteration<V, L> {
+export interface PageItemIteration<L extends PageLoadingState = PageLoadingState> extends ItemIteration<L> {
     /**
      * Returns the maximum number of pages allowed to be loaded.
      *

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

@@ -1,4 +1,4 @@
-import { type LoadingState, type MapLoadingStateResultsConfiguration, type PageLoadingState } from '../loading';
+import { type LoadingState, type LoadingStateValue, type MapLoadingStateResultsConfiguration } from '../loading';
 import { type Destroyable } from '@dereekb/util';
 import { type Observable } from 'rxjs';
 import { type ItemIteration, type ItemIteratorNextRequest } from './iteration';
@@ -6,7 +6,7 @@ import { type ItemIteration, type ItemIteratorNextRequest } from './iteration';
  * An {@link ItemIteration} wrapper that transforms loading state values from one type to another
  * while preserving the iteration interface.
  */
-export interface MappedItemIteration<O, I = unknown, M extends LoadingState<O> = LoadingState<O>, L extends LoadingState<I> = LoadingState<I>, N extends ItemIteration<I, L> = ItemIteration<I, L>> extends ItemIteration<O, M> {
+export interface MappedItemIteration<M extends LoadingState, L extends LoadingState, N extends ItemIteration<L> = ItemIteration<L>> extends ItemIteration<M> {
     /**
      * Iteration being accumulated.
      */
@@ -16,7 +16,7 @@ export interface MappedItemIteration<O, I = unknown, M extends LoadingState<O> =
  * Configuration for creating a {@link MappedItemIterationInstance}, extending the loading state
  * mapping configuration with lifecycle options.
  */
-export interface MappedItemIterationInstanceMapConfig<O, I, M extends LoadingState<O> = PageLoadingState<O>, L extends LoadingState<I> = PageLoadingState<I>> extends MapLoadingStateResultsConfiguration<I, O, L, M> {
+export interface MappedItemIterationInstanceMapConfig<L extends LoadingState, M extends LoadingState> extends MapLoadingStateResultsConfiguration<L, LoadingStateValue<M>, M> {
     /**
      * Whether destroying the mapped instance also destroys the underlying iteration.
      * Defaults to `true`.
@@ -27,9 +27,9 @@ export interface MappedItemIterationInstanceMapConfig<O, I, M extends LoadingSta
  * Concrete instance of a mapped item iteration, exposing the transformed state observables
  * and the underlying iterator and configuration.
  */
-export interface MappedItemIterationInstance<O, I = unknown, M extends LoadingState<O> = LoadingState<O>, L extends LoadingState<I> = LoadingState<I>, N extends ItemIteration<I, L> = ItemIteration<I, L>> extends ItemIteration<O>, Destroyable {
+export interface MappedItemIterationInstance<M extends LoadingState, L extends LoadingState, N extends ItemIteration<L> = ItemIteration<L>> extends ItemIteration<M>, Destroyable {
     readonly itemIterator: N;
-    readonly config: MappedItemIterationInstanceMapConfig<O, I, M, L>;
+    readonly config: MappedItemIterationInstanceMapConfig<L, M>;
     readonly hasNext$: Observable<boolean>;
     readonly canLoadMore$: Observable<boolean>;
     readonly firstState$: Observable<M>;
@@ -47,4 +47,4 @@ export interface MappedItemIterationInstance<O, I = unknown, M extends LoadingSt
  * @param config - Mapping configuration for transforming loading state values.
  * @returns Mapped iteration instance with transformed state observables.
  */
-export declare function mapItemIteration<O, I = unknown, M extends LoadingState<O> = LoadingState<O>, L extends LoadingState<I> = LoadingState<I>, N extends ItemIteration<I, L> = ItemIteration<I, L>>(itemIterator: N, config: MappedItemIterationInstanceMapConfig<O, I, M, L>): MappedItemIterationInstance<O, I, M, L, N>;
+export declare function mapItemIteration<M extends LoadingState, L extends LoadingState, N extends ItemIteration<L> = ItemIteration<L>>(itemIterator: N, config: MappedItemIterationInstanceMapConfig<L, M>): MappedItemIterationInstance<M, L, N>;

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

@@ -4,12 +4,12 @@ import { type MappedItemIteration, type MappedItemIterationInstance, type Mapped
 /**
  * {@link MappedItemIteration} specialized for {@link PageItemIteration}, preserving page-specific loading state types.
  */
-export type MappedPageItemIteration<O, I = unknown, M extends PageLoadingState<O> = PageLoadingState<O>, L extends PageLoadingState<I> = PageLoadingState<I>, N extends PageItemIteration<I, L> = PageItemIteration<I, L>> = MappedItemIteration<O, I, M, L, N>;
+export type MappedPageItemIteration<M extends PageLoadingState, L extends PageLoadingState, N extends PageItemIteration<L> = PageItemIteration<L>> = MappedItemIteration<M, L, N>;
 /**
  * Instance of a mapped page iteration that implements both {@link MappedItemIterationInstance}
  * and {@link PageItemIteration}, providing transformed states alongside page-specific operations.
  */
-export interface MappedPageItemIterationInstance<O, I = unknown, M extends PageLoadingState<O> = PageLoadingState<O>, L extends PageLoadingState<I> = PageLoadingState<I>, N extends PageItemIteration<I, L> = PageItemIteration<I, L>> extends MappedItemIterationInstance<O, I, M, L, N>, PageItemIteration<O, M> {
+export interface MappedPageItemIterationInstance<M extends PageLoadingState, L extends PageLoadingState, N extends PageItemIteration<L> = PageItemIteration<L>> extends MappedItemIterationInstance<M, L, N>, PageItemIteration<M> {
 }
 /**
  * Creates a {@link MappedPageItemIterationInstance} that wraps a {@link PageItemIteration}
@@ -20,4 +20,4 @@ export interface MappedPageItemIterationInstance<O, I = unknown, M extends PageL
  * @param config - Mapping configuration for transforming loading state values.
  * @returns Mapped page iteration instance.
  */
-export declare function mappedPageItemIteration<O, I = unknown, M extends PageLoadingState<O> = PageLoadingState<O>, L extends PageLoadingState<I> = PageLoadingState<I>, N extends PageItemIteration<I, L> = PageItemIteration<I, L>>(itemIteration: N, config: MappedItemIterationInstanceMapConfig<O, I, M, L>): MappedPageItemIterationInstance<O, I, M, L, N>;
+export declare function mappedPageItemIteration<M extends PageLoadingState, L extends PageLoadingState, N extends PageItemIteration<L> = PageItemIteration<L>>(itemIteration: N, config: MappedItemIterationInstanceMapConfig<L, M>): MappedPageItemIterationInstance<M, L, N>;

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

@@ -8,7 +8,7 @@ import { type Maybe, type GetterOrValue, type PageNumber } from '@dereekb/util';
  * @param iteration - The iteration to check.
  * @returns Observable that emits `true` when more items can be loaded.
  */
-export declare function iterationHasNextAndCanLoadMore<V>(iteration: ItemIteration<V>): Observable<boolean>;
+export declare function iterationHasNextAndCanLoadMore(iteration: ItemIteration): Observable<boolean>;
 /**
  * Automatically pages through a {@link PageItemIteration} until its configured max page load limit is reached.
  *

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

@@ -143,7 +143,7 @@ export interface ItemPageIterationInstanceState<V> {
  * tracking loading/success/error states, and exposing all results as reactive observables.
  * Implements {@link PageItemIteration} for use with accumulators and other iteration utilities.
  */
-export declare class ItemPageIterationInstance<V, F, C extends ItemPageIterationConfig<F> = ItemPageIterationConfig<F>> implements PageItemIteration<V, PageLoadingState<V>>, Destroyable {
+export declare class ItemPageIterationInstance<V, F, C extends ItemPageIterationConfig<F> = ItemPageIterationConfig<F>> implements PageItemIteration<PageLoadingState<V>>, Destroyable {
     private readonly _iterator;
     private readonly _config;
     /**

package/src/lib/loading/loading.context.state.list.d.ts

@@ -2,19 +2,19 @@ import { type LimitArrayConfig, type Maybe } from '@dereekb/util';
 import { type Observable } from 'rxjs';
 import { type ListLoadingState } from './loading.state';
 import { type LoadingStateContext, type LoadingStateContextConfig, type LoadingStateContextInput, type MutableLoadingStateContext } from './loading.context.state';
-export interface ListLoadingStateContext<L = unknown, S extends ListLoadingState<L> = ListLoadingState<L>> extends Omit<LoadingStateContext<L[], S>, 'value$' | 'currentValue$' | 'valueAfterLoaded$'> {
+export interface ListLoadingStateContext<T = unknown, S extends ListLoadingState<T> = ListLoadingState<T>> extends Omit<LoadingStateContext<T[], S>, 'value$' | 'currentValue$' | 'valueAfterLoaded$'> {
     /**
      * The current list. Always provided, even while loading.
      */
-    readonly currentList$: Observable<Maybe<L[]>>;
+    readonly currentList$: Observable<Maybe<T[]>>;
     /**
      * The latest list from the most recent loaded state.
      */
-    readonly listAfterLoaded$: Observable<Maybe<L[]>>;
+    readonly listAfterLoaded$: Observable<Maybe<T[]>>;
     /**
      * The latest list from listAfterLoaded$, or a default value if the list was empty.
      */
-    readonly list$: Observable<L[]>;
+    readonly list$: Observable<T[]>;
     /**
      * Whether or not the currentList$ value is empty.
      *
@@ -39,15 +39,15 @@ export interface ListLoadingStateContext<L = unknown, S extends ListLoadingState
 /**
  * A ListLoadingStateContext that can be updated and destroyed.
  */
-export type MutableListLoadingStateContext<L = unknown, S extends ListLoadingState<L> = ListLoadingState<L>> = ListLoadingStateContext<L, S> & Pick<MutableLoadingStateContext<L[], S>, 'setStateObs' | 'destroy'>;
+export type MutableListLoadingStateContext<T = unknown, S extends ListLoadingState<T> = ListLoadingState<T>> = ListLoadingStateContext<T, S> & Pick<MutableLoadingStateContext<T[], S>, 'setStateObs' | 'destroy'>;
 /**
  * Configuration for listLoadingStateContext().
  */
-export type ListLoadingStateContextConfig<L, S extends ListLoadingState<L> = ListLoadingState<L>> = Omit<LoadingStateContextConfig<L[], S>, 'loadingEventForLoadingPair'> & Partial<LimitArrayConfig>;
+export type ListLoadingStateContextConfig<T, S extends ListLoadingState<T> = ListLoadingState<T>> = Omit<LoadingStateContextConfig<T[], S>, 'loadingEventForLoadingPair'> & Partial<LimitArrayConfig>;
 /**
  * Input for listLoadingStateContext().
  */
-export type ListLoadingStateContextInput<L, S extends ListLoadingState<L> = ListLoadingState<L>> = Omit<LoadingStateContextInput<L[], S>, 'loadingEventForLoadingPair'> | ListLoadingStateContextConfig<L, S>;
+export type ListLoadingStateContextInput<T, S extends ListLoadingState<T> = ListLoadingState<T>> = Omit<LoadingStateContextInput<T[], S>, 'loadingEventForLoadingPair'> | ListLoadingStateContextConfig<T, S>;
 /**
  * Creates a {@link MutableListLoadingStateContext} that wraps a {@link ListLoadingState} observable
  * and provides list-specific reactive accessors like `isEmpty$` and `list$`.
@@ -76,4 +76,4 @@ export type ListLoadingStateContextInput<L, S extends ListLoadingState<L> = List
  * context.destroy();
  * ```
  */
-export declare function listLoadingStateContext<L, S extends ListLoadingState<L> = ListLoadingState<L>>(input?: ListLoadingStateContextInput<L, S>): MutableListLoadingStateContext<L, S>;
+export declare function listLoadingStateContext<T, S extends ListLoadingState<T> = ListLoadingState<T>>(input?: ListLoadingStateContextInput<T, S>): MutableListLoadingStateContext<T, S>;