@dereekb/rxjs 13.43.0 → 14.0.1

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

@@ -1,6 +1,6 @@
 import { type Maybe, type ReadableError, type EqualityComparatorFunction, type GetterOrValue, type MaybeSoStrict } from '@dereekb/util';
 import { type MonoTypeOperatorFunction, type OperatorFunction, type Observable, type ObservableInputTuple } from 'rxjs';
-import { type LoadingState, type PageLoadingState, type MapLoadingStateResultsConfiguration, type LoadingStateValue, LoadingStateType, type LoadingStateWithValueType, type LoadingStateWithDefinedValue, type LoadingStateWithError } from './loading.state';
+import { type LoadingState, type PageLoadingState, type MapLoadingStateResultsConfiguration, type LoadingStateValue, LoadingStateType, type LoadingStateWithValueType, type LoadingStateWithError } from './loading.state';
 /**
  * Wraps an observable output and maps the value to a {@link LoadingState}.
  *
@@ -52,7 +52,7 @@ export declare function loadingStateFromObs<T>(obs: Observable<T>, firstOnly?: b
  * @param obsB - the second LoadingState observable to combine
  * @returns An observable emitting the merged {@link LoadingState}.
  */
-export declare function combineLoadingStates<A, B>(obsA: Observable<LoadingState<A>>, obsB: Observable<LoadingState<B>>): Observable<LoadingState<A & B>>;
+export declare function combineLoadingStates<A extends object, B extends object>(obsA: Observable<LoadingState<A>>, obsB: Observable<LoadingState<B>>): Observable<LoadingState<A & B>>;
 export declare function combineLoadingStates<A extends object, B extends object, O>(obsA: Observable<LoadingState<A>>, obsB: Observable<LoadingState<B>>, mergeFn: (a: A, b: B) => O): Observable<LoadingState<O>>;
 export declare function combineLoadingStates<A extends object, B extends object, C extends object>(obsA: Observable<LoadingState<A>>, obsB: Observable<LoadingState<B>>, obsC: Observable<LoadingState<C>>): Observable<LoadingState<A & B & C>>;
 export declare function combineLoadingStates<A extends object, B extends object, C extends object, O>(obsA: Observable<LoadingState<A>>, obsB: Observable<LoadingState<B>>, obsC: Observable<LoadingState<C>>, mergeFn: (a: A, b: B, c: C) => O): Observable<LoadingState<O>>;
@@ -84,13 +84,16 @@ export declare function combineLoadingStates<O>(...args: any[]): Observable<Load
  * const status$ = combineLoadingStatesStatus([loading$, success$]);
  * ```
  */
-export declare function combineLoadingStatesStatus<A extends readonly LoadingState<any>[]>(sources: readonly [...ObservableInputTuple<A>]): Observable<LoadingState<boolean>>;
+export declare function combineLoadingStatesStatus<A extends readonly LoadingState[]>(sources: readonly [...ObservableInputTuple<A>]): Observable<LoadingState<boolean>>;
 /**
  * Merges `startWith()` with `beginLoading()` into a single typed operator.
  *
  * Preferred over using both individually, as typing information can get lost when chaining them separately.
  * An optional partial state can be provided to include additional metadata (e.g., page info) in the initial loading state.
  *
+ * @param state - Optional partial loading state to include in the initial emission.
+ * @returns A `MonoTypeOperatorFunction` that prepends a loading state to the observable.
+ *
  * @example
  * ```ts
  * // Emit a loading state immediately before the source observable emits
@@ -110,13 +113,8 @@ export declare function combineLoadingStatesStatus<A extends readonly LoadingSta
  *   shareReplay(1)
  * );
  * ```
- *
- * @param state - Optional partial loading state to include in the initial emission.
- * @returns A `MonoTypeOperatorFunction` that prepends a loading state to the observable.
  */
-export declare function startWithBeginLoading<L extends LoadingState>(): MonoTypeOperatorFunction<L>;
-export declare function startWithBeginLoading<L extends LoadingState>(state?: Partial<LoadingState>): MonoTypeOperatorFunction<L>;
-export declare function startWithBeginLoading<L extends PageLoadingState>(state?: Partial<PageLoadingState>): MonoTypeOperatorFunction<L>;
+export declare function startWithBeginLoading<L extends LoadingState>(state?: Partial<NoInfer<L>>): MonoTypeOperatorFunction<L>;
 /**
  * Returns the current value from the {@link LoadingState}, including `undefined` when still loading or no value is set.
  *
@@ -133,7 +131,7 @@ export declare function startWithBeginLoading<L extends PageLoadingState>(state?
  * );
  * ```
  */
-export declare function currentValueFromLoadingState<L extends LoadingState>(): OperatorFunction<L, Maybe<LoadingStateValue<L>>>;
+export declare function currentValueFromLoadingState<T>(): OperatorFunction<LoadingState<T>, Maybe<T>>;
 /**
  * Returns the current non-null/non-undefined value from the {@link LoadingState}.
  *
@@ -151,7 +149,7 @@ export declare function currentValueFromLoadingState<L extends LoadingState>():
  * );
  * ```
  */
-export declare function valueFromLoadingState<L extends LoadingStateWithDefinedValue>(): OperatorFunction<L, MaybeSoStrict<LoadingStateValue<L>>>;
+export declare function valueFromLoadingState<T>(): OperatorFunction<LoadingState<T>, MaybeSoStrict<T>>;
 /**
  * Returns the error once the {@link LoadingState} has finished loading with an error.
  *
@@ -168,7 +166,7 @@ export declare function valueFromLoadingState<L extends LoadingStateWithDefinedV
  * ).subscribe();
  * ```
  */
-export declare function errorFromLoadingState<L extends LoadingState>(): OperatorFunction<L, ReadableError>;
+export declare function errorFromLoadingState(): OperatorFunction<LoadingState, ReadableError>;
 /**
  * Throws an error if the {@link LoadingState} value has an error.
  *
@@ -188,7 +186,7 @@ export declare function errorFromLoadingState<L extends LoadingState>(): Operato
  * );
  * ```
  */
-export declare function throwErrorFromLoadingStateError<L extends LoadingState>(): OperatorFunction<L, L>;
+export declare function throwErrorFromLoadingStateError<L extends LoadingState>(): MonoTypeOperatorFunction<L>;
 /**
  * Returns the value once the {@link LoadingState} has finished loading, even if an error occurred or there is no value.
  *
@@ -213,14 +211,17 @@ export declare function throwErrorFromLoadingStateError<L extends LoadingState>(
  * @param defaultValue - Optional default value or getter to use when the finished state has no value.
  * @returns An `OperatorFunction` that emits the value (or default) once loading is finished.
  */
-export declare function valueFromFinishedLoadingState<L extends LoadingState>(defaultValue: GetterOrValue<LoadingStateValue<L>>): OperatorFunction<L, LoadingStateValue<L>>;
-export declare function valueFromFinishedLoadingState<L extends LoadingState>(defaultValue?: Maybe<GetterOrValue<LoadingStateValue<L>>>): OperatorFunction<L, Maybe<LoadingStateValue<L>>>;
-export declare function valueFromFinishedLoadingState<L extends LoadingStateWithDefinedValue>(): OperatorFunction<L, LoadingStateValue<L>>;
+export declare function valueFromFinishedLoadingState<T>(defaultValue: GetterOrValue<NoInfer<T>>): OperatorFunction<LoadingState<T>, T>;
+export declare function valueFromFinishedLoadingState<T>(defaultValue?: Maybe<GetterOrValue<NoInfer<T>>>): OperatorFunction<LoadingState<T>, Maybe<T>>;
 /**
  * Executes a side-effect function when the piped {@link LoadingState} matches the given {@link LoadingStateType}.
  *
  * This is a tap-style operator that does not modify the stream, but calls `fn` when the state matches the specified type.
  *
+ * @param fn - The side-effect function to call when the state matches.
+ * @param type - The {@link LoadingStateType} to match against.
+ * @returns A `MonoTypeOperatorFunction` that taps on matching states.
+ *
  * @example
  * ```ts
  * // Log whenever the state transitions to an error
@@ -233,19 +234,16 @@ export declare function valueFromFinishedLoadingState<L extends LoadingStateWith
  *   tapOnLoadingStateType(() => showSpinner(), LoadingStateType.LOADING)
  * ).subscribe();
  * ```
- *
- * @param fn - The side-effect function to call when the state matches.
- * @param type - The {@link LoadingStateType} to match against.
- * @returns A `MonoTypeOperatorFunction` that taps on matching states.
  */
 export declare function tapOnLoadingStateType<L extends LoadingState>(fn: (state: L) => void, type: LoadingStateType): MonoTypeOperatorFunction<L>;
-export declare function tapOnLoadingStateType<L extends LoadingState>(fn: (state: L) => void, type: LoadingStateType): MonoTypeOperatorFunction<L>;
-export declare function tapOnLoadingStateType<L extends PageLoadingState>(fn: (state: L) => void, type: LoadingStateType): MonoTypeOperatorFunction<L>;
 /**
  * Executes a side-effect function when the input {@link LoadingState} has a successful value.
  *
  * This is a convenience wrapper around {@link tapOnLoadingStateType} with {@link LoadingStateType.SUCCESS}.
  *
+ * @param fn - The side-effect function to call on success states.
+ * @returns A `MonoTypeOperatorFunction` that taps on successful states.
+ *
  * @example
  * ```ts
  * // Log the successful value
@@ -253,18 +251,16 @@ export declare function tapOnLoadingStateType<L extends PageLoadingState>(fn: (s
  *   tapOnLoadingStateSuccess((state) => console.log('Loaded:', state.value))
  * ).subscribe();
  * ```
- *
- * @param fn - The side-effect function to call on success states.
- * @returns A `MonoTypeOperatorFunction` that taps on successful states.
  */
 export declare function tapOnLoadingStateSuccess<L extends LoadingState>(fn: (state: L) => void): MonoTypeOperatorFunction<L>;
-export declare function tapOnLoadingStateSuccess<L extends LoadingState>(fn: (state: L) => void): MonoTypeOperatorFunction<L>;
-export declare function tapOnLoadingStateSuccess<L extends PageLoadingState>(fn: (state: L) => void): MonoTypeOperatorFunction<L>;
 /**
  * Convenience function for using {@link mapLoadingStateResults} with an Observable.
  *
  * Maps the value within a {@link LoadingState} using the provided configuration, preserving the loading/error state metadata.
  *
+ * @param config - Configuration for mapping the loading state value.
+ * @returns An `OperatorFunction` that maps the value within the loading state.
+ *
  * @example
  * ```ts
  * // Map a SystemState<T> loading state to just its data property
@@ -273,13 +269,8 @@ export declare function tapOnLoadingStateSuccess<L extends PageLoadingState>(fn:
  *   shareReplay(1)
  * );
  * ```
- *
- * @param config - Configuration for mapping the loading state value.
- * @returns An `OperatorFunction` that maps the value within the loading state.
  */
-export declare function mapLoadingState<A, B, L extends LoadingState<A> = LoadingState<A>, O extends LoadingState<B> = LoadingState<B>>(config: MapLoadingStateResultsConfiguration<A, B, L, O>): OperatorFunction<L, O>;
-export declare function mapLoadingState<A, B, L extends PageLoadingState<A> = PageLoadingState<A>, O extends PageLoadingState<B> = PageLoadingState<B>>(config: MapLoadingStateResultsConfiguration<A, B, L, O>): OperatorFunction<L, O>;
-export declare function mapLoadingState<A, B, L extends Partial<PageLoadingState<A>> = Partial<PageLoadingState<A>>, O extends Partial<PageLoadingState<B>> = Partial<PageLoadingState<B>>>(config: MapLoadingStateResultsConfiguration<A, B, L, O>): OperatorFunction<L, O>;
+export declare function mapLoadingState<L extends LoadingState, B, O extends LoadingState = LoadingStateWithValueType<L, B>>(config: MapLoadingStateResultsConfiguration<L, B, O>): OperatorFunction<L, O>;
 /**
  * Maps the value within a {@link LoadingState} using an arbitrary RxJS operator.
  *
@@ -289,6 +280,10 @@ export declare function mapLoadingState<A, B, L extends Partial<PageLoadingState
  *
  * Error and loading states are passed through without invoking the operator.
  *
+ * @param operator - The RxJS operator to apply to the loading state's value.
+ * @param mapOnUndefined - If true, also applies the operator when the value is undefined (but loading is finished and no error).
+ * @returns An `OperatorFunction` that transforms the value within the loading state.
+ *
  * @example
  * ```ts
  * // Filter loading state values using a search string operator
@@ -312,20 +307,17 @@ export declare function mapLoadingState<A, B, L extends Partial<PageLoadingState
  *   shareReplay(1)
  * );
  * ```
- *
- * @param operator - The RxJS operator to apply to the loading state's value.
- * @param mapOnUndefined - If true, also applies the operator when the value is undefined (but loading is finished and no error).
- * @returns An `OperatorFunction` that transforms the value within the loading state.
  */
 export declare function mapLoadingStateValueWithOperator<L extends LoadingState, O>(operator: OperatorFunction<LoadingStateValue<L>, O>, mapOnUndefined?: boolean): OperatorFunction<L, LoadingStateWithValueType<L, O>>;
-export declare function mapLoadingStateValueWithOperator<L extends PageLoadingState, O>(operator: OperatorFunction<LoadingStateValue<L>, O>, mapOnUndefined?: boolean): OperatorFunction<L, LoadingStateWithValueType<L, O>>;
-export declare function mapLoadingStateValueWithOperator<L extends Partial<PageLoadingState>, O>(operator: OperatorFunction<LoadingStateValue<L>, O>, mapOnUndefined?: boolean): OperatorFunction<L, LoadingStateWithValueType<L, O>>;
 /**
  * Catches a {@link LoadingStateWithError} and transforms it into a new {@link LoadingState} using the provided operator.
  *
  * Non-error states are passed through unchanged. When an error state is encountered, it is passed through the
  * operator to produce a replacement state. If the operator does not emit immediately, a temporary loading state is emitted.
  *
+ * @param operator - The RxJS operator to apply to the error loading state.
+ * @returns A `MonoTypeOperatorFunction` that catches and transforms error states.
+ *
  * @example
  * ```ts
  * // On error, return an empty list instead of propagating the error
@@ -335,13 +327,8 @@ export declare function mapLoadingStateValueWithOperator<L extends Partial<PageL
  *   )
  * );
  * ```
- *
- * @param operator - The RxJS operator to apply to the error loading state.
- * @returns A `MonoTypeOperatorFunction` that catches and transforms error states.
  */
-export declare function catchLoadingStateErrorWithOperator<L extends LoadingState>(operator: OperatorFunction<L & LoadingStateWithError, L>): MonoTypeOperatorFunction<L>;
-export declare function catchLoadingStateErrorWithOperator<L extends PageLoadingState>(operator: OperatorFunction<L & LoadingStateWithError, L>): MonoTypeOperatorFunction<L>;
-export declare function catchLoadingStateErrorWithOperator<L extends Partial<PageLoadingState>>(operator: OperatorFunction<L & LoadingStateWithError, L>): MonoTypeOperatorFunction<L>;
+export declare function catchLoadingStateErrorWithOperator<L extends LoadingState>(operator: OperatorFunction<NoInfer<L> & LoadingStateWithError, NoInfer<L>>): MonoTypeOperatorFunction<L>;
 /**
  * Config for {@link distinctLoadingState}.
  */
@@ -363,7 +350,7 @@ export interface DistinctLoadingStateConfig<L extends LoadingState> {
     /**
      * Used for comparing the metadata values of the LoadingState. By default uses isPageLoadingStateMetadataEqual.
      */
-    readonly metadataComparator?: EqualityComparatorFunction<Maybe<Partial<L>>>;
+    readonly metadataComparator?: EqualityComparatorFunction<Maybe<Partial<PageLoadingState>>>;
 }
 /**
  * A special `distinctUntilChanged`-like operator for {@link LoadingState} and {@link PageLoadingState}.
@@ -375,6 +362,9 @@ export interface DistinctLoadingStateConfig<L extends LoadingState> {
  * Accepts either a simple {@link EqualityComparatorFunction} for comparing values, or a full
  * {@link DistinctLoadingStateConfig} for more fine-grained control over comparison behavior.
  *
+ * @param config - Either a value comparator function or a full {@link DistinctLoadingStateConfig}.
+ * @returns A `MonoTypeOperatorFunction` that filters out duplicate loading states.
+ *
  * @example
  * ```ts
  * // Filter out duplicate loading states using key-based comparison
@@ -389,13 +379,8 @@ export interface DistinctLoadingStateConfig<L extends LoadingState> {
  *   })
  * );
  * ```
- *
- * @param config - Either a value comparator function or a full {@link DistinctLoadingStateConfig}.
- * @returns A `MonoTypeOperatorFunction` that filters out duplicate loading states.
  */
-export declare function distinctLoadingState<L extends LoadingState>(config: EqualityComparatorFunction<Maybe<LoadingStateValue<L>>> | DistinctLoadingStateConfig<L>): MonoTypeOperatorFunction<L>;
-export declare function distinctLoadingState<L extends PageLoadingState>(config: EqualityComparatorFunction<Maybe<LoadingStateValue<L>>> | DistinctLoadingStateConfig<L>): MonoTypeOperatorFunction<L>;
-export declare function distinctLoadingState<L extends Partial<PageLoadingState>>(config: EqualityComparatorFunction<Maybe<LoadingStateValue<L>>> | DistinctLoadingStateConfig<L>): MonoTypeOperatorFunction<L>;
+export declare function distinctLoadingState<L extends LoadingState>(config: NoInfer<EqualityComparatorFunction<Maybe<LoadingStateValue<L>>> | DistinctLoadingStateConfig<L>>): MonoTypeOperatorFunction<L>;
 /**
  * Creates a Promise from an Observable of {@link LoadingState} that resolves when loading finishes.
  *