@dereekb/rxjs 13.11.14 → 13.11.16

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

@@ -55,15 +55,15 @@ export type ScanBuildArrayConfigFn<S, T> = (seedState: S) => ScanBuildArrayConfi
  * are incrementally appended. Useful when loading large datasets where the initial page and
  * subsequent pages come from different sources.
  *
- * @param init - function that receives the seed state and returns the accumulator config
- * @returns an operator that emits the growing array
+ * @param init - Function that receives the seed state and returns the accumulator config.
+ * @returns An operator that emits the growing array.
  */
 export declare function scanBuildArray<S, T>(init: ScanBuildArrayConfigFn<S, T>): OperatorFunction<S, T[]>;
 /**
  * RxJS operator that executes a side-effect on each element of the emitted array, then passes the array through.
  *
- * @param forEach - callback to run for each element, or null/undefined to pass through unchanged
- * @returns an operator that taps each element in emitted arrays
+ * @param forEach - Callback to run for each element, or null/undefined to pass through unchanged.
+ * @returns An operator that taps each element in emitted arrays.
  */
 export declare function mapForEach<T>(forEach: Maybe<(value: T) => void>): MonoTypeOperatorFunction<T[]>;
 export interface MapEachAsyncConfig {
@@ -78,8 +78,8 @@ export interface MapEachAsyncConfig {
  *
  * Emits `[]` for empty arrays. When `onlyFirst` is true, takes only the first combined emission.
  *
- * @param mapFunction - function that maps each item to an ObservableInput
- * @param config - optional config (e.g., `onlyFirst`)
- * @returns an operator that async-maps each array element
+ * @param mapFunction - Function that maps each item to an ObservableInput.
+ * @param config - Optional config (e.g., `onlyFirst`)
+ * @returns An operator that async-maps each array element.
  */
 export declare function mapEachAsync<I, O>(mapFunction: MapFunction<I, ObservableInput<O>>, config?: MapEachAsyncConfig): OperatorFunction<I[], O[]>;

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

@@ -2,26 +2,26 @@ import { type OperatorFunction, type MonoTypeOperatorFunction } from 'rxjs';
 /**
  * Conditionally applies an operator. Returns the given pipe when `usePipe` is true, otherwise returns identity (pass-through).
  *
- * @param usePipe - whether to apply the pipe
- * @param pipe - the operator to conditionally apply
- * @returns the pipe or identity operator
+ * @param usePipe - Whether to apply the pipe.
+ * @param pipe - The operator to conditionally apply.
+ * @returns The pipe or identity operator.
  */
 export declare function pipeIf<A>(usePipe: boolean, pipe: OperatorFunction<A, A>): OperatorFunction<A, A>;
 /**
  * RxJS operator that negates each emitted boolean value.
  *
- * @returns operator that maps each boolean emission to its negated value
+ * @returns Operator that maps each boolean emission to its negated value.
  */
 export declare function isNot(): MonoTypeOperatorFunction<boolean>;
 /**
  * RxJS operator that only emits when a boolean stream transitions from `true` to `false`.
  *
- * @returns operator that filters to only true-to-false transition emissions
+ * @returns Operator that filters to only true-to-false transition emissions.
  */
 export declare function onTrueToFalse(): MonoTypeOperatorFunction<boolean>;
 /**
  * RxJS operator that only emits when a boolean stream transitions from `false` to `true`.
  *
- * @returns operator that filters to only false-to-true transition emissions
+ * @returns Operator that filters to only false-to-true transition emissions.
  */
 export declare function onFalseToTrue(): MonoTypeOperatorFunction<boolean>;

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

@@ -9,9 +9,9 @@ export type ObservableDecisionFunction<T> = (value: T) => Observable<boolean>;
  *
  * When `invert` is false, returns the original function unchanged.
  *
- * @param decisionFn - the decision function to invert
- * @param invert - whether to apply the inversion (defaults to true)
- * @returns the inverted (or original) decision function
+ * @param decisionFn - The decision function to invert.
+ * @param invert - Whether to apply the inversion (defaults to true)
+ * @returns The inverted (or original) decision function.
  */
 export declare function invertObservableDecision<F extends ObservableDecisionFunction<any>>(decisionFn: F, invert?: boolean): F;
 /**
@@ -20,8 +20,8 @@ export declare function invertObservableDecision<F extends ObservableDecisionFun
  * Items where the decision returns true are kept; others are removed. Results are throttled
  * to prevent excessive re-emissions.
  *
- * @param observableDecisionFunction - async predicate to evaluate each item
- * @param throttle - throttle duration in ms (defaults to 20)
- * @returns an operator that async-filters array elements
+ * @param observableDecisionFunction - Async predicate to evaluate each item.
+ * @param throttle - Throttle duration in ms (defaults to 20)
+ * @returns An operator that async-filters array elements.
  */
 export declare function filterItemsWithObservableDecision<T>(observableDecisionFunction: ObservableDecisionFunction<T>, throttle?: Milliseconds): MonoTypeOperatorFunction<T[]>;

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

@@ -6,23 +6,23 @@ export interface OnMatchDeltaConfig<T> {
     /**
      * The first from value.
      */
-    from: T;
+    readonly from: T;
     /**
      * The target value to receive after the first.
      */
-    to: T;
+    readonly to: T;
     /**
      * Comparison function to compare equality between the emission and the target values.
      *
      * isMatch is checked for each value, and at the time a match is found, allowing a double check to occur on the from target value.
      */
-    isMatch?: (a: T, b: T) => boolean;
+    readonly isMatch?: (a: T, b: T) => boolean;
     /**
      * Whether or not the two values must be emitted consecutively.
      *
      * For example, if requiredConsecutive=true and we are waiting for 1 -> 2, and the emissions are 1,0,2, the observable function will not emit 2.
      */
-    requireConsecutive?: boolean;
+    readonly requireConsecutive?: boolean;
 }
 /**
  * RxJS operator that emits only when the stream transitions from a `from` value to a `to` value.
@@ -30,6 +30,9 @@ export interface OnMatchDeltaConfig<T> {
  * The `from` value must be seen first; only then is the `to` value emitted. When `requireConsecutive`
  * is true, the two values must be adjacent emissions.
  *
+ * @param config - From/to values, optional comparator, and consecutive requirement.
+ * @returns An operator that emits on value transitions.
+ *
  * @example
  * ```ts
  * // Emit when transitioning from true to false
@@ -37,8 +40,5 @@ export interface OnMatchDeltaConfig<T> {
  *   onMatchDelta({ from: true, to: false, requireConsecutive: true })
  * ).subscribe((val) => console.log('Transitioned to false'));
  * ```
- *
- * @param config - from/to values, optional comparator, and consecutive requirement
- * @returns an operator that emits on value transitions
  */
 export declare function onMatchDelta<T>(config: OnMatchDeltaConfig<T>): MonoTypeOperatorFunction<T>;

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

@@ -4,44 +4,44 @@ import { type MonoTypeOperatorFunction, type Observable, type OperatorFunction }
  * RxJS operator that maps each emission to a new {@link Expires} object with an expiration
  * time relative to the current moment.
  *
- * @param expiresIn - duration in milliseconds until expiration
- * @returns an `OperatorFunction` that maps each emission to an {@link Expires} object
+ * @param expiresIn - Duration in milliseconds until expiration.
+ * @returns An `OperatorFunction` that maps each emission to an {@link Expires} object.
  */
 export declare function toExpiration<T>(expiresIn: number): OperatorFunction<T, Expires>;
 /**
  * RxJS operator that filters out emissions whose {@link Expires} value has already expired.
  *
- * @returns operator that only passes through non-expired emissions
+ * @returns Operator that only passes through non-expired emissions.
  */
 export declare function skipExpired<T extends Expires>(): MonoTypeOperatorFunction<T>;
 /**
  * RxJS operator that skips emissions until the elapsed time since the emitted date/timestamp has exceeded `expiresIn`.
  *
- * @param expiresIn - duration in milliseconds
- * @returns operator that skips emissions until the time window has elapsed
+ * @param expiresIn - Duration in milliseconds.
+ * @returns Operator that skips emissions until the time window has elapsed.
  */
 export declare function skipUntilExpiration(expiresIn?: number): MonoTypeOperatorFunction<DateOrUnixDateTimeMillisecondsNumber>;
 /**
  * RxJS operator that skips emissions after the elapsed time since the emitted date/timestamp has exceeded `expiresIn`.
  *
- * @param expiresIn - duration in milliseconds
- * @returns operator that passes through emissions only within the time window
+ * @param expiresIn - Duration in milliseconds.
+ * @returns Operator that passes through emissions only within the time window.
  */
 export declare function skipAfterExpiration(expiresIn?: number): MonoTypeOperatorFunction<DateOrUnixDateTimeMillisecondsNumber>;
 /**
  * RxJS operator that only takes emissions from the source within a time window after each emission from a watch observable.
  *
- * @param watch - observable whose emissions reset the time window
- * @param takeFor - duration in milliseconds of each time window
- * @returns operator that limits source emissions to the active time window after each watch emission
+ * @param watch - Observable whose emissions reset the time window.
+ * @param takeFor - Duration in milliseconds of each time window.
+ * @returns Operator that limits source emissions to the active time window after each watch emission.
  */
 export declare function skipUntilTimeElapsedAfterLastEmission<T>(watch: Observable<unknown>, takeFor: Milliseconds): MonoTypeOperatorFunction<T>;
 /**
  * RxJS operator that skips emissions from the source for a duration after each emission from a watch observable,
  * then passes values through once the time has elapsed.
  *
- * @param watch - observable whose emissions reset the skip window
- * @param skipFor - duration in milliseconds to skip after each watch emission
- * @returns an operator that delays passing values through until time has elapsed since the last watch emission
+ * @param watch - Observable whose emissions reset the skip window.
+ * @param skipFor - Duration in milliseconds to skip after each watch emission.
+ * @returns An operator that delays passing values through until time has elapsed since the last watch emission.
  */
 export declare function takeAfterTimeElapsedSinceLastEmission<T>(watch: Observable<unknown>, skipFor: Milliseconds): MonoTypeOperatorFunction<T>;

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

@@ -7,19 +7,19 @@ export interface FactoryTimerConfig<T> {
     /**
      * How long to wait before the first emission.
      */
-    wait?: number;
+    readonly wait?: number;
     /**
      * Interval period
      */
-    interval?: number;
+    readonly interval?: number;
     /**
      * Max number of iterations.
      */
-    limit?: number;
+    readonly limit?: number;
     /**
      * Factory for values.
      */
-    factory: FactoryWithInput<T, number>;
+    readonly factory: FactoryWithInput<T, number>;
 }
 export declare const DEFAULT_FACTORY_TIMER_INTERVAL = 1000;
 /**
@@ -28,6 +28,9 @@ export declare const DEFAULT_FACTORY_TIMER_INTERVAL = 1000;
  * Wraps `timer()` internally and maps each tick index through the factory. Optionally limits
  * the total number of emissions.
  *
+ * @param config - Timer configuration including factory, interval, wait, and limit.
+ * @returns An observable of factory-produced values.
+ *
  * @example
  * ```ts
  * const countdown$ = factoryTimer({
@@ -37,8 +40,5 @@ export declare const DEFAULT_FACTORY_TIMER_INTERVAL = 1000;
  * });
  * // emits 10, 9, 8, ... 0
  * ```
- *
- * @param config - timer configuration including factory, interval, wait, and limit
- * @returns an observable of factory-produced values
  */
 export declare function factoryTimer<T>(config: FactoryTimerConfig<T>): Observable<T>;

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

@@ -16,14 +16,14 @@ export declare function asObservable<T>(valueOrObs: Maybe<ObservableOrValue<T>>)
 /**
  * RxJS operator that flattens an emitted {@link ObservableOrValue} into its unwrapped value via `switchMap`.
  *
- * @returns an operator that unwraps ObservableOrValue emissions
+ * @returns An operator that unwraps ObservableOrValue emissions.
  */
 export declare function valueFromObservableOrValue<T>(): OperatorFunction<ObservableOrValue<T>, T>;
 /**
  * RxJS operator that flattens an emitted Maybe<{@link ObservableOrValue}> into its unwrapped value,
  * emitting `undefined` when the input is nullish.
  *
- * @returns an operator that unwraps Maybe<ObservableOrValue> emissions
+ * @returns An operator that unwraps Maybe<ObservableOrValue> emissions.
  */
 export declare function maybeValueFromObservableOrValue<T>(): OperatorFunction<MaybeObservableOrValue<T>, Maybe<T>>;
 /**
@@ -48,14 +48,14 @@ export declare function asObservableFromGetter<T extends GetterDistinctValue, A>
 /**
  * RxJS operator that flattens an emitted {@link ObservableOrValueGetter} into its resolved value via `switchMap`.
  *
- * @returns an operator that unwraps getter emissions
+ * @returns An operator that unwraps getter emissions.
  */
 export declare function valueFromObservableOrValueGetter<T>(): OperatorFunction<ObservableOrValueGetter<T>, T>;
 /**
  * RxJS operator that flattens an emitted Maybe<{@link ObservableOrValueGetter}> into its resolved value,
  * emitting `undefined` when the input is nullish.
  *
- * @returns an operator that unwraps Maybe<ObservableOrValueGetter> emissions, emitting undefined for nullish inputs
+ * @returns An operator that unwraps Maybe<ObservableOrValueGetter> emissions, emitting undefined for nullish inputs.
  */
 export declare function maybeValueFromObservableOrValueGetter<T>(): OperatorFunction<MaybeObservableOrValueGetter<T>, Maybe<T>>;
 /**

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

@@ -4,14 +4,14 @@ import { type MonoTypeOperatorFunction } from 'rxjs';
  * `distinctUntilChanged` variant for arrays that only emits when the set of keys extracted from
  * the array elements changes.
  *
- * @param readKey - function to extract one or more keys from each element
- * @returns an operator that filters out arrays with unchanged key sets
+ * @param readKey - Function to extract one or more keys from each element.
+ * @returns An operator that filters out arrays with unchanged key sets.
  */
 export declare function distinctUntilKeysChange<T, K extends PrimativeKey = PrimativeKey>(readKey: ReadKeyFunction<T, K> | ReadMultipleKeysFunction<T, K>): MonoTypeOperatorFunction<T[]>;
 /**
  * `distinctUntilChanged` variant for single objects that only emits when the extracted key changes.
  *
- * @param readKey - function to extract a key from the emitted object
- * @returns an operator that filters out emissions with unchanged keys
+ * @param readKey - Function to extract a key from the emitted object.
+ * @returns An operator that filters out emissions with unchanged keys.
  */
 export declare function distinctUntilObjectKeyChange<T>(readKey: ReadKeyFunction<T>): MonoTypeOperatorFunction<T>;

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

@@ -7,9 +7,9 @@ import { type MonoTypeOperatorFunction } from 'rxjs';
  * delays emitting the new value until the previous destruction completes.
  * On unsubscription, the last emitted instance is also destroyed.
  *
- * @param destroy - function to clean up each replaced instance
- * @param wait - whether to wait for the previous destroy to complete before emitting
- * @returns an operator that manages instance lifecycle
+ * @param destroy - Function to clean up each replaced instance.
+ * @param wait - Whether to wait for the previous destroy to complete before emitting.
+ * @returns An operator that manages instance lifecycle.
  */
 export declare function cleanup<T>(destroy: (instance: T) => PromiseOrValue<void>, wait?: boolean): MonoTypeOperatorFunction<T>;
 /**
@@ -18,7 +18,7 @@ export declare function cleanup<T>(destroy: (instance: T) => PromiseOrValue<void
  * Accepts both {@link Destroyable} and {@link Maybe}<{@link Destroyable}> values,
  * skipping cleanup for nullish emissions.
  *
- * @param wait - whether to wait for the previous destroy to complete before emitting
- * @returns an operator that manages Destroyable lifecycle
+ * @param wait - Whether to wait for the previous destroy to complete before emitting.
+ * @returns An operator that manages Destroyable lifecycle.
  */
 export declare function cleanupDestroyable<T extends Maybe<Destroyable>>(wait?: boolean): MonoTypeOperatorFunction<T>;

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

@@ -4,12 +4,12 @@ import { type OperatorFunction } from 'rxjs';
  *
  * Only considers the first emission from the source. The result is shared via `shareReplay(1)`.
  *
+ * @returns An operator that tracks whether the first value has been emitted.
+ *
  * @example
  * ```ts
  * const loading$ = dataFetch$.pipe(isLoading());
  * // emits true initially, then false once dataFetch$ emits
  * ```
- *
- * @returns an operator that tracks whether the first value has been emitted
  */
 export declare function isLoading<T>(): OperatorFunction<T, boolean>;

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

@@ -5,13 +5,13 @@ import { type ObservableOrValue } from './getter';
  * RxJS operator that extracts values from a keyed object using a keys observable,
  * returning only the values whose keys are present in both.
  *
- * @param keysObs - observable (or static value) of keys to intersect with
- * @returns an operator that maps a keyed object to an array of matching values
+ * @param keysObs - Observable (or static value) of keys to intersect with.
+ * @returns An operator that maps a keyed object to an array of matching values.
  */
 export declare function mapKeysIntersectionToArray<T>(keysObs: ObservableOrValue<Iterable<string>>): OperatorFunction<MapKeysIntersectionObject<T>, T[]>;
 /**
  * `distinctUntilChanged` variant for `Map` instances that only emits when the set of map keys changes.
  *
- * @returns an operator that filters out Maps with unchanged key sets
+ * @returns An operator that filters out Maps with unchanged key sets.
  */
 export declare function distinctUntilMapHasDifferentKeys<I extends Map<K, V>, K, V>(): MonoTypeOperatorFunction<I>;

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

@@ -24,16 +24,17 @@ export declare function tapLog<T = unknown>(messageFunction: (value: T) => unkno
  *
  * Useful for simulating network latency or staggering requests.
  *
- * @param maxOrArgs - maximum delay in ms, or a full random number config
- * @returns an operator that delays each emission by a random amount
+ * @param maxOrArgs - Maximum delay in ms, or a full random number config.
+ * @returns An operator that delays each emission by a random amount.
  */
 export declare function randomDelay<T = unknown>(maxOrArgs: number | RandomNumberFactoryConfig): MonoTypeOperatorFunction<T>;
 /**
  * RxJS operator that adds a random delay using a custom random number generator.
  *
- * @param makeRandomDelay - factory that produces random delay values
- * @param scheduler - the scheduler to use for the delay (defaults to asyncScheduler)
- * @returns an operator that delays each emission
+ * @param makeRandomDelay - Factory that produces random delay values.
+ * @param scheduler - The scheduler to use for the delay (defaults to asyncScheduler)
+ * @returns An operator that delays each emission.
+ *
  * @__NO_SIDE_EFFECTS__
  */
 export declare function randomDelayWithRandomFunction<T = unknown>(makeRandomDelay: RandomNumberFactory, scheduler?: SchedulerLike): MonoTypeOperatorFunction<T>;

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

@@ -2,12 +2,12 @@ import { type ModelKeyRef, type UniqueModel } from '@dereekb/util';
 /**
  * `distinctUntilChanged` variant that only emits when the model's `id` property changes.
  *
- * @returns operator that suppresses consecutive emissions with the same model `id`
+ * @returns Operator that suppresses consecutive emissions with the same model `id`
  */
 export declare function distinctUntilModelIdChange<T extends UniqueModel>(): import("rxjs").MonoTypeOperatorFunction<T>;
 /**
  * `distinctUntilChanged` variant that only emits when the model's `key` property changes.
  *
- * @returns operator that suppresses consecutive emissions with the same model `key`
+ * @returns Operator that suppresses consecutive emissions with the same model `key`
  */
 export declare function distinctUntilModelKeyChange<T extends ModelKeyRef>(): import("rxjs").MonoTypeOperatorFunction<T>;

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

@@ -5,8 +5,8 @@ import { type FactoryTimerConfig } from './factory';
  * RxJS operator that counts emissions as they occur using `scan`, emitting the running count
  * after each emission (unlike `count()` which only emits on completion).
  *
- * @param startAt - initial count value (defaults to 0)
- * @returns an operator that emits the running emission count
+ * @param startAt - Initial count value (defaults to 0)
+ * @returns An operator that emits the running emission count.
  */
 export declare function scanCount(startAt?: number): OperatorFunction<unknown, number>;
 /**
@@ -17,7 +17,7 @@ export interface IncrementingTimerConfig extends Omit<FactoryTimerConfig<number>
 /**
  * Creates a {@link factoryTimer} that emits incrementing numbers on an interval.
  *
- * @param config - timer and incrementing number configuration
- * @returns an observable of incrementing numbers
+ * @param config - Timer and incrementing number configuration.
+ * @returns An observable of incrementing numbers.
  */
 export declare function incrementingNumberTimer(config?: IncrementingTimerConfig): Observable<number>;

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

@@ -45,6 +45,9 @@ export interface AsyncPusherConfig<T> {
  * Each call pushes a value onto the internal subject and returns the shared, throttled observable.
  * Useful for debouncing repeated calls while sharing a single observable output.
  *
+ * @param config - Optional throttle, distinct, and pipe settings.
+ * @returns An async pusher function.
+ *
  * @example
  * ```ts
  * const pusher = asyncPusher<string>({ throttle: 100 });
@@ -54,9 +57,6 @@ export interface AsyncPusherConfig<T> {
  * // clean up
  * pusher.destroy();
  * ```
- *
- * @param config - optional throttle, distinct, and pipe settings
- * @returns an async pusher function
  */
 export declare function asyncPusher<T>(config?: AsyncPusherConfig<T>): AsyncPusher<T>;
 /**
@@ -68,7 +68,7 @@ export type AsyncPusherCache<T> = CachedFactoryWithInput<AsyncPusher<T>, Observa
  *
  * The factory optionally accepts a cleanup observable — when it completes, the pusher is destroyed.
  *
- * @param config - optional config passed to the underlying async pusher
- * @returns a cached factory that produces an async pusher
+ * @param config - Optional config passed to the underlying async pusher.
+ * @returns A cached factory that produces an async pusher.
  */
 export declare function asyncPusherCache<T>(config?: AsyncPusherConfig<T>): AsyncPusherCache<T>;

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

@@ -5,18 +5,18 @@ import { type Observable, type MonoTypeOperatorFunction } from 'rxjs';
  *
  * Emits the `initial` value first, then taps on the first emitted value to run the provided callback.
  *
- * @param tap - side-effect function called with the first value
- * @param initial - optional starting value emitted before the source
- * @param skipFirst - if true, skips tapping the initial value
- * @returns an operator that initializes the pipe with a tap
+ * @param tap - Side-effect function called with the first value.
+ * @param initial - Optional starting value emitted before the source.
+ * @param skipFirst - If true, skips tapping the initial value.
+ * @returns An operator that initializes the pipe with a tap.
  */
 export declare function initialize<T>(tap: (value: Maybe<T>) => void, initial?: Maybe<T>, skipFirst?: boolean): MonoTypeOperatorFunction<T>;
 /**
  * Executes a side-effect on the first emission from the observable, then passes all values through.
  *
- * @param tap - the side-effect function to call once
- * @param skipFirst - if true, skips the very first emission before tapping
- * @returns an operator that taps the first value
+ * @param tap - The side-effect function to call once.
+ * @param skipFirst - If true, skips the very first emission before tapping.
+ * @returns An operator that taps the first value.
  */
 export declare function tapFirst<T>(tap: (value: T) => void, skipFirst?: boolean): MonoTypeOperatorFunction<T>;
 /**
@@ -25,8 +25,8 @@ export declare function tapFirst<T>(tap: (value: T) => void, skipFirst?: boolean
  * The subscription will never have `complete()` called since it only triggers after unsubscription.
  * Use `finalize()` for additional cleanup.
  *
- * @param obs - the source observable to wrap
- * @returns an observable that only completes on unsubscription
+ * @param obs - The source observable to wrap.
+ * @returns An observable that only completes on unsubscription.
  */
 export declare function preventComplete<T>(obs: Observable<T>): Observable<T>;
 /**
@@ -34,13 +34,13 @@ export declare function preventComplete<T>(obs: Observable<T>): Observable<T>;
  *
  * Unlike `from()`, the promise/observable is not created until the first subscriber connects.
  *
+ * @param getter - Factory that returns a Promise or Observable.
+ * @returns A shared observable that defers execution until subscription.
+ *
  * @example
  * ```ts
  * const data$ = lazyFrom(() => fetch('/api/data').then(r => r.json()));
  * // The fetch is not called until data$ is subscribed to
  * ```
- *
- * @param getter - factory that returns a Promise or Observable
- * @returns a shared observable that defers execution until subscription
  */
 export declare function lazyFrom<T>(getter: Getter<Promise<T> | Observable<T>>): Observable<T>;

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

@@ -42,6 +42,9 @@ export interface ErrorOnEmissionsInPeriodConfig<T> {
  *
  * Useful as a safety valve to detect infinite loops or runaway observables.
  *
+ * @param config - Period duration, max emissions, and error/fallback handling.
+ * @returns An operator that monitors emission frequency.
+ *
  * @example
  * ```ts
  * source$.pipe(
@@ -49,8 +52,5 @@ export interface ErrorOnEmissionsInPeriodConfig<T> {
  * ).subscribe();
  * // throws if more than 100 emissions occur within 1 second
  * ```
- *
- * @param config - period duration, max emissions, and error/fallback handling
- * @returns an operator that monitors emission frequency
  */
 export declare function errorOnEmissionsInPeriod<T>(config: ErrorOnEmissionsInPeriodConfig<T>): MonoTypeOperatorFunction<T>;

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

@@ -4,8 +4,8 @@ import { type PrimativeKey, type ReadKeyFunction, type ReadMultipleKeysFunction
  * Creates a function that takes a `Map` and combines the latest emissions from observables
  * created from each map value.
  *
- * @param mapToObs - function to transform each map value into an observable
- * @returns a function that converts a Map to a combined observable of results
+ * @param mapToObs - Function to transform each map value into an observable.
+ * @returns Operator-ready function that combines the per-entry observables into one emission of results.
  */
 export declare function combineLatestFromMapValuesObsFn<T, O>(mapToObs: (value: T) => Observable<O>): (map: Map<unknown, T>) => Observable<O[]>;
 /**
@@ -13,8 +13,8 @@ export declare function combineLatestFromMapValuesObsFn<T, O>(mapToObs: (value:
  *
  * Returns `of([])` for empty arrays.
  *
- * @param mapToObs - function to transform each value into an observable
- * @returns a function that converts an array to a combined observable
+ * @param mapToObs - Function to transform each value into an observable.
+ * @returns Operator-ready function that combines the latest emissions from each derived observable.
  */
 export declare function combineLatestFromArrayObsFn<T, O>(mapToObs: (value: T) => Observable<O>): (values: T[]) => Observable<O[]>;
 export type ObservableObjectMap = object;
@@ -27,6 +27,9 @@ export type ObservableObjectMapResult<T extends ObservableObjectMap> = {
  * Each key in the input object maps to an observable (or static value). The result observable
  * emits an object with the same keys, where each value is the latest emission from its source.
  *
+ * @param objectMap - An object whose values are observables or static values.
+ * @returns An observable that emits the resolved object.
+ *
  * @example
  * ```ts
  * const result$ = combineLatestFromObject({
@@ -35,23 +38,20 @@ export type ObservableObjectMapResult<T extends ObservableObjectMap> = {
  * });
  * // emits { name: 'Alice', age: 30 }
  * ```
- *
- * @param objectMap - an object whose values are observables or static values
- * @returns an observable that emits the resolved object
  */
 export declare function combineLatestFromObject<T extends ObservableObjectMap>(objectMap: T): Observable<ObservableObjectMapResult<T>>;
 /**
  * RxJS operator that maps an array of items to a `Map<K, T>` using the provided key reader.
  *
- * @param read - function to extract the key from each item
- * @returns an operator that converts an array into a keyed Map
+ * @param read - Function to extract the key from each item.
+ * @returns An operator that converts an array into a keyed Map.
  */
 export declare function keyValueMap<T, K extends PrimativeKey = PrimativeKey>(read: ReadKeyFunction<T, K>): OperatorFunction<T[], Map<K, T>>;
 /**
  * RxJS operator that maps an array of items to a `Map<K, T>` using a multi-key reader,
  * allowing each item to appear under multiple keys.
  *
- * @param read - function to extract multiple keys from each item
- * @returns an operator that converts an array into a multi-keyed Map
+ * @param read - Function to extract multiple keys from each item.
+ * @returns An operator that converts an array into a multi-keyed Map.
  */
 export declare function multiKeyValueMap<T, K extends PrimativeKey = PrimativeKey>(read: ReadMultipleKeysFunction<T, K>): OperatorFunction<T[], Map<K, T>>;

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

@@ -5,8 +5,8 @@ import { type MonoTypeOperatorFunction } from 'rxjs';
  *
  * Uses {@link filterUniqueFunction} to deduplicate emitted arrays by extracting a key from each item.
  *
- * @param readKey - function to extract the unique key from each item
- * @param additionalKeysInput - optional additional keys to include in the unique set
- * @returns an operator that emits deduplicated arrays
+ * @param readKey - Function to extract the unique key from each item.
+ * @param additionalKeysInput - Optional additional keys to include in the unique set.
+ * @returns An operator that emits deduplicated arrays.
  */
 export declare function filterUnique<T, K extends PrimativeKey = PrimativeKey>(readKey: ReadKeyFunction<T, K>, additionalKeysInput?: FilterUniqueFunctionAdditionalKeysInput<T, K>): MonoTypeOperatorFunction<T[]>;