@dereekb/rxjs 13.43.0 → 14.0.1

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

@@ -1,4 +1,4 @@
-import { type Maybe, type ReadableError, type ReadableDataError, type Page, type FilteredPage, type PageNumber, type MapFunction, type ErrorInput } from '@dereekb/util';
+import { type Maybe, type ReadableError, type ReadableDataError, type Page, type PageNumber, type MapFunction, type ErrorInput } from '@dereekb/util';
 import { type LoadingProgress } from './loading';
 /**
  * A value/error pair used in loading situations.
@@ -36,7 +36,7 @@ export interface LoadingErrorPair {
  * isLoadingStateEqual(a, c); // false
  * ```
  */
-export declare function isLoadingStateEqual<T extends LoadingState>(a: T, b: T): boolean;
+export declare function isLoadingStateEqual<L extends LoadingState>(a: L, b: L): boolean;
 /**
  * Compares the metadata (loading flag, loading progress, and error) of two {@link LoadingErrorPair} instances,
  * using loose equality for loading and nullish-aware comparison for progress and error.
@@ -50,18 +50,43 @@ export declare function isLoadingStateEqual<T extends LoadingState>(a: T, b: T):
 export declare function isLoadingStateMetadataEqual(a: Partial<LoadingErrorPair>, b: Partial<LoadingErrorPair>): boolean;
 /**
  * A value/error pair used in loading situations.
+ *
+ * The `T = unknown` default is deliberate: it makes the bare `LoadingState` the correct top type for
+ * an `L extends LoadingState` constraint, which every shape-preserving helper in this file relies on.
  */
 export interface LoadingState<T = unknown> extends LoadingErrorPair {
     readonly value?: Maybe<T>;
 }
 /**
  * Returns the value type inferred from the LoadingState type.
+ *
+ * This is a conditional type, and therefore a non-inferable position: a signature that mentions
+ * `LoadingStateValue<L>` in an argument position can never infer `L` from that argument. Use it only
+ * in callback-parameter positions and return types.
+ *
+ * Note that `LoadingStateValue<LoadingState<never>>` resolves to `unknown`, not `never`, because
+ * inferring `Maybe<never>` (which is `null | undefined`) against `Maybe<T>` leaves `T` candidate-less.
+ *
+ * The conditional `infer` body is kept intentionally; a `NonNullable<L['value']>` rewrite is
+ * functionally equivalent and removes no cast.
  */
 export type LoadingStateValue<L extends LoadingState> = L extends LoadingState<infer T> ? T : never;
 /**
  * Replaces the value type of the input LoadingState.
+ *
+ * The `L extends LoadingState ? ... : never` wrapper is load-bearing rather than dead code: it makes
+ * the type distribute over a union of state types. `Omit<A | B, K>` collapses a union down to its
+ * common keys, so without distribution a union containing a {@link PageLoadingState} would lose `page`.
  */
 export type LoadingStateWithValueType<L extends LoadingState, T> = L extends LoadingState ? Omit<L, 'value'> & LoadingState<T> : never;
+/**
+ * The result of re-deriving a {@link LoadingState} with its `value` and `error` cleared or replaced.
+ *
+ * The `value` and `error` keys are dropped from `S` before the plain {@link LoadingState} shape is
+ * re-added, because the merge helpers may clear a field that `S` itself requires (a
+ * `LoadingStateWithDefinedValue<Foo>` cannot honestly be returned once its value is cleared).
+ */
+export type MergedLoadingState<S extends LoadingState> = Omit<S, 'value' | 'error'> & LoadingState<LoadingStateValue<S>>;
 /**
  * Loading state with a value key.
  */
@@ -93,19 +118,10 @@ export interface PageLoadingState<T = unknown> extends LoadingState<T>, Page {
      */
     readonly hasNextPage?: Maybe<boolean>;
 }
-/**
- * PageLoadingState with a filter.
- */
-export interface FilteredPageLoadingState<T, F> extends PageLoadingState<T>, FilteredPage<F> {
-}
 /**
  * LoadingPageState that has an array of the values and
  */
-export type PageListLoadingState<T> = PageLoadingState<T[]>;
-/**
- * PageListLoadingState with a Filter.
- */
-export type FilteredPageListLoadingState<T, F> = FilteredPageLoadingState<T[], F>;
+export type PageListLoadingState<T = unknown> = PageLoadingState<T[]>;
 /**
  * Describes a LoadingState's current state type.
  */
@@ -177,7 +193,7 @@ export declare function isLoadingStateFinishedLoading<L extends LoadingState>(st
  * loadingStateType(state); // LoadingStateType.IDLE
  * ```
  */
-export declare function idleLoadingState<T>(): LoadingState<T>;
+export declare function idleLoadingState<T = never>(): LoadingState<T>;
 /**
  * Creates a {@link LoadingState} with `loading: true`, optionally merged with additional state properties.
  *
@@ -193,9 +209,9 @@ export declare function idleLoadingState<T>(): LoadingState<T>;
  * @param state - optional partial state to merge with the loading flag
  * @returns a loading state with `loading: true`
  */
-export declare function beginLoading<T>(): LoadingState<T>;
-export declare function beginLoading<T>(state?: Partial<PageLoadingState<T>>): PageLoadingState<T>;
-export declare function beginLoading<T>(state?: Partial<LoadingState<T>>): LoadingState<T>;
+export declare function beginLoading<T = never>(): LoadingState<T>;
+export declare function beginLoading<T = never>(state: Partial<LoadingState<T>> & Page): PageLoadingState<T>;
+export declare function beginLoading<T = never>(state?: Partial<LoadingState<T>>): LoadingState<T>;
 /**
  * Creates a {@link PageLoadingState} that is loading for the given page number.
  *
@@ -224,7 +240,7 @@ export declare function successResult<T>(value: T): LoadingStateWithValue<T>;
  * @param value - The loaded value.
  * @returns A page loading state representing success.
  */
-export declare function successPageResult<T>(page: PageNumber, value: T): PageLoadingState<T>;
+export declare function successPageResult<T>(page: PageNumber, value: T): PageLoadingState<T> & LoadingStateWithValue<T>;
 /**
  * Creates a {@link LoadingState} representing an error with `loading: false`.
  *
@@ -239,7 +255,8 @@ export declare function successPageResult<T>(page: PageNumber, value: T): PageLo
  * // { error: { message: 'Not found', ... }, loading: false }
  * ```
  */
-export declare function errorResult<T>(error?: Maybe<ErrorInput>): LoadingState<T>;
+export declare function errorResult<T = never>(error: ErrorInput): LoadingStateWithError<T>;
+export declare function errorResult<T = never>(error?: Maybe<ErrorInput>): LoadingState<T>;
 /**
  * Creates a {@link PageLoadingState} representing an error for a specific page.
  *
@@ -247,7 +264,7 @@ export declare function errorResult<T>(error?: Maybe<ErrorInput>): LoadingState<
  * @param error - The error to include.
  * @returns A page loading state representing an error.
  */
-export declare function errorPageResult<T>(page: PageNumber, error?: Maybe<ReadableError | ReadableDataError>): PageLoadingState<T>;
+export declare function errorPageResult<T = never>(page: PageNumber, error?: Maybe<ErrorInput>): PageLoadingState<T>;
 /**
  * Whether any of the given {@link LoadingState} instances are currently loading.
  *
@@ -260,7 +277,7 @@ export declare function errorPageResult<T>(page: PageNumber, error?: Maybe<Reada
  * isAnyLoadingStateInLoadingState([successResult(1), successResult(2)]); // false
  * ```
  */
-export declare function isAnyLoadingStateInLoadingState(states: LoadingState[]): boolean;
+export declare function isAnyLoadingStateInLoadingState(states: readonly LoadingState[]): boolean;
 /**
  * Whether all given {@link LoadingState} instances have finished loading.
  *
@@ -273,7 +290,7 @@ export declare function isAnyLoadingStateInLoadingState(states: LoadingState[]):
  * areAllLoadingStatesFinishedLoading([successResult(1), beginLoading()]); // false
  * ```
  */
-export declare function areAllLoadingStatesFinishedLoading(states: LoadingState[]): boolean;
+export declare function areAllLoadingStatesFinishedLoading(states: readonly LoadingState[]): boolean;
 /**
  * Creates a predicate function that checks whether a {@link LoadingState} matches the given {@link LoadingStateType}.
  *
@@ -328,7 +345,7 @@ export declare const isLoadingStateInErrorState: <L extends LoadingState>(state:
  * isLoadingStateWithDefinedValue(beginLoading()); // false
  * ```
  */
-export declare function isLoadingStateWithDefinedValue<L extends LoadingState>(state: Maybe<L> | LoadingStateWithDefinedValue<LoadingStateValue<L>>): state is LoadingStateWithDefinedValue<LoadingStateValue<L>>;
+export declare function isLoadingStateWithDefinedValue<L extends LoadingState>(state: Maybe<L>): state is L & LoadingStateWithDefinedValue<LoadingStateValue<L>>;
 /**
  * Type guard that checks whether a {@link LoadingState} has a non-null error, regardless of loading status.
  *
@@ -341,21 +358,21 @@ export declare function isLoadingStateWithDefinedValue<L extends LoadingState>(s
  * isLoadingStateWithError(successResult('ok')); // false
  * ```
  */
-export declare function isLoadingStateWithError<L extends LoadingState>(state: Maybe<L> | LoadingState<LoadingStateValue<L>>): state is LoadingStateWithError<LoadingStateValue<L>>;
+export declare function isLoadingStateWithError<L extends LoadingState>(state: Maybe<L>): state is L & LoadingStateWithError<LoadingStateValue<L>>;
 /**
  * Type guard that checks whether a {@link LoadingState} has finished loading and has a defined value.
  *
  * @param state - The loading state to check.
  * @returns True if finished loading with a non-undefined value.
  */
-export declare function isLoadingStateFinishedLoadingWithDefinedValue<L extends LoadingState>(state: Maybe<L> | LoadingStateWithDefinedValue<LoadingStateValue<L>>): state is LoadingStateWithDefinedValue<LoadingStateValue<L>>;
+export declare function isLoadingStateFinishedLoadingWithDefinedValue<L extends LoadingState>(state: Maybe<L>): state is L & LoadingStateWithDefinedValue<LoadingStateValue<L>>;
 /**
  * Type guard that checks whether a {@link LoadingState} has finished loading and has an error.
  *
  * @param state - The loading state to check.
  * @returns True if finished loading with an error.
  */
-export declare function isLoadingStateFinishedLoadingWithError<L extends LoadingState>(state: Maybe<L> | LoadingState<LoadingStateValue<L>>): state is LoadingStateWithError<LoadingStateValue<L>>;
+export declare function isLoadingStateFinishedLoadingWithError<L extends LoadingState>(state: Maybe<L>): state is L & LoadingStateWithError<LoadingStateValue<L>>;
 /**
  * Compares the metadata (page, loading, error) of two {@link PageLoadingState} instances for equivalence.
  *
@@ -379,6 +396,73 @@ export declare function isLoadingStateFinishedLoadingWithError<L extends Loading
  * ```
  */
 export declare function isPageLoadingStateMetadataEqual(a: Partial<PageLoadingState>, b: Partial<PageLoadingState>): boolean;
+/**
+ * Type guard that checks whether the input {@link LoadingState} also carries a {@link Page}.
+ *
+ * `Page` is intentionally kept orthogonal to `LoadingState`, so this is the supported way to ask a
+ * state whether it is paginated without hoisting page keys onto the base type.
+ *
+ * @param state - The loading state to check (may be null/undefined)
+ * @returns True when the state is present and exposes a numeric `page`.
+ *
+ * @example
+ * ```ts
+ * isPageLoadingState(successPageResult(0, 'a')); // true
+ * isPageLoadingState(successResult('a')); // false
+ * ```
+ */
+export declare function isPageLoadingState<L extends LoadingState>(state: Maybe<L>): state is L & Page;
+/**
+ * Reads the `hasNextPage` flag from the input state, if it carries one.
+ *
+ * @param state - The loading state to read from (may be null/undefined)
+ * @returns The `hasNextPage` value, or null/undefined when the state is absent or not paginated.
+ *
+ * @example
+ * ```ts
+ * loadingStateHasNextPage({ page: 0, loading: false, hasNextPage: true }); // true
+ * loadingStateHasNextPage(successResult('a')); // undefined
+ * ```
+ */
+export declare function loadingStateHasNextPage(state: Maybe<LoadingState>): Maybe<boolean>;
+/**
+ * Reads the value of a generic {@link LoadingState}.
+ *
+ * Reading `state.value` where `state: L` resolves through `L`'s apparent type (its constraint), which
+ * yields `Maybe<unknown>` rather than `Maybe<LoadingStateValue<L>>`. This is the single documented
+ * site that casts that back, so no other function in the library needs to.
+ *
+ * @param state - The loading state to read the value from.
+ * @returns The state's value, typed as the state's value type.
+ *
+ * @example
+ * ```ts
+ * loadingStateValue(successResult('a')); // 'a'
+ * loadingStateValue(beginLoading<string>()); // undefined
+ * ```
+ */
+export declare function loadingStateValue<L extends LoadingState>(state: L): Maybe<LoadingStateValue<L>>;
+/**
+ * Copies the input state, replacing only its value, and retypes the result to match.
+ *
+ * Distinct from {@link mergeLoadingStateWithValue}, which additionally forces `loading: false` and
+ * clears any error; this preserves the input state's metadata (including `loading` and `error`)
+ * exactly and swaps the value alone.
+ *
+ * @param state - The state to copy metadata from.
+ * @param value - The replacement value.
+ * @returns The state with its value type replaced.
+ *
+ * @example
+ * ```ts
+ * loadingStateWithValueType(successPageResult(0, 'a'), 1); // { page: 0, loading: false, value: 1 }
+ * ```
+ */
+export declare function loadingStateWithValueType<L extends LoadingState, T>(state: L, value: Maybe<T>): LoadingStateWithValueType<L, T>;
+/**
+ * Function used by {@link mergeLoadingStatesArray} to merge the values of the input states.
+ */
+export type MergeLoadingStatesArrayFunction<O> = (...values: any[]) => O;
 /**
  * Merges multiple {@link LoadingState} instances into a single combined state.
  *
@@ -418,9 +502,30 @@ export declare function mergeLoadingStates<A extends object, B extends object, C
 export declare function mergeLoadingStates<A extends object, B extends object, C extends object, O>(a: LoadingState<A>, b: LoadingState<B>, c: LoadingState<C>, mergeFn: (a: A, b: B, c: C) => O): LoadingState<O>;
 export declare function mergeLoadingStates<A extends object, B extends object, C extends object, D extends object>(a: LoadingState<A>, b: LoadingState<B>, c: LoadingState<C>, d: LoadingState<D>): LoadingState<A & B & C & D>;
 export declare function mergeLoadingStates<A extends object, B extends object, C extends object, D extends object, O>(a: LoadingState<A>, b: LoadingState<B>, c: LoadingState<C>, d: LoadingState<D>, mergeFn: (a: A, b: B, c: C, d: D) => O): LoadingState<O>;
-export declare function mergeLoadingStates<A extends object, B extends object, C extends object, D extends object, E extends object, O>(a: LoadingState<A>, b: LoadingState<B>, c: LoadingState<C>, d: LoadingState<D>, e: LoadingState<E>): LoadingState<A & B & C & D & E>;
+export declare function mergeLoadingStates<A extends object, B extends object, C extends object, D extends object, E extends object>(a: LoadingState<A>, b: LoadingState<B>, c: LoadingState<C>, d: LoadingState<D>, e: LoadingState<E>): LoadingState<A & B & C & D & E>;
 export declare function mergeLoadingStates<A extends object, B extends object, C extends object, D extends object, E extends object, O>(a: LoadingState<A>, b: LoadingState<B>, c: LoadingState<C>, d: LoadingState<D>, e: LoadingState<E>, mergeFn: (a: A, b: B, c: C, d: D, e: E) => O): LoadingState<O>;
 export declare function mergeLoadingStates<O>(...args: any[]): LoadingState<O>;
+/**
+ * Merges an array of {@link LoadingState} instances into a single combined state.
+ *
+ * The non-variadic counterpart to {@link mergeLoadingStates}: because the states arrive as one array
+ * argument rather than as rest arguments, the output value type `O` is inferable from `mergeFn` and
+ * the call site needs no cast.
+ *
+ * @param states - The loading states to merge.
+ * @param mergeFn - Optional function merging the states' values; defaults to `mergeObjects`.
+ * @returns The combined loading state.
+ *
+ * @example
+ * ```ts
+ * mergeLoadingStatesArray([successResult({ a: 1 }), successResult({ b: 2 })]);
+ * // { loading: false, value: { a: 1, b: 2 } }
+ *
+ * mergeLoadingStatesArray([successResult(1), successResult(2)], (a: number, b: number) => a + b);
+ * // { loading: false, value: 3 }
+ * ```
+ */
+export declare function mergeLoadingStatesArray<O>(states: readonly LoadingState[], mergeFn?: MergeLoadingStatesArrayFunction<O>): LoadingState<O>;
 /**
  * Returns a copy of the state with the value and error cleared, and `loading` set to the given flag.
  *
@@ -430,7 +535,7 @@ export declare function mergeLoadingStates<O>(...args: any[]): LoadingState<O>;
  * @param loading - Whether to mark as loading (defaults to true)
  * @returns A new state with value/error cleared.
  */
-export declare function mergeLoadingStateWithLoading<S extends LoadingState>(state: S, loading?: boolean): S;
+export declare function mergeLoadingStateWithLoading<S extends LoadingState>(state: S, loading?: boolean): MergedLoadingState<S>;
 /**
  * Returns a copy of the state with the given value, `loading: false`, and error cleared.
  *
@@ -438,7 +543,7 @@ export declare function mergeLoadingStateWithLoading<S extends LoadingState>(sta
  * @param value - The new value to set.
  * @returns A new state representing success.
  */
-export declare function mergeLoadingStateWithValue<S extends LoadingState>(state: S, value: LoadingStateValue<S> | undefined): S;
+export declare function mergeLoadingStateWithValue<S extends LoadingState>(state: S, value: Maybe<LoadingStateValue<S>>): MergedLoadingState<S>;
 /**
  * Returns a copy of the state with the given error and `loading: false`.
  *
@@ -446,29 +551,33 @@ export declare function mergeLoadingStateWithValue<S extends LoadingState>(state
  * @param error - The error to set.
  * @returns A new state representing an error.
  */
-export declare function mergeLoadingStateWithError<S extends LoadingState = LoadingState>(state: S, error?: ReadableDataError): S;
-export type MapMultipleLoadingStateValuesFn<T, X> = (input: X[]) => T;
-export interface MapMultipleLoadingStateResultsConfiguration<T, X, L extends LoadingState<X>[], R extends LoadingState<T>> {
-    readonly mapValues?: MapMultipleLoadingStateValuesFn<T, X>;
-    readonly mapState?: (input: L) => R;
-}
+export declare function mergeLoadingStateWithError<S extends LoadingState = LoadingState>(state: S, error?: ReadableDataError): MergedLoadingState<S>;
 /**
- * Maps multiple {@link LoadingState} results into a single state using a value mapping or state mapping function.
+ * Maps an entire input {@link LoadingState} (and its already-mapped value) to the output state.
  *
- * Returns `undefined` if any input is still loading or has an error.
+ * State-first, per the family-3 rule: `L` and `B` must resolve before `O`'s default is evaluated.
+ */
+export type MapLoadingStateFn<L extends LoadingState, B, O extends LoadingState = LoadingStateWithValueType<L, B>> = (input: L, value?: B) => O;
+/**
+ * Maps the value of an input {@link LoadingState} to the output value type.
+ */
+export type MapLoadingStateValuesFn<L extends LoadingState, B> = (input: LoadingStateValue<L>, state: L) => B;
+/**
+ * Configuration for {@link mapLoadingStateResults}.
+ *
+ * The type parameter order is load-bearing: the input state `L` comes first so that it (and then `B`,
+ * inferred from `mapValue`'s return) is resolved before `O`'s default is evaluated. Any other order
+ * leaves `O` — and with it the input state's shape, including `page` — degraded.
  *
- * @param input - Array of loading states to combine.
- * @param config - Mapping configuration with either `mapValues` or `mapState`
- * @returns The combined loading state, or undefined if inputs are not ready.
- * @throws {Error} When neither `mapValues` nor `mapState` is provided in the config.
+ * `O` is constrained to a bare {@link LoadingState} rather than to `LoadingState<B>`: a caller that
+ * threads its own output state type through (as the mapped-iteration layer does) cannot prove
+ * `M extends LoadingState<LoadingStateValue<M>>` while `M` is still generic. `mapState`'s signature
+ * still ties `O` back to `B`.
  */
-export declare function mapMultipleLoadingStateResults<T, X, L extends LoadingState<X>[], R extends LoadingState<T>>(input: L, config: MapMultipleLoadingStateResultsConfiguration<T, X, L, R>): Maybe<R>;
-export type MapLoadingStateFn<A, B, L extends LoadingState<A> = LoadingState<A>, O extends LoadingState<B> = LoadingState<B>> = (input: L, value?: B) => O;
-export type MapLoadingStateValuesFn<A, B, L extends LoadingState<A> = LoadingState<A>> = (input: A, state: L) => B;
-export interface MapLoadingStateResultsConfiguration<A, B, L extends LoadingState<A> = LoadingState<A>, O extends LoadingState<B> = LoadingState<B>> {
+export interface MapLoadingStateResultsConfiguration<L extends LoadingState, B, O extends LoadingState = LoadingStateWithValueType<L, B>> {
     readonly alwaysMapValue?: boolean;
-    readonly mapValue?: MapLoadingStateValuesFn<A, B, L>;
-    readonly mapState?: MapLoadingStateFn<A, B, L, O>;
+    readonly mapValue?: MapLoadingStateValuesFn<L, B>;
+    readonly mapState?: MapLoadingStateFn<L, B, O>;
 }
 /**
  * Maps the value of a single {@link LoadingState} to a new type using the provided configuration.
@@ -476,6 +585,10 @@ export interface MapLoadingStateResultsConfiguration<A, B, L extends LoadingStat
  * Preserves the loading/error metadata while transforming the value via `mapValue` or the entire
  * state via `mapState`. When `alwaysMapValue` is true, maps even when the value is null/undefined.
  *
+ * @param input - The loading state to transform.
+ * @param config - Mapping configuration.
+ * @returns The transformed loading state.
+ *
  * @example
  * ```ts
  * const result = mapLoadingStateResults(successResult(0), {
@@ -483,16 +596,16 @@ export interface MapLoadingStateResultsConfiguration<A, B, L extends LoadingStat
  * });
  * // { value: 'Value: 0', loading: false }
  * ```
- *
- * @param input - the loading state to transform
- * @param config - mapping configuration
- * @returns the transformed loading state
  */
-export declare function mapLoadingStateResults<A, B, L extends PageLoadingState<A> = PageLoadingState<A>, O extends PageLoadingState<B> = PageLoadingState<B>>(input: L, config: MapLoadingStateResultsConfiguration<A, B, L, O>): O;
-export declare function mapLoadingStateResults<A, B, L extends LoadingState<A> = LoadingState<A>, O extends LoadingState<B> = LoadingState<B>>(input: L, config: MapLoadingStateResultsConfiguration<A, B, L, O>): O;
-export declare function mapLoadingStateResults<A, B, L extends Partial<PageLoadingState<A>> = Partial<PageLoadingState<A>>, O extends Partial<PageLoadingState<B>> = Partial<PageLoadingState<B>>>(input: L, config: MapLoadingStateResultsConfiguration<A, B, L, O>): O;
-export type MapLoadingStateValueFunction<O, I, L extends LoadingState<I> = LoadingState<I>> = MapFunction<L, Maybe<O>>;
-export type MapLoadingStateValueMapFunction<O, I, L extends LoadingState<I> = LoadingState<I>> = (item: I, state: L) => Maybe<O>;
+export declare function mapLoadingStateResults<L extends LoadingState, B, O extends LoadingState = LoadingStateWithValueType<L, B>>(input: L, config: MapLoadingStateResultsConfiguration<L, B, O>): O;
+/**
+ * Extracts and maps the value out of a {@link LoadingState}, or returns undefined when it has none.
+ */
+export type MapLoadingStateValueFunction<L extends LoadingState, O> = MapFunction<L, Maybe<O>>;
+/**
+ * Maps a {@link LoadingState}'s non-null value (and the state it came from) to the output type.
+ */
+export type MapLoadingStateValueMapFunction<L extends LoadingState, O> = (item: LoadingStateValue<L>, state: L) => Maybe<O>;
 /**
  * Creates a function that extracts and maps the value from a {@link LoadingState}, returning undefined
  * when the state has no value.
@@ -502,4 +615,4 @@ export type MapLoadingStateValueMapFunction<O, I, L extends LoadingState<I> = Lo
  *
  * @__NO_SIDE_EFFECTS__
  */
-export declare function mapLoadingStateValueFunction<O, I, L extends LoadingState<I> = LoadingState<I>>(mapFn: MapLoadingStateValueMapFunction<O, I, L>): MapLoadingStateValueFunction<O, I, L>;
+export declare function mapLoadingStateValueFunction<L extends LoadingState, O>(mapFn: MapLoadingStateValueMapFunction<L, O>): MapLoadingStateValueFunction<L, O>;

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

@@ -1,6 +1,6 @@
 import { type PageNumber } from '@dereekb/util';
 import { type Observable, type OperatorFunction } from 'rxjs';
-import { type LoadingStateValue, type ListLoadingState, type PageLoadingState } from './loading.state';
+import { type ListLoadingState, type PageLoadingState } from './loading.state';
 /**
  * Whether the {@link ListLoadingState} has no value or an empty array.
  *
@@ -16,7 +16,7 @@ import { type LoadingStateValue, type ListLoadingState, type PageLoadingState }
  * isListLoadingStateWithEmptyValue(beginLoading()); // true (no value)
  * ```
  */
-export declare function isListLoadingStateWithEmptyValue<T>(listLoadingState: ListLoadingState<T>): boolean;
+export declare function isListLoadingStateWithEmptyValue(listLoadingState: ListLoadingState): boolean;
 /**
  * RxJS operator that maps each emitted {@link ListLoadingState} to a boolean indicating whether the list is empty.
  *
@@ -66,4 +66,4 @@ export declare function pageLoadingStateFromObs<T>(obs: Observable<T>, firstOnly
  * ).subscribe((items) => console.log(items)); // []
  * ```
  */
-export declare function arrayValueFromFinishedLoadingState<L extends ListLoadingState>(): OperatorFunction<L, LoadingStateValue<L>>;
+export declare function arrayValueFromFinishedLoadingState<T>(): OperatorFunction<ListLoadingState<T>, T[]>;