@dereekb/rxjs 11.1.8 → 12.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dereekb/rxjs",
-  "version": "11.1.8",
+  "version": "12.0.1",
   "exports": {
     ".": {
       "types": "./src/index.d.ts",
@@ -21,5 +21,6 @@
     "@dereekb/util": "*"
   },
   "module": "./index.esm.js",
-  "main": "./index.cjs.js"
-}
+  "main": "./index.cjs.js",
+  "types": "./index.esm.d.ts"
+}

package/src/lib/filter/filter.source.d.ts

@@ -1,7 +1,12 @@
 import { type Observable } from 'rxjs';
 import { type FilterSource } from './filter';
-import { type ObservableOrValue } from '../rxjs/getter';
+import { type MaybeObservableOrValue } from '../rxjs/getter';
 import { type Destroyable, type Maybe } from '@dereekb/util';
+export interface FilterSourceInstanceConfig<F> {
+    readonly initWithFilter?: Maybe<Observable<F>>;
+    readonly defaultFilter?: MaybeObservableOrValue<F>;
+    readonly filter?: Maybe<F>;
+}
 /**
  * A basic FilterSource implementation.
  */
@@ -9,6 +14,9 @@ export declare class FilterSourceInstance<F> implements FilterSource<F>, Destroy
     private readonly _initialFilterSub;
     private readonly _initialFilterTakesPriority;
     private readonly _filter;
+    /**
+     * The initial filter can only pass through observables that always emit a value.
+     */
     private readonly _initialFilter;
     private readonly _defaultFilter;
     readonly defaultFilter$: Observable<Maybe<F>>;
@@ -17,15 +25,19 @@ export declare class FilterSourceInstance<F> implements FilterSource<F>, Destroy
      * filter$ uses the latest value from any filter.
      */
     readonly filter$: Observable<F>;
+    constructor(config?: FilterSourceInstanceConfig<F>);
     initWithFilter(filterObs: Observable<F>): void;
-    setDefaultFilter(filter: Maybe<ObservableOrValue<Maybe<F>>>): void;
+    setDefaultFilter(filter: MaybeObservableOrValue<F>): void;
     setFilter(filter: F): void;
     /**
      * Resets the current filter to be the default filter.
      */
     resetFilter(): void;
-    get initialFilterTakesPriority(): boolean;
-    set initialFilterTakesPriority(initialFilterTakesPriority: boolean);
+    setInitialFilterTakesPriority(initialFilterTakesPriority: boolean): void;
     protected initFilterTakesPriority(): void;
     destroy(): void;
+    /**
+     * @deprecated use setInitialFilterTakesPriority instead.
+     */
+    set initialFilterTakesPriority(initialFilterTakesPriority: boolean);
 }

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

@@ -1,6 +1,6 @@
+export * from './loading.context.rxjs';
 export * from './loading.context.state';
 export * from './loading.context.state.list';
-export * from './loading.context.state.value';
 export * from './loading.context.simple';
 export * from './loading.context';
 export * from './loading.context.value';

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

@@ -1,8 +1,22 @@
 import { type Observable } from 'rxjs';
-import { type LoadingErrorPair } from './loading.state';
+import { type LoadingState, type LoadingErrorPair } from './loading.state';
+/**
+ * A LoadingErrorPair that always defines a loading value.
+ */
 export interface LoadingContextEvent extends LoadingErrorPair {
-    loading: boolean;
+    readonly loading: boolean;
 }
-export interface LoadingContext {
-    readonly stream$: Observable<LoadingContextEvent>;
+/**
+ * An observable LoadingContext that provides a stream of LoadingContextEvents.
+ */
+export interface LoadingContext<E extends LoadingContextEvent = LoadingContextEvent> {
+    /**
+     * Stream of events that provide the current LoadingContextEvent for the LoadingContext.
+     */
+    readonly stream$: Observable<E>;
+}
+/**
+ * A LoadingContextEvent that has a value.
+ */
+export interface LoadingStateContextEvent<T = unknown> extends LoadingContextEvent, Omit<LoadingState<T>, 'loading'> {
 }

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

@@ -0,0 +1,7 @@
+import { type OperatorFunction } from 'rxjs';
+import { type LoadingContext, type LoadingContextEvent } from './loading.context';
+import { type Maybe } from '@dereekb/util';
+/**
+ * Creates a switchMap operator that will emit the stream of events from the input LoadingContext as soon as a non-null LoadingContext is emitted.
+ */
+export declare function switchMapMaybeLoadingContextStream(): OperatorFunction<Maybe<LoadingContext>, Maybe<LoadingContextEvent>>;

package/src/lib/loading/loading.context.simple.d.ts

@@ -5,13 +5,12 @@ import { type LoadingContext, type LoadingContextEvent } from './loading.context
  * Simple LoadingContext implementation
  */
 export declare class SimpleLoadingContext implements LoadingContext, Destroyable {
-    private _subject;
-    private _error;
+    private readonly _subject;
+    readonly stream$: Observable<LoadingContextEvent>;
     constructor(loading?: boolean);
     destroy(): void;
     hasError(): boolean;
     clearError(): void;
-    get stream$(): Observable<LoadingContextEvent>;
     setSuccess(): void;
     setLoading(loading?: boolean): void;
     setError(error: ReadableError, loading?: boolean): void;

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

@@ -1,46 +1,94 @@
 import { type Maybe, type Destroyable } from '@dereekb/util';
 import { type Observable } from 'rxjs';
-import { type LoadingContext, type LoadingContextEvent } from './loading.context';
+import { type LoadingStateContextEvent, type LoadingContext, type LoadingContextEvent } from './loading.context';
 import { type LoadingState } from './loading.state';
-export interface AbstractLoadingStateEvent<T = unknown> extends LoadingContextEvent {
-    value?: Maybe<T>;
-}
-export interface AbstractLoadingEventForLoadingPairConfig<S extends LoadingState = LoadingState> {
+/**
+ * A LoadingContext that provides several accessors to a LoadingState<T> and corresponding LoadingContextEvent
+ */
+export interface LoadingStateContext<T = unknown, S extends LoadingState<T> = LoadingState<T>, E extends LoadingContextEvent = LoadingContextEvent & S> extends LoadingContext<E> {
     /**
-     * The initial observable.
+     * The current observable stream of the state observable.
      */
-    obs?: Observable<S>;
+    readonly currentStateStream$: Observable<Maybe<Observable<Maybe<S>>>>;
     /**
-     * Whether or not to show loading if a value is defined.
+     * The latest non-null observable stream of the state observable.
+     */
+    readonly stateStream$: Observable<Observable<Maybe<S>>>;
+    /**
+     * Current state.
+     */
+    readonly currentState$: Observable<Maybe<S>>;
+    /**
+     * Latest non-null state.
      */
-    showLoadingOnNoValue?: boolean;
-}
-export interface AbstractLoadingStateContext<T = unknown, S extends LoadingState<T> = LoadingState<T>, E extends LoadingContextEvent = LoadingContextEvent> {
-    readonly stateObs$: Observable<Maybe<Observable<S>>>;
-    readonly stateSubject$: Observable<Observable<S>>;
     readonly state$: Observable<S>;
-    readonly stream$: Observable<E>;
+    /**
+     * Observable for the current loading state from the event stream.
+     */
     readonly loading$: Observable<boolean>;
+    /**
+     * The current value. Always provided, even while loading.
+     */
+    readonly currentValue$: Observable<Maybe<T>>;
+    /**
+     * The latest value from the most recent loaded state.
+     */
+    readonly valueAfterLoaded$: Observable<Maybe<T>>;
+    /**
+     * The latest non-null value from valueAfterLoaded$.
+     */
+    readonly value$: Observable<T>;
 }
-export type LoadingStateContextInstanceInputConfig<S, C> = Observable<S> | C;
 /**
- * Abstract LoadingContext implementation using LoadingState.
+ * A LoadingStateContext that can be updated and destroyed.
  */
-export declare abstract class AbstractLoadingStateContextInstance<T = unknown, S extends LoadingState<T> = LoadingState<T>, E extends AbstractLoadingStateEvent<T> = AbstractLoadingStateEvent<T>, C extends AbstractLoadingEventForLoadingPairConfig<S> = AbstractLoadingEventForLoadingPairConfig<S>> implements AbstractLoadingStateContext<T, S, E>, LoadingContext, Destroyable {
-    private _stateSubject;
-    private _config;
-    readonly config$: Observable<C>;
-    readonly stateSubject$: Observable<Observable<S>>;
-    readonly state$: Observable<S>;
-    readonly stateObs$: Observable<Maybe<Observable<S>>>;
-    readonly stream$: Observable<E>;
+export interface MutableLoadingStateContext<T = unknown, S extends LoadingState<T> = LoadingState<T>, E extends LoadingStateContextEvent = LoadingContextEvent & S> extends LoadingStateContext<T, S, E>, Destroyable {
     /**
-     * Emits when the input state has changed.
+     * Sets a new state observable.
+     *
+     * @param obs Observable
      */
-    readonly stateChange$: Observable<void>;
-    readonly loading$: Observable<boolean>;
-    constructor(config?: LoadingStateContextInstanceInputConfig<S, C>);
-    protected abstract loadingEventForLoadingPair(state: S, config: C): E;
-    setStateObs(state: Maybe<Observable<S>>): void;
-    destroy(): void;
+    setStateObs(obs: Maybe<Observable<Maybe<S>>>): void;
 }
+/**
+ * Configuration for loadingStateContext().
+ */
+export interface LoadingStateContextConfig<T = unknown, S extends LoadingState<T> = LoadingState<T>, E extends LoadingStateContextEvent = LoadingContextEvent & S> {
+    /**
+     * The initial observable.
+     */
+    readonly obs?: Maybe<Observable<Maybe<S>>>;
+    /**
+     * Whether or not to show loading if finished loading and the value is undefined.
+     *
+     * Defaults to false.
+     */
+    readonly showLoadingOnUndefinedValue?: Maybe<boolean>;
+    /**
+     * Optional function to generate a LoadingContextEvent from a LoadingState and this config.
+     *
+     * @param state the current state
+     * @param config this config
+     * @returns the event to emit
+     */
+    readonly loadingEventForLoadingPair?: Maybe<(state: S, config: LoadingEventForLoadingPairConfigInput) => E>;
+    /**
+     * Alias for showLoadingOnUndefinedValue.
+     *
+     * @deprecated Use showLoadingOnUndefinedValue instead.
+     */
+    readonly showLoadingOnNoValue?: Maybe<boolean>;
+}
+export type LoadingEventForLoadingPairConfigInput = Pick<LoadingStateContextConfig, 'showLoadingOnUndefinedValue'>;
+export declare const DEFAULT_LOADING_EVENT_FOR_LOADING_PAIR_FUNCTION: <T = unknown, S extends LoadingState<T> = LoadingState<T>, E extends LoadingStateContextEvent = LoadingContextEvent & S>(state: S, input: LoadingEventForLoadingPairConfigInput) => LoadingStateContextEvent<T>;
+/**
+ * Input for loadingStateContext()
+ */
+export type LoadingStateContextInput<T = unknown, S extends LoadingState<T> = LoadingState<T>, E extends LoadingStateContextEvent = LoadingContextEvent & S> = LoadingStateContextConfig<T, S, E> | LoadingStateContextConfig<T, S, E>['obs'];
+/**
+ * Creates a new LoadingStateContext from the input.
+ 
+ * @param input LoadingStateContextInput
+ * @returns LoadingStateContext
+ */
+export declare function loadingStateContext<T = unknown, S extends LoadingState<T> = LoadingState<T>, E extends LoadingStateContextEvent = LoadingContextEvent & S>(input?: LoadingStateContextInput<T, S, E>): MutableLoadingStateContext<T, S, E>;

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

@@ -1,36 +1,32 @@
 import { type LimitArrayConfig, type Maybe } from '@dereekb/util';
 import { type Observable } from 'rxjs';
 import { type ListLoadingState } from './loading.state';
-import { type AbstractLoadingEventForLoadingPairConfig, type AbstractLoadingStateContext, AbstractLoadingStateContextInstance, type AbstractLoadingStateEvent, type LoadingStateContextInstanceInputConfig } from './loading.context.state';
-export interface ListLoadingStateContextEvent<T> extends AbstractLoadingStateEvent<T[]> {
-    value?: Maybe<T[]>;
-}
-export interface LoadingEventForListLoadingStateConfig<S extends ListLoadingState<unknown> = ListLoadingState<unknown>> extends AbstractLoadingEventForLoadingPairConfig<S>, Partial<LimitArrayConfig> {
-}
-export interface ListLoadingStateContext<L = unknown, S extends ListLoadingState<L> = ListLoadingState<L>> extends AbstractLoadingStateContext<L[], S, ListLoadingStateContextEvent<L>> {
-    readonly list$: Observable<L[]>;
-    readonly isEmpty$: Observable<boolean>;
-}
-/**
- * LoadingContext implementation that uses a ListLoadingState observable.
- */
-export declare class ListLoadingStateContextInstance<L = unknown, S extends ListLoadingState<L> = ListLoadingState<L>> extends AbstractLoadingStateContextInstance<L[], S, ListLoadingStateContextEvent<L>, LoadingEventForListLoadingStateConfig<S>> {
+import { type LoadingStateContext, type LoadingStateContextConfig, type LoadingStateContextInput, type MutableLoadingStateContext } from './loading.context.state';
+export interface ListLoadingStateContext<L = unknown, S extends ListLoadingState<L> = ListLoadingState<L>> extends Omit<LoadingStateContext<L[], S>, 'value$' | 'currentValue$' | 'valueAfterLoaded$'> {
     /**
-     * Returns the current values or an empty list.
+     * The current list. Always provided, even while loading.
      */
-    readonly list$: Observable<L[]>;
+    readonly currentList$: Observable<Maybe<L[]>>;
     /**
-     * Returns true while loading and the current value is considered empty.
+     * The latest list from the most recent loaded state.
      */
-    readonly isEmptyLoading$: Observable<boolean>;
+    readonly listAfterLoaded$: Observable<Maybe<L[]>>;
+    /**
+     * The latest list from listAfterLoaded$, or a default value if the list was empty.
+     */
+    readonly list$: Observable<L[]>;
     /**
-     * Whether or not the current value is empty.
+     * Whether or not the currentList$ value is empty.
      *
-     * Only resolves when the first non-loading event has occured.
+     * Only resolves after the first non-loading event has occured.
      *
      * After that, will return true if the value is empty even if loading a new value.
      */
     readonly isEmpty$: Observable<boolean>;
+    /**
+     * Returns true while loading and the current value is considered empty.
+     */
+    readonly isEmptyLoading$: Observable<boolean>;
     /**
      * Whether or not the current value is empty and not loading.
      *
@@ -39,6 +35,23 @@ export declare class ListLoadingStateContextInstance<L = unknown, S extends List
      * After that, will return true if the value is empty even if loading a new value.
      */
     readonly isEmptyAndNotLoading$: Observable<boolean>;
-    protected loadingEventForLoadingPair(state: S, config?: LoadingEventForListLoadingStateConfig): ListLoadingStateContextEvent<L>;
 }
-export declare function listLoadingStateContext<T = unknown, S extends ListLoadingState<T> = ListLoadingState<T>>(config: LoadingStateContextInstanceInputConfig<S, LoadingEventForListLoadingStateConfig<S>>): ListLoadingStateContextInstance<T, S>;
+/**
+ * A ListLoadingStateContext that can be updated and destroyed.
+ */
+export type MutableListLoadingStateContext<L = unknown, S extends ListLoadingState<L> = ListLoadingState<L>> = ListLoadingStateContext<L, S> & Pick<MutableLoadingStateContext<L[], S>, 'setStateObs' | 'destroy'>;
+/**
+ * Configuration for listLoadingStateContext().
+ */
+export type ListLoadingStateContextConfig<L, S extends ListLoadingState<L> = ListLoadingState<L>> = Omit<LoadingStateContextConfig<L[], S>, 'loadingEventForLoadingPair'> & Partial<LimitArrayConfig>;
+/**
+ * Input for listLoadingStateContext().
+ */
+export type ListLoadingStateContextInput<L, S extends ListLoadingState<L> = ListLoadingState<L>> = Omit<LoadingStateContextInput<L[], S>, 'loadingEventForLoadingPair'> | ListLoadingStateContextConfig<L, S>;
+/**
+ * Creates a ListLoadingStateContext.
+ *
+ * @param input Optional configuration for the ListLoadingStateContext.
+ * @returns A ListLoadingStateContext.
+ */
+export declare function listLoadingStateContext<L, S extends ListLoadingState<L> = ListLoadingState<L>>(input?: ListLoadingStateContextInput<L, S>): MutableListLoadingStateContext<L, S>;

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

@@ -8,17 +8,25 @@ export interface LoadingErrorPair {
      *
      * Not being specified is considered not being loaded.
      */
-    loading?: Maybe<boolean>;
+    readonly loading?: Maybe<boolean>;
     /**
      * A Readable server error.
      */
-    error?: Maybe<ReadableError>;
+    readonly error?: Maybe<ReadableError>;
 }
+/**
+ * Returns true if the input LoadingErrorPair has the same loading (truthy vs falsy) and error values as the other LoadingErrorPair.
+ *
+ * @param a LoadingErrorPair a
+ * @param b LoadingErrorPair b
+ * @returns Returns true if the input's metadata is considered equivalent.
+ */
+export declare function isLoadingStateMetadataEqual(a: Partial<LoadingErrorPair>, b: Partial<LoadingErrorPair>): boolean;
 /**
  * A value/error pair used in loading situations.
  */
 export interface LoadingState<T = unknown> extends LoadingErrorPair {
-    value?: Maybe<T>;
+    readonly value?: Maybe<T>;
 }
 /**
  * Returns the value type inferred from the LoadingState type.
@@ -32,19 +40,19 @@ export type LoadingStateWithValueType<L extends LoadingState, T> = L extends Loa
  * Loading state with a value key.
  */
 export type LoadingStateWithValue<T = unknown> = LoadingState<T> & {
-    value: Maybe<T>;
+    readonly value: Maybe<T>;
 };
 /**
  * Loading state with a value key and a non-maybe value.
  */
 export type LoadingStateWithDefinedValue<T = unknown> = LoadingState<T> & {
-    value: T;
+    readonly value: T;
 };
 /**
  * Loading state with an error
  */
 export type LoadingStateWithError<T = unknown> = LoadingState<T> & {
-    error: ReadableError;
+    readonly error: ReadableError;
 };
 /**
  * Convenience identifier for a LoadingState that returns a list.
@@ -123,39 +131,39 @@ export declare function isAnyLoadingStateInLoadingState(states: LoadingState[]):
  * @returns
  */
 export declare function areAllLoadingStatesFinishedLoading(states: LoadingState[]): boolean;
-export declare function isLoadingStateWithStateType(type: LoadingStateType): <L extends LoadingState<unknown>>(state: Maybe<L>) => boolean;
+export declare function isLoadingStateWithStateType(type: LoadingStateType): <L extends LoadingState>(state: Maybe<L>) => boolean;
 /**
  * Returns true if the input LoadingState passed to loadingStateType() returns IDLE.
  *
  * @param state
  * @returns
  */
-export declare const isLoadingStateInIdleState: <L extends LoadingState<unknown>>(state: Maybe<L>) => boolean;
+export declare const isLoadingStateInIdleState: <L extends LoadingState>(state: Maybe<L>) => boolean;
 /**
  * Returns true if the input LoadingState passed to loadingStateType() returns LOADING.
  *
  * @param state
  * @returns
  */
-export declare const isLoadingStateLoading: <L extends LoadingState<unknown>>(state: Maybe<L>) => boolean;
+export declare const isLoadingStateLoading: <L extends LoadingState>(state: Maybe<L>) => boolean;
 /**
  * Alias of isLoadingStateLoading.
  */
-export declare const isLoadingStateInLoadingState: <L extends LoadingState<unknown>>(state: Maybe<L>) => boolean;
+export declare const isLoadingStateInLoadingState: <L extends LoadingState>(state: Maybe<L>) => boolean;
 /**
  * Returns true if the input LoadingState passed to loadingStateType() returns SUCCESS.
  *
  * @param state
  * @returns
  */
-export declare const isLoadingStateInSuccessState: <L extends LoadingState<unknown>>(state: Maybe<L>) => boolean;
+export declare const isLoadingStateInSuccessState: <L extends LoadingState>(state: Maybe<L>) => boolean;
 /**
  * Returns true if the input LoadingState passed to loadingStateType() returns ERROR.
  *
  * @param state
  * @returns
  */
-export declare const isLoadingStateInErrorState: <L extends LoadingState<unknown>>(state: Maybe<L>) => boolean;
+export declare const isLoadingStateInErrorState: <L extends LoadingState>(state: Maybe<L>) => boolean;
 /**
  * Whether or not the input LoadingState has a non-undefined value.
  *
@@ -251,19 +259,19 @@ export declare const allLoadingStatesHaveFinishedLoading: typeof areAllLoadingSt
 /**
  * @deprecated use isLoadingStateInIdleState instead.
  */
-export declare const loadingStateIsIdle: <L extends LoadingState<unknown>>(state: Maybe<L>) => boolean;
+export declare const loadingStateIsIdle: <L extends LoadingState>(state: Maybe<L>) => boolean;
 /**
  * @deprecated use isLoadingStateInSuccessState instead.
  */
-export declare const isSuccessLoadingState: <L extends LoadingState<unknown>>(state: Maybe<L>) => boolean;
+export declare const isSuccessLoadingState: <L extends LoadingState>(state: Maybe<L>) => boolean;
 /**
  * @deprecated use isLoadingStateInErrorState instead.
  */
-export declare const isErrorLoadingState: <L extends LoadingState<unknown>>(state: Maybe<L>) => boolean;
+export declare const isErrorLoadingState: <L extends LoadingState>(state: Maybe<L>) => boolean;
 /**
  * @deprecated Use isLoadingStateLoading instead.
  */
-export declare const loadingStateIsLoading: <L extends LoadingState<unknown>>(state: Maybe<L>) => boolean;
+export declare const loadingStateIsLoading: <L extends LoadingState>(state: Maybe<L>) => boolean;
 /**
  * @deprecated use isLoadingStateFinishedLoading instead.
  */

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

@@ -4,6 +4,7 @@ import { type Observable, type OperatorFunction, type Subscription, type Observe
  * A value that is either the value or an observable that returns the value.
  */
 export type ObservableOrValue<T> = T | Observable<T>;
+export type MaybeObservableOrValue<T> = Maybe<ObservableOrValue<Maybe<T>>>;
 /**
  * Wraps the input value as an observable, if it is not an observable.
  */
@@ -12,9 +13,15 @@ export declare function asObservable<T>(valueOrObs: Maybe<ObservableOrValue<T>>)
 /**
  * Switch map for an ObservableGetter that pipes through the value.
  *
- * @returns
+ * @returns OperatorFunction<ObservableOrValue<T>, T>
  */
 export declare function valueFromObservableOrValue<T>(): OperatorFunction<ObservableOrValue<T>, T>;
+/**
+ * Switch map for an ObservableGetter that pipes through the Maybe value.
+ *
+ * @returns OperatorFunction<Maybe<ObservableOrValue<T>>, Maybe<T>>
+ */
+export declare function maybeValueFromObservableOrValue<T>(): OperatorFunction<MaybeObservableOrValue<T>, Maybe<T>>;
 /**
  * A GetterOrValue of a ObservableOrValue.
  */

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

@@ -1,16 +1,55 @@
 import { type MonoTypeOperatorFunction, type Observable, type OperatorFunction } from 'rxjs';
 import { type DecisionFunction, type GetterOrValue, type MapFunction, type Maybe } from '@dereekb/util';
-import { type MaybeObservableOrValueGetter, type ObservableOrValueGetter } from './getter';
+import { type MaybeObservableOrValueGetter, type ObservableOrValueGetter, type MaybeObservableOrValue } from './getter';
 import { type ObservableDecisionFunction } from './decision';
+/**
+ * Function that checks the input value and returns an observable that emits a boolean.
+ */
 export type IsCheckFunction<T = unknown> = (value: T) => Observable<boolean>;
 /**
- * Function that validates the input value and returns an observable.
+ * Function that validates the input value and returns an observable that emits true if the value is valid.
  */
 export type IsValidFunction<T = unknown> = IsCheckFunction<T>;
 /**
- * Function that checks modification status of the input value and returns a value.
+ * Function that checks equality of the input value and returns an observable that emits true if the value is equal.
+ */
+export type IsEqualFunction<T = unknown> = IsCheckFunction<T>;
+/**
+ * Function that checks modification status of the input value and returns an observable that emits true if the value is modified.
  */
 export type IsModifiedFunction<T = unknown> = IsCheckFunction<T>;
+/**
+ * Creates an IsModifiedFunction from an IsEqualFunction, or from IsModifiedFunctionInput.
+ *
+ * @param isEqualFunction
+ */
+export declare function makeIsModifiedFunction<T>(isEqualFunction: IsEqualFunction<T>): IsModifiedFunction<T>;
+/**
+ * Configuration for creating an Observable<IsModifiedFunction>.
+ */
+export interface MakeIsModifiedFunctionObservableConfig<T = unknown> {
+    /**
+     * Observable or value of the IsModifiedFunction to use, if applicable.
+     */
+    readonly isModified?: MaybeObservableOrValue<IsModifiedFunction<T>>;
+    /**
+     * Observable or value of the IsEqualFunction to use, if applicable.
+     */
+    readonly isEqual?: MaybeObservableOrValue<IsEqualFunction<T>>;
+    /**
+     * The default function to use if no other function is provided.
+     *
+     * Defaults to a function that returns true.
+     */
+    readonly defaultFunction?: Maybe<IsModifiedFunction<T>>;
+}
+/**
+ * Creates an Observable<IsModifiedFunction> from the input config.
+ *
+ * @param config MakeIsModifiedFunctionObservableConfig.
+ * @returns Observable<IsModifiedFunction<T>>
+ */
+export declare function makeIsModifiedFunctionObservable<T>(config: MakeIsModifiedFunctionObservableConfig<T>): Observable<IsModifiedFunction<T>>;
 export declare function makeReturnIfIsFunction<T>(isCheckFunction: Maybe<IsModifiedFunction<T>>, defaultValueOnMaybe?: boolean): (value: Maybe<T>) => Observable<Maybe<T>>;
 export declare function returnIfIs<T>(isCheckFunction: Maybe<IsModifiedFunction<T>>, value: Maybe<T>, defaultValueOnMaybe?: boolean): Observable<Maybe<T>>;
 export declare function makeCheckIsFunction<T>(isCheckFunction: Maybe<IsModifiedFunction<T>>, defaultValueOnMaybe?: boolean): (value: Maybe<T>) => Observable<boolean>;
@@ -60,7 +99,9 @@ export declare function switchMapObject<T extends object>(config: SwitchMapObjec
  * @param defaultValue
  * @returns
  */
+export declare function switchMapWhileTrue<T = unknown>(obs: ObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
 export declare function switchMapWhileTrue<T = unknown>(obs: MaybeObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
+export declare function switchMapWhileTrue<T = unknown>(obs: ObservableOrValueGetter<T>, otherwise: ObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
 export declare function switchMapWhileTrue<T = unknown>(obs: MaybeObservableOrValueGetter<T>, otherwise?: MaybeObservableOrValueGetter<T>): OperatorFunction<boolean, Maybe<T>>;
 /**
  * Provides a switchMap that will emit from the input observable if the value is false, otherwise emits the otherwise value or empty.
@@ -68,7 +109,9 @@ export declare function switchMapWhileTrue<T = unknown>(obs: MaybeObservableOrVa
  * @param defaultValue
  * @returns
  */
+export declare function switchMapWhileFalse<T = unknown>(obs: ObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
 export declare function switchMapWhileFalse<T = unknown>(obs: MaybeObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
+export declare function switchMapWhileFalse<T = unknown>(obs: ObservableOrValueGetter<T>, otherwise: ObservableOrValueGetter<T>): OperatorFunction<boolean, T>;
 export declare function switchMapWhileFalse<T = unknown>(obs: MaybeObservableOrValueGetter<T>, otherwise?: MaybeObservableOrValueGetter<T>): OperatorFunction<boolean, Maybe<T>>;
 /**
  * Provides a switchMap that will emit from the input observable if the value matches the switchOnValue, otherwise emits the otherwise value or empty.
@@ -79,11 +122,17 @@ export declare function switchMapWhileFalse<T = unknown>(obs: MaybeObservableOrV
 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>>;
 /**
- * Combines both filterMaybe and switchMap to build a subscriber that emits only concrete values.
+ * Combines both filterMaybe and switchMap to build a subscriber that emits values only from a concrete Observable, filtering out null/undefined Observables.
+ *
+ * @returns
+ */
+export declare function switchMapFilterMaybe<T = unknown>(): OperatorFunction<Maybe<Observable<Maybe<T>>>, T>;
+/**
+ * Converts a Maybe<Observable<Maybe<T>>> to an Observable<Maybe<T>> that emits null/undefined if the input observable is also null/undefined.
  *
  * @returns
  */
-export declare function switchMapMaybeObs<T = unknown>(): OperatorFunction<Maybe<Observable<Maybe<T>>>, T>;
+export declare function switchMapMaybe<T = unknown>(): OperatorFunction<Maybe<Observable<Maybe<T>>>, Maybe<T>>;
 /**
  * Performs the input map function on the input if it is not null/undefined.
  *

package/src/lib/subscription.d.ts

@@ -1,14 +1,14 @@
-import { type Subscription } from 'rxjs';
+import { type Unsubscribable } from 'rxjs';
 import { type ArrayOrValue, type Destroyable, type Maybe } from '@dereekb/util';
 /**
- * Destroyable object that wraps a subscription.
+ * Destroyable object that wraps an Unsubscribable.
  */
-export declare class SubscriptionObject implements Destroyable {
+export declare class SubscriptionObject<T extends Unsubscribable = Unsubscribable> implements Destroyable {
     private _subscription?;
-    constructor(sub?: Maybe<Subscription>);
+    constructor(sub?: Maybe<T>);
     get hasSubscription(): boolean;
-    set subscription(sub: Maybe<Subscription>);
-    setSub(sub: Maybe<Subscription>): void;
+    set subscription(sub: Maybe<T | void>);
+    setSub(sub: Maybe<T | void>): void;
     unsub(): void;
     destroy(): void;
 }
@@ -17,12 +17,12 @@ export declare class SubscriptionObject implements Destroyable {
  *
  * NOTE: In some cases it might be better to use RXJS's merge(...[]) and subscribe to a single item.
  */
-export declare class MultiSubscriptionObject implements Destroyable {
+export declare class MultiSubscriptionObject<T extends Unsubscribable = Unsubscribable> implements Destroyable {
     private _subscriptions?;
-    constructor(subs?: ArrayOrValue<Subscription>);
+    constructor(subs?: ArrayOrValue<T>);
     get hasSubscription(): boolean;
-    set subscriptions(subs: ArrayOrValue<Subscription>);
-    setSubs(subs: ArrayOrValue<Subscription>): void;
+    set subscriptions(subs: ArrayOrValue<T>);
+    setSubs(subs: ArrayOrValue<T>): void;
     unsub(): void;
     destroy(): void;
 }

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

@@ -1,23 +0,0 @@
-import { type Maybe } from '@dereekb/util';
-import { type Observable } from 'rxjs';
-import { type LoadingContextEvent } from './loading.context';
-import { type AbstractLoadingEventForLoadingPairConfig, type AbstractLoadingStateContext, AbstractLoadingStateContextInstance, type LoadingStateContextInstanceInputConfig } from './loading.context.state';
-import { type LoadingState } from './loading.state';
-export interface LoadingStateContextEvent<T = unknown> extends LoadingContextEvent {
-    value?: Maybe<T>;
-}
-export type LoadingEventForLoadingPairConfig<S extends LoadingState = LoadingState> = AbstractLoadingEventForLoadingPairConfig<S>;
-export interface LoadingStateContext<T = unknown, S extends LoadingState<T> = LoadingState<T>> extends AbstractLoadingStateContext<T, S, LoadingStateContextEvent<T>> {
-    readonly list$: Observable<T[]>;
-    readonly values$: Observable<T[]>;
-    readonly isEmpty$: Observable<boolean>;
-}
-/**
- * LoadingContext implementation for a LoadingState.
- */
-export declare class LoadingStateContextInstance<T = unknown, S extends LoadingState<T> = LoadingState<T>> extends AbstractLoadingStateContextInstance<T, S, LoadingStateContextEvent<T>, LoadingEventForLoadingPairConfig<S>> {
-    readonly value$: Observable<Maybe<T>>;
-    readonly valueAfterLoaded$: Observable<Maybe<T>>;
-    protected loadingEventForLoadingPair(pair: S, { showLoadingOnNoValue }?: LoadingEventForLoadingPairConfig): LoadingStateContextEvent<T>;
-}
-export declare function loadingStateContext<T = unknown, S extends LoadingState<T> = LoadingState<T>>(config: LoadingStateContextInstanceInputConfig<S, LoadingEventForLoadingPairConfig<S>>): LoadingStateContextInstance<T, S>;