@dereekb/rxjs 13.11.13 → 13.11.15

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

@@ -22,6 +22,10 @@ export interface LoadingErrorPair {
 /**
  * Compares two {@link LoadingState} instances for shallow equality across all key properties.
  *
+ * @param a - First loading state.
+ * @param b - Second loading state.
+ * @returns True if loading, loadingProgress, error, and value are all strictly equal.
+ *
  * @example
  * ```ts
  * const a = successResult('hello');
@@ -31,10 +35,6 @@ export interface LoadingErrorPair {
  * const c = beginLoading();
  * isLoadingStateEqual(a, c); // false
  * ```
- *
- * @param a - first loading state
- * @param b - second loading state
- * @returns true if loading, loadingProgress, error, and value are all strictly equal
  */
 export declare function isLoadingStateEqual<T extends LoadingState>(a: T, b: T): boolean;
 /**
@@ -43,9 +43,9 @@ export declare function isLoadingStateEqual<T extends LoadingState>(a: T, b: T):
  *
  * Does not compare the `value` property — only structural metadata.
  *
- * @param a - first loading error pair
- * @param b - second loading error pair
- * @returns true if both pairs have equivalent metadata
+ * @param a - First loading error pair.
+ * @param b - Second loading error pair.
+ * @returns True if both pairs have equivalent metadata.
  */
 export declare function isLoadingStateMetadataEqual(a: Partial<LoadingErrorPair>, b: Partial<LoadingErrorPair>): boolean;
 /**
@@ -133,6 +133,9 @@ export declare enum LoadingStateType {
  * Returns `LOADING` if still loading, `SUCCESS` if finished with a value key,
  * `ERROR` if finished with an error key, or `IDLE` if finished with neither.
  *
+ * @param loadingState - The loading state to classify.
+ * @returns The corresponding {@link LoadingStateType}
+ *
  * @example
  * ```ts
  * loadingStateType(beginLoading()); // LoadingStateType.LOADING
@@ -140,9 +143,6 @@ export declare enum LoadingStateType {
  * loadingStateType(errorResult(new Error())); // LoadingStateType.ERROR
  * loadingStateType({ loading: false }); // LoadingStateType.IDLE
  * ```
- *
- * @param loadingState - the loading state to classify
- * @returns the corresponding {@link LoadingStateType}
  */
 export declare function loadingStateType(loadingState: LoadingState): LoadingStateType;
 /**
@@ -151,6 +151,9 @@ export declare function loadingStateType(loadingState: LoadingState): LoadingSta
  * Returns `true` when `loading` is explicitly `false`, or when `loading` is not `true`
  * and either a value, error, or `null` value is present.
  *
+ * @param state - The loading state to check (may be null/undefined)
+ * @returns True if loading is complete.
+ *
  * @example
  * ```ts
  * isLoadingStateFinishedLoading(successResult('done')); // true
@@ -158,9 +161,6 @@ export declare function loadingStateType(loadingState: LoadingState): LoadingSta
  * isLoadingStateFinishedLoading({ loading: false }); // true
  * isLoadingStateFinishedLoading(null); // false
  * ```
- *
- * @param state - the loading state to check (may be null/undefined)
- * @returns true if loading is complete
  */
 export declare function isLoadingStateFinishedLoading<L extends LoadingState>(state: Maybe<L>): boolean;
 /**
@@ -168,14 +168,14 @@ export declare function isLoadingStateFinishedLoading<L extends LoadingState>(st
  *
  * Represents a state where no loading has been initiated yet.
  *
+ * @returns A loading state with `loading: false` and no value or error.
+ *
  * @example
  * ```ts
  * const state = idleLoadingState();
  * // { loading: false }
  * loadingStateType(state); // LoadingStateType.IDLE
  * ```
- *
- * @returns a loading state with `loading: false` and no value or error
  */
 export declare function idleLoadingState<T>(): LoadingState<T>;
 /**
@@ -199,30 +199,30 @@ export declare function beginLoading<T>(state?: Partial<LoadingState<T>>): Loadi
 /**
  * Creates a {@link PageLoadingState} that is loading for the given page number.
  *
- * @param page - the page number being loaded
- * @param state - optional partial state to merge
- * @returns a page loading state with `loading: true`
+ * @param page - The page number being loaded.
+ * @param state - Optional partial state to merge.
+ * @returns A page loading state with `loading: true`
  */
 export declare function beginLoadingPage<T>(page: PageNumber, state?: Partial<PageLoadingState<T>>): PageLoadingState<T>;
 /**
  * Creates a successful {@link LoadingState} with the given value and `loading: false`.
  *
+ * @param value - The loaded value.
+ * @returns A loading state representing a successful result.
+ *
  * @example
  * ```ts
  * const state = successResult({ name: 'Alice' });
  * // { value: { name: 'Alice' }, loading: false }
  * ```
- *
- * @param value - the loaded value
- * @returns a loading state representing a successful result
  */
 export declare function successResult<T>(value: T): LoadingStateWithValue<T>;
 /**
  * Creates a successful {@link PageLoadingState} for a specific page.
  *
- * @param page - the page number
- * @param value - the loaded value
- * @returns a page loading state representing success
+ * @param page - The page number.
+ * @param value - The loaded value.
+ * @returns A page loading state representing success.
  */
 export declare function successPageResult<T>(page: PageNumber, value: T): PageLoadingState<T>;
 /**
@@ -230,48 +230,48 @@ export declare function successPageResult<T>(page: PageNumber, value: T): PageLo
  *
  * Converts the input error to a {@link ReadableError} via {@link toReadableError}.
  *
+ * @param error - The error to wrap (string, Error, or ReadableError)
+ * @returns A loading state representing an error.
+ *
  * @example
  * ```ts
  * const state = errorResult(new Error('Not found'));
  * // { error: { message: 'Not found', ... }, loading: false }
  * ```
- *
- * @param error - the error to wrap (string, Error, or ReadableError)
- * @returns a loading state representing an error
  */
 export declare function errorResult<T>(error?: Maybe<ErrorInput>): LoadingState<T>;
 /**
  * Creates a {@link PageLoadingState} representing an error for a specific page.
  *
- * @param page - the page number
- * @param error - the error to include
- * @returns a page loading state representing an error
+ * @param page - The page number.
+ * @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>;
 /**
  * Whether any of the given {@link LoadingState} instances are currently loading.
  *
+ * @param states - Array of loading states to check.
+ * @returns True if at least one state is loading.
+ *
  * @example
  * ```ts
  * isAnyLoadingStateInLoadingState([successResult(1), beginLoading()]); // true
  * isAnyLoadingStateInLoadingState([successResult(1), successResult(2)]); // false
  * ```
- *
- * @param states - array of loading states to check
- * @returns true if at least one state is loading
  */
 export declare function isAnyLoadingStateInLoadingState(states: LoadingState[]): boolean;
 /**
  * Whether all given {@link LoadingState} instances have finished loading.
  *
+ * @param states - Array of loading states to check.
+ * @returns True if every state has finished loading.
+ *
  * @example
  * ```ts
  * areAllLoadingStatesFinishedLoading([successResult(1), successResult(2)]); // true
  * areAllLoadingStatesFinishedLoading([successResult(1), beginLoading()]); // false
  * ```
- *
- * @param states - array of loading states to check
- * @returns true if every state has finished loading
  */
 export declare function areAllLoadingStatesFinishedLoading(states: LoadingState[]): boolean;
 /**
@@ -279,8 +279,8 @@ export declare function areAllLoadingStatesFinishedLoading(states: LoadingState[
  *
  * When the target type is `IDLE`, returns `true` for null/undefined states.
  *
- * @param type - the loading state type to match against
- * @returns a predicate function for the given type
+ * @param type - The loading state type to match against.
+ * @returns A predicate function for the given type.
  */
 export declare function isLoadingStateWithStateType(type: LoadingStateType): <L extends LoadingState>(state: Maybe<L>) => boolean;
 /**
@@ -318,42 +318,42 @@ export declare const isLoadingStateInErrorState: <L extends LoadingState>(state:
 /**
  * Type guard that checks whether a {@link LoadingState} has a non-undefined value, regardless of loading status.
  *
+ * @param state - The loading state to check.
+ * @returns True if the state has a defined (non-undefined) value.
+ *
  * @example
  * ```ts
  * isLoadingStateWithDefinedValue(successResult('hello')); // true
  * isLoadingStateWithDefinedValue(successResult(null)); // true (null is defined)
  * isLoadingStateWithDefinedValue(beginLoading()); // false
  * ```
- *
- * @param state - the loading state to check
- * @returns true if the state has a defined (non-undefined) value
  */
 export declare function isLoadingStateWithDefinedValue<L extends LoadingState>(state: Maybe<L> | LoadingStateWithDefinedValue<LoadingStateValue<L>>): state is LoadingStateWithDefinedValue<LoadingStateValue<L>>;
 /**
  * Type guard that checks whether a {@link LoadingState} has a non-null error, regardless of loading status.
  *
+ * @param state - The loading state to check.
+ * @returns True if the state has an error.
+ *
  * @example
  * ```ts
  * isLoadingStateWithError(errorResult(new Error('fail'))); // true
  * isLoadingStateWithError(successResult('ok')); // false
  * ```
- *
- * @param state - the loading state to check
- * @returns true if the state has an error
  */
 export declare function isLoadingStateWithError<L extends LoadingState>(state: Maybe<L> | LoadingState<LoadingStateValue<L>>): state is 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
+ * @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>>;
 /**
  * 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
+ * @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>>;
 /**
@@ -361,6 +361,10 @@ export declare function isLoadingStateFinishedLoadingWithError<L extends Loading
  *
  * Does not compare values — only structural metadata.
  *
+ * @param a - First page loading state.
+ * @param b - Second page loading state.
+ * @returns True if metadata is equivalent.
+ *
  * @example
  * ```ts
  * isPageLoadingStateMetadataEqual(
@@ -373,10 +377,6 @@ export declare function isLoadingStateFinishedLoadingWithError<L extends Loading
  *   { page: 2 }
  * ); // false
  * ```
- *
- * @param a - first page loading state
- * @param b - second page loading state
- * @returns true if metadata is equivalent
  */
 export declare function isPageLoadingStateMetadataEqual(a: Partial<PageLoadingState>, b: Partial<PageLoadingState>): boolean;
 /**
@@ -426,25 +426,25 @@ export declare function mergeLoadingStates<O>(...args: any[]): LoadingState<O>;
  *
  * Useful for resetting a state back to loading or idle without losing other metadata (e.g., page).
  *
- * @param state - the state to copy metadata from
- * @param loading - whether to mark as loading (defaults to true)
- * @returns a new state with value/error cleared
+ * @param state - The state to copy metadata from.
+ * @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;
 /**
  * Returns a copy of the state with the given value, `loading: false`, and error cleared.
  *
- * @param state - the state to copy metadata from
- * @param value - the new value to set
- * @returns a new state representing success
+ * @param state - The state to copy metadata from.
+ * @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;
 /**
  * Returns a copy of the state with the given error and `loading: false`.
  *
- * @param state - the state to copy metadata from
- * @param error - the error to set
- * @returns a new state representing an error
+ * @param state - The state to copy metadata from.
+ * @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;
@@ -457,10 +457,9 @@ export interface MapMultipleLoadingStateResultsConfiguration<T, X, L extends Loa
  *
  * Returns `undefined` if any input is still loading or has an error.
  *
- * @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
- *
+ * @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.
  */
 export declare function mapMultipleLoadingStateResults<T, X, L extends LoadingState<X>[], R extends LoadingState<T>>(input: L, config: MapMultipleLoadingStateResultsConfiguration<T, X, L, R>): Maybe<R>;
@@ -489,8 +488,8 @@ export interface MapLoadingStateResultsConfiguration<A, B, L extends LoadingStat
  * @param config - mapping configuration
  * @returns the transformed loading state
  */
-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 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>;
@@ -498,8 +497,9 @@ export type MapLoadingStateValueMapFunction<O, I, L extends LoadingState<I> = Lo
  * Creates a function that extracts and maps the value from a {@link LoadingState}, returning undefined
  * when the state has no value.
  *
- * @param mapFn - function to transform the value and state into the output type
- * @returns a function that accepts a loading state and returns the mapped value or undefined
+ * @param mapFn - Function to transform the value and state into the output type.
+ * @returns Mapper that yields the transformed value when present, or undefined when the state has none.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function mapLoadingStateValueFunction<O, I, L extends LoadingState<I> = LoadingState<I>>(mapFn: MapLoadingStateValueMapFunction<O, I, L>): MapLoadingStateValueFunction<O, I, L>;

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

@@ -6,28 +6,28 @@ import { type LoadingStateValue, type ListLoadingState, type PageLoadingState }
  *
  * Returns true if the value is nullish or has zero length, regardless of loading status.
  *
+ * @param listLoadingState - The list loading state to check.
+ * @returns True if the value is empty or absent.
+ *
  * @example
  * ```ts
  * isListLoadingStateWithEmptyValue(successResult([])); // true
  * isListLoadingStateWithEmptyValue(successResult([1, 2])); // false
  * isListLoadingStateWithEmptyValue(beginLoading()); // true (no value)
  * ```
- *
- * @param listLoadingState - the list loading state to check
- * @returns true if the value is empty or absent
  */
 export declare function isListLoadingStateWithEmptyValue<T>(listLoadingState: ListLoadingState<T>): boolean;
 /**
  * RxJS operator that maps each emitted {@link ListLoadingState} to a boolean indicating whether the list is empty.
  *
+ * @returns An operator that emits true when the list value is empty or absent.
+ *
  * @example
  * ```ts
  * of(successResult([])).pipe(
  *   mapIsListLoadingStateWithEmptyValue()
  * ).subscribe((isEmpty) => console.log(isEmpty)); // true
  * ```
- *
- * @returns an operator that emits true when the list value is empty or absent
  */
 export declare function mapIsListLoadingStateWithEmptyValue<T>(): OperatorFunction<ListLoadingState<T>, boolean>;
 /**
@@ -35,16 +35,16 @@ export declare function mapIsListLoadingStateWithEmptyValue<T>(): OperatorFuncti
  *
  * Uses {@link loadingStateFromObs} internally and attaches the page number to each emitted state.
  *
+ * @param obs - The source observable to wrap.
+ * @param firstOnly - If true, only takes the first value.
+ * @param page - The page number to attach (defaults to 0)
+ * @returns An observable of page loading states.
+ *
  * @example
  * ```ts
  * const pageState$ = pageLoadingStateFromObs(fetchItems$, false, 2);
  * // emits: { loading: true, page: 2 }, then { value: items, loading: false, page: 2 }
  * ```
- *
- * @param obs - the source observable to wrap
- * @param firstOnly - if true, only takes the first value
- * @param page - the page number to attach (defaults to 0)
- * @returns an observable of page loading states
  */
 export declare function pageLoadingStateFromObs<T>(obs: Observable<T>, firstOnly?: boolean, page?: PageNumber): Observable<PageLoadingState<T>>;
 /**
@@ -53,6 +53,8 @@ export declare function pageLoadingStateFromObs<T>(obs: Observable<T>, firstOnly
  *
  * Combines {@link valueFromFinishedLoadingState} with a default of `[]`.
  *
+ * @returns An operator that emits the array value or an empty array.
+ *
  * @example
  * ```ts
  * of(successResult([1, 2, 3])).pipe(
@@ -63,7 +65,5 @@ export declare function pageLoadingStateFromObs<T>(obs: Observable<T>, firstOnly
  *   arrayValueFromFinishedLoadingState()
  * ).subscribe((items) => console.log(items)); // []
  * ```
- *
- * @returns an operator that emits the array value or an empty array
  */
 export declare function arrayValueFromFinishedLoadingState<L extends ListLoadingState>(): OperatorFunction<L, LoadingStateValue<L>>;

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

@@ -9,6 +9,10 @@ import { type LoadingState, type PageLoadingState, type MapLoadingStateResultsCo
  *
  * If firstOnly is provided, it will only take the first value the observable returns.
  *
+ * @param obs - The source observable to wrap.
+ * @param firstOnly - If true, only takes the first value from the observable.
+ * @returns An observable that emits {@link LoadingState} values representing the loading lifecycle.
+ *
  * @example
  * ```ts
  * // Wrap a data fetch observable into a LoadingState
@@ -17,10 +21,6 @@ import { type LoadingState, type PageLoadingState, type MapLoadingStateResultsCo
  * // Wrap an observable and only take the first emitted value
  * readonly singleValueState$ = loadingStateFromObs(this.data$, true);
  * ```
- *
- * @param obs - The source observable to wrap.
- * @param firstOnly - If true, only takes the first value from the observable.
- * @returns An observable that emits {@link LoadingState} values representing the loading lifecycle.
  */
 export declare function loadingStateFromObs<T>(obs: Observable<T>, firstOnly?: boolean): Observable<LoadingState<T>>;
 /**
@@ -68,6 +68,9 @@ export declare function combineLoadingStates<O>(...args: any[]): Observable<Load
  * If any source has an error, the error is propagated. If any source is still loading, the result is loading.
  * When all sources are successful, the result value is `true`.
  *
+ * @param sources - LoadingState observables whose statuses participate in the combined emission.
+ * @returns An observable emitting a {@link LoadingState}<boolean> representing the combined status.
+ *
  * @example
  * ```ts
  * const success$ = of(successResult(1));
@@ -80,9 +83,6 @@ export declare function combineLoadingStates<O>(...args: any[]): Observable<Load
  * const loading$ = of(beginLoading());
  * const status$ = combineLoadingStatesStatus([loading$, success$]);
  * ```
- *
- * @param sources - An array of LoadingState observables to combine.
- * @returns An observable emitting a {@link LoadingState}<boolean> representing the combined status.
  */
 export declare function combineLoadingStatesStatus<A extends readonly LoadingState<any>[]>(sources: readonly [...ObservableInputTuple<A>]): Observable<LoadingState<boolean>>;
 /**
@@ -122,6 +122,8 @@ export declare function startWithBeginLoading<L extends PageLoadingState>(state?
  *
  * Unlike {@link valueFromLoadingState}, this operator emits for every state change, regardless of whether the value is defined.
  *
+ * @returns An `OperatorFunction` that maps each {@link LoadingState} to its current value (or undefined).
+ *
  * @example
  * ```ts
  * // Expose the current (possibly undefined) value from a loading state
@@ -130,8 +132,6 @@ export declare function startWithBeginLoading<L extends PageLoadingState>(state?
  *   shareReplay(1)
  * );
  * ```
- *
- * @returns An `OperatorFunction` that maps each {@link LoadingState} to its current value (or undefined).
  */
 export declare function currentValueFromLoadingState<L extends LoadingState>(): OperatorFunction<L, Maybe<LoadingStateValue<L>>>;
 /**
@@ -140,6 +140,8 @@ export declare function currentValueFromLoadingState<L extends LoadingState>():
  * Equivalent to piping {@link currentValueFromLoadingState} and `filterMaybeStrict()`.
  * Only emits when the value is defined, filtering out loading and error states without values.
  *
+ * @returns An `OperatorFunction` that emits only defined values from the {@link LoadingState}.
+ *
  * @example
  * ```ts
  * // Only emit when the loading state has a defined value
@@ -148,8 +150,6 @@ export declare function currentValueFromLoadingState<L extends LoadingState>():
  *   // only emits non-null/non-undefined values
  * );
  * ```
- *
- * @returns An `OperatorFunction` that emits only defined values from the {@link LoadingState}.
  */
 export declare function valueFromLoadingState<L extends LoadingStateWithDefinedValue>(): OperatorFunction<L, MaybeSoStrict<LoadingStateValue<L>>>;
 /**
@@ -157,6 +157,8 @@ export declare function valueFromLoadingState<L extends LoadingStateWithDefinedV
  *
  * Filters to only emit when the state contains an error, then extracts and emits the {@link ReadableError}.
  *
+ * @returns An `OperatorFunction` that emits the {@link ReadableError} from error states.
+ *
  * @example
  * ```ts
  * // React to errors from a loading state
@@ -165,8 +167,6 @@ export declare function valueFromLoadingState<L extends LoadingStateWithDefinedV
  *   tap((error) => console.error('Loading failed:', error))
  * ).subscribe();
  * ```
- *
- * @returns An `OperatorFunction` that emits the {@link ReadableError} from error states.
  */
 export declare function errorFromLoadingState<L extends LoadingState>(): OperatorFunction<L, ReadableError>;
 /**
@@ -175,6 +175,8 @@ export declare function errorFromLoadingState<L extends LoadingState>(): Operato
  * Passes through non-error states unchanged, but throws the error from any {@link LoadingStateWithError},
  * converting the loading state error into an observable error that can be caught with `catchError`.
  *
+ * @returns An `OperatorFunction` that passes through non-error states and throws on error states.
+ *
  * @example
  * ```ts
  * // Convert a LoadingState observable to a Promise, throwing on error states
@@ -185,8 +187,6 @@ export declare function errorFromLoadingState<L extends LoadingState>(): Operato
  *   )
  * );
  * ```
- *
- * @returns An `OperatorFunction` that passes through non-error states and throws on error states.
  */
 export declare function throwErrorFromLoadingStateError<L extends LoadingState>(): OperatorFunction<L, L>;
 /**
@@ -402,6 +402,9 @@ export declare function distinctLoadingState<L extends Partial<PageLoadingState>
  * Waits for the first finished loading state, then resolves with the value. If the finished state
  * contains an error, the promise is rejected with that error.
  *
+ * @param obs - The observable emitting {@link LoadingState} values.
+ * @returns Resolves with the first finished value or rejects when the finished state carries an error.
+ *
  * @example
  * ```ts
  * // Await a loading state observable as a promise
@@ -418,8 +421,5 @@ export declare function distinctLoadingState<L extends Partial<PageLoadingState>
  *   throw e;
  * });
  * ```
- *
- * @param obs - The observable emitting {@link LoadingState} values.
- * @returns A Promise that resolves with the value or rejects with the error.
  */
 export declare function promiseFromLoadingState<T>(obs: Observable<LoadingState<T>>): Promise<T>;

package/src/lib/lock.d.ts

@@ -64,12 +64,12 @@ export declare const DEFAULT_LOCK_SET_TIME_LOCK_KEY = "timelock";
  *
  * Useful for deferring an action until all locks are released, with a safety timeout to avoid waiting indefinitely.
  *
- * @param config - configuration specifying the lock set, callback, timeout, and optional delay
- * @param config.lockSet - the lock set to monitor for the next unlock event
- * @param config.fn - optional callback to invoke when the lock set unlocks or the timeout is reached
- * @param config.timeout - maximum time in milliseconds to wait before timing out
- * @param config.delayTime - optional delay in milliseconds after unlock before invoking the callback
- * @returns subscription that can be unsubscribed to cancel the wait
+ * @param config - Configuration specifying the lock set, callback, timeout, and optional delay.
+ * @param config.lockSet - The lock set to monitor for the next unlock event.
+ * @param config.fn - Optional callback to invoke when the lock set unlocks or the timeout is reached.
+ * @param config.timeout - Maximum time in milliseconds to wait before timing out.
+ * @param config.delayTime - Optional delay in milliseconds after unlock before invoking the callback.
+ * @returns Subscription that can be unsubscribed to cancel the wait.
  *
  * @example
  * ```ts
@@ -139,32 +139,32 @@ export declare class LockSet implements Destroyable {
      * When locked with a duration, the lock automatically releases after the specified time.
      * When unlocked, the lock is removed from the set.
      *
-     * @param key - identifier for this lock
-     * @param config - locked state or configuration object
-     * @param duration - optional auto-unlock duration in milliseconds (only used with boolean config)
+     * @param key - Identifier for this lock.
+     * @param config - Locked state or configuration object.
+     * @param duration - Optional auto-unlock duration in milliseconds (only used with boolean config)
      */
     setLocked(key: LockKey, config: SetLockedConfig): void;
     setLocked(key: LockKey, config: boolean, duration?: Milliseconds): void;
     /**
      * Locks for a specified number of seconds using the default time lock key.
      *
-     * @param seconds - duration in seconds
+     * @param seconds - Duration in seconds.
      */
     lockForSeconds(seconds: Seconds): void;
     /**
      * Locks for a specified duration in milliseconds, automatically unlocking when the time elapses.
      *
-     * @param milliseconds - lock duration
-     * @param key - optional lock key, defaults to {@link DEFAULT_LOCK_SET_TIME_LOCK_KEY}
+     * @param milliseconds - Lock duration.
+     * @param key - Optional lock key, defaults to {@link DEFAULT_LOCK_SET_TIME_LOCK_KEY}
      */
     lockForTime(milliseconds: Milliseconds, key?: LockKey): void;
     /**
      * Registers a lock observable under the given key. The lock is considered active when
      * the observable emits `true`. Empty observables are treated as unlocked.
      *
-     * @param key - identifier for this lock
-     * @param obs - observable that emits the lock state
-     * @returns function that removes this specific lock when called
+     * @param key - Identifier for this lock.
+     * @param obs - Observable that emits the lock state.
+     * @returns Function that removes this specific lock when called.
      *
      * @example
      * ```ts
@@ -180,30 +180,30 @@ export declare class LockSet implements Destroyable {
     /**
      * Removes the lock registered under the given key, if it exists.
      *
-     * @param key - identifier of the lock to remove
+     * @param key - Identifier of the lock to remove.
      */
     removeLock(key: LockKey): void;
     /**
      * Registers a callback for the next time this lock set becomes unlocked.
      *
-     * @param config - callback function or configuration object
-     * @param delayTime - optional delay in milliseconds after unlock before invoking the callback
-     * @returns subscription that can be unsubscribed to cancel the wait
+     * @param config - Callback function or configuration object.
+     * @param delayTime - Optional delay in milliseconds after unlock before invoking the callback.
+     * @returns Subscription that can be unsubscribed to cancel the wait.
      */
     onNextUnlock(config: OnLockSetUnlockedFunction | Omit<OnLockSetUnlockedConfig, 'lockSet'>, delayTime?: Milliseconds): Subscription;
     /**
      * Establishes a parent-child relationship where this lock set's locked state is propagated
      * to the parent. When this lock set is locked, the parent will also reflect a locked state.
      *
-     * @param parent - parent lock set or observable of one; pass `undefined` to detach
+     * @param parent - Parent lock set or observable of one; pass `undefined` to detach.
      */
     setParentLockSet(parent: ObservableOrValue<Maybe<LockSet>>): void;
     /**
      * Registers a child lock set so its locked state propagates upward to this lock set.
      *
-     * @param lockSet - child lock set to monitor
-     * @param key - optional lock key, auto-generated if not provided
-     * @returns function that removes the child lock relationship when called
+     * @param lockSet - Child lock set to monitor.
+     * @param key - Optional lock key, auto-generated if not provided.
+     * @returns Function that removes the child lock relationship when called.
      */
     addChildLockSet(lockSet: LockSet, key?: LockKey): RemoveLockFunction;
     get isDestroyed(): boolean;
@@ -213,8 +213,8 @@ export declare class LockSet implements Destroyable {
      * After the unlock event (or timeout), the optional callback is invoked and then
      * {@link destroy} is called after a short delay.
      *
-     * @param config - optional callback or configuration for the unlock wait
-     * @param delayTime - optional delay in milliseconds after unlock before invoking the callback
+     * @param config - Optional callback or configuration for the unlock wait.
+     * @param delayTime - Optional delay in milliseconds after unlock before invoking the callback.
      */
     destroyOnNextUnlock(config?: Maybe<DestroyOnNextUnlockConfig['fn'] | DestroyOnNextUnlockConfig>, delayTime?: Milliseconds): void;
     /**

package/src/lib/object.d.ts

@@ -5,7 +5,7 @@ import { type MonoTypeOperatorFunction, type Observable } from 'rxjs';
  * Uses {@link areEqualPOJOValues} for comparison, so the emitted objects should be plain objects
  * or compatible with deep value equality checks.
  *
- * @returns operator that filters out consecutive duplicate POJO emissions
+ * @returns Operator that filters out consecutive duplicate POJO emissions.
  *
  * @example
  * ```ts