@dereekb/rxjs 13.3.1 → 13.4.1

package/src/lib/rxjs/value.d.ts

@@ -1,5 +1,5 @@
 import { type MonoTypeOperatorFunction, type Observable, type OperatorFunction } from 'rxjs';
-import { type DecisionFunction, type GetterOrValue, type MapFunction, type Maybe, type MaybeSoStrict } from '@dereekb/util';
+import { type DecisionFunction, type GetterOrValue, type MapFunction, type Maybe, type Milliseconds, type MaybeSoStrict } from '@dereekb/util';
 import { type MaybeObservableOrValueGetter, type ObservableOrValueGetter, type MaybeObservableOrValue } from './getter';
 import { type ObservableDecisionFunction } from './decision';
 /**
@@ -59,6 +59,7 @@ export declare function makeIsModifiedFunctionObservable<T>(config: MakeIsModifi
  *
  * @param isCheckFunction - optional check function
  * @param defaultValueOnMaybe - default result for null/undefined values
+ * @returns a function that evaluates each value against the check function and returns it or undefined
  */
 export declare function makeReturnIfIsFunction<T>(isCheckFunction: Maybe<IsModifiedFunction<T>>, defaultValueOnMaybe?: boolean): (value: Maybe<T>) => Observable<Maybe<T>>;
 /**
@@ -67,6 +68,7 @@ export declare function makeReturnIfIsFunction<T>(isCheckFunction: Maybe<IsModif
  * @param isCheckFunction - optional check function
  * @param value - the value to check
  * @param defaultValueOnMaybe - default result for null/undefined values
+ * @returns an observable that emits the value if the check passes, or undefined otherwise
  */
 export declare function returnIfIs<T>(isCheckFunction: Maybe<IsModifiedFunction<T>>, value: Maybe<T>, defaultValueOnMaybe?: boolean): Observable<Maybe<T>>;
 /**
@@ -74,6 +76,7 @@ export declare function returnIfIs<T>(isCheckFunction: Maybe<IsModifiedFunction<
  *
  * @param isCheckFunction - optional check function
  * @param defaultValueOnMaybe - default result for null/undefined values
+ * @returns a function that evaluates each value against the check function and returns an observable boolean
  */
 export declare function makeCheckIsFunction<T>(isCheckFunction: Maybe<IsModifiedFunction<T>>, defaultValueOnMaybe?: boolean): (value: Maybe<T>) => Observable<boolean>;
 /**
@@ -84,10 +87,13 @@ export declare function makeCheckIsFunction<T>(isCheckFunction: Maybe<IsModified
  * @param isCheckFunction - optional check function
  * @param value - the value to check
  * @param defaultValueOnMaybe - default result for null/undefined values (defaults to false)
+ * @returns an observable boolean indicating whether the value passes the check
  */
 export declare function checkIs<T>(isCheckFunction: Maybe<IsModifiedFunction<T>>, value: Maybe<T>, defaultValueOnMaybe?: boolean): Observable<boolean>;
 /**
  * RxJS operator that filters out null and undefined values, only passing through defined values.
+ *
+ * @returns operator that filters out null and undefined emissions
  */
 export declare function filterMaybe<T>(): OperatorFunction<Maybe<T>, T>;
 /**
@@ -96,20 +102,27 @@ export declare function filterMaybe<T>(): OperatorFunction<Maybe<T>, T>;
 export declare const filterMaybeStrict: <T>() => OperatorFunction<Maybe<T>, MaybeSoStrict<T>>;
 /**
  * RxJS operator that filters out null/undefined elements from an emitted array, keeping only defined values.
+ *
+ * @returns operator that maps each emitted array to a version with null/undefined elements removed
  */
 export declare function filterMaybeArray<T>(): OperatorFunction<Maybe<T>[], T[]>;
 /**
  * RxJS operator that skips all leading null/undefined emissions, then passes all subsequent values through.
+ *
+ * @returns operator that skips all null/undefined emissions at the start of the stream
  */
 export declare function skipAllInitialMaybe<T>(): MonoTypeOperatorFunction<T>;
 /**
  * RxJS operator that skips only the first emission if it is null/undefined, then passes all subsequent values.
+ *
+ * @returns operator that skips the first null/undefined emission if it occurs at the start of the stream
  */
 export declare function skipInitialMaybe<T>(): MonoTypeOperatorFunction<T>;
 /**
  * RxJS operator that skips up to `maxToSkip` null/undefined emissions, then passes all subsequent values.
  *
  * @param maxToSkip - maximum number of null/undefined emissions to skip
+ * @returns operator that skips the first N null/undefined emissions from the stream
  */
 export declare function skipMaybes<T>(maxToSkip: number): MonoTypeOperatorFunction<T>;
 /**
@@ -135,16 +148,22 @@ export declare function switchMapToDefault<T = unknown>(defaultObs: MaybeObserva
 export declare function switchMapToDefault<T = unknown>(defaultObs: ObservableOrValueGetter<T>): OperatorFunction<Maybe<T>, T>;
 export declare function switchMapToDefault<T = unknown>(defaultObs: MaybeObservableOrValueGetter<T>, useDefault?: SwitchMapToDefaultFilterFunction<T>): OperatorFunction<Maybe<T>, Maybe<T>>;
 export interface SwitchMapObjectConfig<T> {
-    defaultGetter?: GetterOrValue<Maybe<T>>;
+    readonly defaultGetter?: GetterOrValue<Maybe<T>>;
 }
 /**
  * RxJS operator that resolves an observable/getter config input into a value, applying defaults
  * for `null`/`undefined`/`true` inputs and emitting `null` for `false`.
+ *
+ * @param config - configuration providing an optional default getter for null/undefined/true inputs
+ * @returns operator that resolves each emitted getter into a value, using the default for nullish or true inputs
  */
 export declare function switchMapObject<T extends object>(config: SwitchMapObjectConfig<T>): OperatorFunction<Maybe<ObservableOrValueGetter<Maybe<T | boolean>>>, Maybe<T>>;
 /**
  * RxJS operator that emits from the given observable/getter when the source boolean is `true`,
  * otherwise emits from the `otherwise` source or `EMPTY`.
+ *
+ * @param obs - observable or getter to subscribe to when the source emits `true`
+ * @returns operator that switches to the given source when the boolean is true
  */
 export declare function switchMapWhileTrue<T = unknown>(obs: ObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
 export declare function switchMapWhileTrue<T = unknown>(obs: MaybeObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
@@ -153,6 +172,9 @@ export declare function switchMapWhileTrue<T = unknown>(obs: MaybeObservableOrVa
 /**
  * RxJS operator that emits from the given observable/getter when the source boolean is `false`,
  * otherwise emits from the `otherwise` source or `EMPTY`.
+ *
+ * @param obs - observable or getter to subscribe to when the source emits `false`
+ * @returns operator that switches to the given source when the boolean is false
  */
 export declare function switchMapWhileFalse<T = unknown>(obs: ObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
 export declare function switchMapWhileFalse<T = unknown>(obs: MaybeObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
@@ -165,6 +187,7 @@ export declare function switchMapWhileFalse<T = unknown>(obs: MaybeObservableOrV
  * @param switchOnValue - the boolean value that triggers emitting from `obs`
  * @param obs - observable/getter to emit from when matched
  * @param otherwise - optional observable/getter for the non-matching case
+ * @returns operator that switches to the appropriate source based on the emitted boolean value
  */
 export declare function switchMapOnBoolean<T = unknown>(switchOnValue: boolean, obs: MaybeObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
 export declare function switchMapOnBoolean<T = unknown>(switchOnValue: boolean, obs: MaybeObservableOrValueGetter<T>, otherwise?: MaybeObservableOrValueGetter<T>): OperatorFunction<boolean, Maybe<T>>;
@@ -172,10 +195,14 @@ export declare function switchMapOnBoolean<T = unknown>(switchOnValue: boolean,
  * RxJS operator that filters out null/undefined observables and then switches to the remaining ones.
  *
  * Combines {@link filterMaybe} and `switchMap` to only subscribe to non-nullish observables.
+ *
+ * @returns operator that filters nullish observables and subscribes to the non-nullish ones
  */
 export declare function switchMapFilterMaybe<T = unknown>(): OperatorFunction<Maybe<Observable<Maybe<T>>>, T>;
 /**
  * RxJS operator that switches to the emitted observable if defined, or emits `undefined` when the observable is nullish.
+ *
+ * @returns operator that switches to the emitted observable or emits undefined for null/undefined inputs
  */
 export declare function switchMapMaybe<T = unknown>(): OperatorFunction<Maybe<Observable<Maybe<T>>>, Maybe<T>>;
 /**
@@ -194,20 +221,29 @@ export declare function mapMaybe<A, B>(mapFn: MapFunction<A, Maybe<B>>): Operato
  */
 export declare function mapIf<A, B>(mapFn: MapFunction<Maybe<A>, Maybe<B>>, decision: DecisionFunction<Maybe<A>>): OperatorFunction<Maybe<A>, Maybe<B>>;
 /**
- * Combines both combineLatest with map values to an other value.
+ * Combines the source observable with another observable via `combineLatest`, then maps the pair to a result.
  *
- * @param combineObs
- * @param mapFn
- * @returns
+ * @param combineObs - the secondary observable to combine with the source
+ * @param mapFn - function that maps the source value and combined value to the output
+ * @returns operator that combines the source with `combineObs` and maps each pair using `mapFn`
  */
 export declare function combineLatestMapFrom<A, B, C>(combineObs: Observable<B>, mapFn: (a: A, b: B) => C): OperatorFunction<A, C>;
 /**
  * Creates an observable that emits a starting value, then a second value after a delay.
  *
  * If the delay is not provided, or is falsy, then the second value is never emitted.
+ *
+ * @param startWith - the value to emit immediately
+ * @param endWith - the value to emit after the delay
+ * @param delayTime - optional delay in milliseconds before emitting the second value
+ * @returns an observable that emits `startWith` immediately and `endWith` after the delay (if provided)
  */
-export declare function emitDelayObs<T>(startWith: T, endWith: T, delayTime: Maybe<number>): Observable<T>;
+export declare function emitDelayObs<T>(startWith: T, endWith: T, delayTime: Maybe<Milliseconds>): Observable<T>;
 /**
  * Emits a value after a given delay after every new emission.
+ *
+ * @param value - the value to emit after the delay
+ * @param delayTime - duration in milliseconds before emitting the value
+ * @returns operator that appends the given value after each source emission with the specified delay
  */
-export declare function emitAfterDelay<T>(value: T, delayTime: number): MonoTypeOperatorFunction<T>;
+export declare function emitAfterDelay<T>(value: T, delayTime: Milliseconds): MonoTypeOperatorFunction<T>;

package/src/lib/subscription.d.ts

@@ -26,6 +26,8 @@ export declare class SubscriptionObject<T extends Unsubscribable = Unsubscribabl
     constructor(sub?: Maybe<T>);
     /**
      * Whether a subscription is currently being managed.
+     *
+     * @returns true if a subscription is currently active
      */
     get hasSubscription(): boolean;
     /**
@@ -77,6 +79,8 @@ export declare class MultiSubscriptionObject<T extends Unsubscribable = Unsubscr
     constructor(subs?: ArrayOrValue<T>);
     /**
      * Whether any subscriptions are currently being managed.
+     *
+     * @returns true if one or more subscriptions are currently active
      */
     get hasSubscription(): boolean;
     /**

package/src/lib/work/work.factory.d.ts

@@ -52,6 +52,8 @@ export interface WorkFactoryConfig<T, O> {
  * ```
  *
  * @param config - work function and delegate configuration
+ * @param config.work - the work function to execute for each input value
+ * @param config.delegate - delegate that receives lifecycle callbacks (start, success, reject)
  * @returns a factory function that creates WorkInstance for each input
  */
 export declare function workFactory<T, O>({ work, delegate }: WorkFactoryConfig<T, O>): WorkFactory<T, O>;

package/src/lib/work/work.instance.d.ts

@@ -61,7 +61,7 @@ export declare class WorkInstance<I = unknown, O = unknown> implements Destroyab
      *
      * If the loading state returns an error, the error is forwarded.
      *
-     * @param loadingStateObs
+     * @param loadingStateObs - observable of the loading state to track as the work result
      */
     startWorkingWithLoadingStateObservable(loadingStateObs: Observable<Maybe<LoadingState<O>>>): void;
     /**
@@ -71,7 +71,8 @@ export declare class WorkInstance<I = unknown, O = unknown> implements Destroyab
      *
      * It is used in conjunction with startWorking() and ideal for cases where multiple observables or promises are used.
      *
-     * @param loadingStateObs
+     * @param loadingStateObs - promise or observable of the loading state to track for errors
+     * @returns a promise that resolves with the value from the loading state or rejects on error
      */
     performTaskWithLoadingState<T>(loadingStateObs: Promise<LoadingState<T>> | Observable<Maybe<LoadingState<T>>>): Promise<T>;
     /**
@@ -79,15 +80,19 @@ export declare class WorkInstance<I = unknown, O = unknown> implements Destroyab
      *
      * If an error is thrown, the error is forwarded to the reject function.
      *
-     * @param fn
+     * @param fn - synchronous function that returns the result value or throws an error
      */
     performTaskWithReturnValue(fn: () => O): void;
     /**
      * Begins working using a promise.
+     *
+     * @param promise - the promise that represents the asynchronous work
      */
     startWorkingWithPromise(promise: Promise<O>): void;
     /**
      * Begins working using an observable.
+     *
+     * @param workObs - the observable that represents the asynchronous work and emits the result
      */
     startWorkingWithObservable(workObs: Observable<O>): void;
     /**
@@ -96,10 +101,14 @@ export declare class WorkInstance<I = unknown, O = unknown> implements Destroyab
     startWorking(): void;
     /**
      * Sets success on the work.
+     *
+     * @param result - the successful result value to pass to the delegate
      */
     success(result?: O): void;
     /**
      * Sets rejected on the work.
+     *
+     * @param error - the error to pass to the delegate as the rejection reason
      */
     reject(error?: ErrorInput): void;
     destroy(): void;