@dereekb/dbx-core 11.1.8 → 12.0.0

package/lib/action/action.module.d.ts

@@ -17,10 +17,12 @@ import * as i15 from "./directive/debug/action.logger.directive";
 import * as i16 from "./directive/state/action.presuccess.directive";
 import * as i17 from "./directive/state/action.success.directive";
 import * as i18 from "./directive/state/action.success.handler.directive";
-import * as i19 from "./directive/state/action.working.component";
-import * as i20 from "@angular/common";
+import * as i19 from "./directive/state/action.working.directive";
+/**
+ * Contains all base DbxAction components.
+ */
 export declare class DbxCoreActionModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxCoreActionModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreActionModule, [typeof i1.DbxActionDirective, typeof i2.DbxActionContextMapDirective, typeof i3.DbxActionFromMapDirective, typeof i4.DbxActionMapSourceDirective, typeof i5.DbxActionMapWorkingDisableDirective, typeof i6.DbxActionSourceDirective, typeof i7.DbxActionHandlerDirective, typeof i7.DbxActionHandlerValueDirective, typeof i8.DbxActionDisabledDirective, typeof i9.DbxActionDisabledOnSuccessDirective, typeof i10.DbxActionEnforceModifiedDirective, typeof i11.DbxActionAutoTriggerDirective, typeof i12.dbxActionValueStreamDirective, typeof i13.DbxActionAutoModifyDirective, typeof i14.DbxActionValueDirective, typeof i15.DbxActionContextLoggerDirective, typeof i16.DbxActionPreSuccessDirective, typeof i17.DbxActionHasSuccessDirective, typeof i18.DbxActionSuccessHandlerDirective, typeof i19.DbxActionIsWorkingDirective], [typeof i20.CommonModule], [typeof i1.DbxActionDirective, typeof i2.DbxActionContextMapDirective, typeof i3.DbxActionFromMapDirective, typeof i4.DbxActionMapSourceDirective, typeof i5.DbxActionMapWorkingDisableDirective, typeof i6.DbxActionSourceDirective, typeof i7.DbxActionHandlerDirective, typeof i7.DbxActionHandlerValueDirective, typeof i8.DbxActionDisabledDirective, typeof i9.DbxActionDisabledOnSuccessDirective, typeof i10.DbxActionEnforceModifiedDirective, typeof i11.DbxActionAutoTriggerDirective, typeof i12.dbxActionValueStreamDirective, typeof i13.DbxActionAutoModifyDirective, typeof i14.DbxActionValueDirective, typeof i15.DbxActionContextLoggerDirective, typeof i16.DbxActionPreSuccessDirective, typeof i17.DbxActionHasSuccessDirective, typeof i18.DbxActionSuccessHandlerDirective, typeof i19.DbxActionIsWorkingDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxCoreActionModule, never, [typeof i1.DbxActionDirective, typeof i2.DbxActionContextMapDirective, typeof i3.DbxActionFromMapDirective, typeof i4.DbxActionMapSourceDirective, typeof i5.DbxActionMapWorkingDisableDirective, typeof i6.DbxActionSourceDirective, typeof i7.DbxActionHandlerDirective, typeof i7.DbxActionHandlerValueDirective, typeof i8.DbxActionDisabledDirective, typeof i9.DbxActionDisabledOnSuccessDirective, typeof i10.DbxActionEnforceModifiedDirective, typeof i11.DbxActionAutoTriggerDirective, typeof i12.DbxActionValueStreamDirective, typeof i13.DbxActionAutoModifyDirective, typeof i14.DbxActionValueDirective, typeof i15.DbxActionContextLoggerDirective, typeof i16.DbxActionPreSuccessDirective, typeof i17.DbxActionHasSuccessDirective, typeof i18.DbxActionSuccessHandlerDirective, typeof i19.DbxActionIsWorkingDirective], [typeof i1.DbxActionDirective, typeof i2.DbxActionContextMapDirective, typeof i3.DbxActionFromMapDirective, typeof i4.DbxActionMapSourceDirective, typeof i5.DbxActionMapWorkingDisableDirective, typeof i6.DbxActionSourceDirective, typeof i7.DbxActionHandlerDirective, typeof i7.DbxActionHandlerValueDirective, typeof i8.DbxActionDisabledDirective, typeof i9.DbxActionDisabledOnSuccessDirective, typeof i10.DbxActionEnforceModifiedDirective, typeof i11.DbxActionAutoTriggerDirective, typeof i12.DbxActionValueStreamDirective, typeof i13.DbxActionAutoModifyDirective, typeof i14.DbxActionValueDirective, typeof i15.DbxActionContextLoggerDirective, typeof i16.DbxActionPreSuccessDirective, typeof i17.DbxActionHasSuccessDirective, typeof i18.DbxActionSuccessHandlerDirective, typeof i19.DbxActionIsWorkingDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DbxCoreActionModule>;
 }

package/lib/action/action.store.d.ts

@@ -17,28 +17,31 @@ export declare function actionContextHasNoErrorAndIsModifiedAndCanTrigger(state:
 export declare function loadingStateForActionContextState<O = unknown>(state: ActionContextState<unknown, O>): LoadingState<O>;
 export declare function loadingStateTypeForActionContextState(state: ActionContextState): LoadingStateType;
 export interface ActionContextState<T = unknown, O = unknown> {
-    actionState: DbxActionState;
-    isModified: boolean;
+    readonly actionState: DbxActionState;
+    /**
+     * Whether or not this action is flagged as having been modified.
+     */
+    readonly isModified: boolean;
     /**
      * Value that is set after a triggered action. Not to be confused with result.
      */
-    value?: Maybe<T>;
+    readonly value?: Maybe<T>;
     /**
      * Resolved result value.
      */
-    result?: Maybe<O>;
+    readonly result?: Maybe<O>;
     /**
      * Rejected error, if available.
      */
-    error?: Maybe<ReadableError>;
+    readonly error?: Maybe<ReadableError>;
     /**
      * Current disabled state.
      */
-    disabled?: BooleanStringKeyArray;
+    readonly disabled?: BooleanStringKeyArray;
     /**
      * Number of consecutive errors that have occured.
      */
-    errorCount?: number;
+    readonly errorCount?: number;
 }
 export declare class ActionContextStore<T = unknown, O = unknown> extends ComponentStore<ActionContextState<T, O>> implements OnDestroy {
     readonly lockSet: LockSet;
@@ -130,11 +133,17 @@ export declare class ActionContextStore<T = unknown, O = unknown> extends Compon
     /**
      * Adds a disabled reason.
      */
-    readonly disable: (() => void) | ((observableOrValue: string | void | Observable<string | void>) => import("rxjs").Subscription);
+    readonly disable: (() => void) | ((observableOrValue: string | void | Observable<string | void | undefined> | undefined) => import("rxjs").Subscription);
     /**
      * Removes a disabled reason.
      */
-    readonly enable: (() => void) | ((observableOrValue: string | void | Observable<string | void>) => import("rxjs").Subscription);
+    readonly enable: (() => void) | ((observableOrValue: string | void | Observable<string | void | undefined> | undefined) => import("rxjs").Subscription);
+    /**
+     * Triggers the modified state, if not disabled.
+     *
+     * Equivalent to calling setIsModified() with opposite input.
+     */
+    readonly setIsSame: (() => void) | ((observableOrValue: boolean | void | Observable<boolean | void>) => import("rxjs").Subscription);
     /**
      * Triggers the modified state, if not disabled.
      */

package/lib/action/action.store.source.d.ts

@@ -61,6 +61,7 @@ export declare class DbxActionContextStoreSourceInstance<T = unknown, O = unknow
     get errorCountSinceLastSuccess$(): Observable<number>;
     enable(key?: DbxActionDisabledKey, enable?: boolean): void;
     disable(key?: DbxActionDisabledKey, disable?: boolean): void;
+    setIsSame(isSame?: boolean | Observable<boolean> | Observable<void>): void;
     setIsModified(isModified?: boolean | Observable<boolean> | Observable<void>): void;
     trigger(): void;
     triggerWithValue(value: T | Observable<T>): void;

package/lib/action/directive/auto/action.automodify.directive.d.ts

@@ -1,15 +1,13 @@
 import { OnInit, OnDestroy } from '@angular/core';
 import { AbstractSubscriptionDirective } from '../../../subscription';
+import { Observable } from 'rxjs';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
-import { type Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
 export declare class DbxActionAutoModifyDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
-    private readonly _autoModifyEnabled;
-    get autoModifyEnabled(): boolean;
-    set autoModifyEnabled(autoModifyEnabled: Maybe<boolean | ''>);
+    readonly autoModifyEnabled: import("@angular/core").InputSignalWithTransform<boolean, string | boolean>;
+    readonly markAsModified$: Observable<void>;
     ngOnInit(): void;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionAutoModifyDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionAutoModifyDirective<any, any>, "[dbxActionAutoModify]", never, { "autoModifyEnabled": { "alias": "dbxActionAutoModify"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionAutoModifyDirective<any, any>, "dbxActionAutoModify, [dbxActionAutoModify]", never, { "autoModifyEnabled": { "alias": "dbxActionAutoModify"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/auto/action.autotrigger.directive.d.ts

@@ -1,4 +1,4 @@
-import { OnInit, OnDestroy } from '@angular/core';
+import { OnInit, OnDestroy, Signal } from '@angular/core';
 import { AbstractSubscriptionDirective } from '../../../subscription';
 import { Observable } from 'rxjs';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
@@ -11,33 +11,17 @@ import * as i0 from "@angular/core";
  */
 export declare class DbxActionAutoTriggerDirective<T = unknown, O = unknown> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
-    private readonly _triggerEnabled;
-    private readonly _triggerLimit;
-    private readonly _trigger;
-    /**
-     * How much to throttle the auto-triggering.
-     */
-    get triggerEnabled(): boolean;
-    set triggerEnabled(triggerEnabled: Maybe<boolean> | '');
-    triggerDebounce: number;
-    triggerThrottle: number;
-    triggerErrorThrottle: number;
-    maxErrorsForThrottle: number;
-    /**
-     * Optional input to override both triggerDebounce and triggerThrottle.
-     *
-     * Used in forms that are simple.
-     */
-    set fastTrigger(fastTrigger: Maybe<boolean> | '');
-    /**
-     * Optional input to override both triggerDebounce and triggerThrottle to be 0.
-     *
-     * Used in forms that generally return a single value.
-     */
-    set instantTrigger(instantTrigger: Maybe<boolean> | '');
-    get triggerLimit(): Maybe<number>;
-    set triggerLimit(triggerLimit: Maybe<number>);
-    private _triggerCount;
+    readonly triggerDebounce: import("@angular/core").InputSignal<Maybe<number>>;
+    readonly triggerThrottle: import("@angular/core").InputSignal<Maybe<number>>;
+    readonly triggerErrorThrottle: import("@angular/core").InputSignalWithTransform<number, Maybe<number>>;
+    readonly maxErrorsForThrottle: import("@angular/core").InputSignalWithTransform<number, Maybe<number>>;
+    readonly triggerLimit: import("@angular/core").InputSignal<Maybe<number>>;
+    readonly triggerEnabled: import("@angular/core").InputSignalWithTransform<boolean, Maybe<string | boolean>>;
+    readonly useFastTriggerPreset: import("@angular/core").InputSignalWithTransform<boolean, Maybe<string | boolean>>;
+    readonly useInstantTriggerPreset: import("@angular/core").InputSignalWithTransform<boolean, Maybe<string | boolean>>;
+    readonly triggerDebounceSignal: Signal<number>;
+    readonly triggerThrottleSignal: Signal<number>;
+    readonly triggerCountSignal: import("@angular/core").WritableSignal<number>;
     readonly _errorCount$: Observable<number>;
     readonly _triggerCount$: Observable<number>;
     /**
@@ -45,11 +29,10 @@ export declare class DbxActionAutoTriggerDirective<T = unknown, O = unknown> ext
      */
     readonly triggerCount$: Observable<number>;
     private readonly _isTriggerLimited$;
-    readonly isTriggerLimited$: Observable<boolean>;
-    readonly trigger$: Observable<void>;
-    get isEnabled(): boolean;
+    readonly isTriggerAllowedToRun$: Observable<boolean>;
+    readonly automaticTrigger$: Observable<void>;
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionAutoTriggerDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionAutoTriggerDirective<any, any>, "dbxActionAutoTrigger, [dbxActionAutoTrigger]", never, { "triggerEnabled": { "alias": "dbxActionAutoTrigger"; "required": false; }; "triggerDebounce": { "alias": "triggerDebounce"; "required": false; }; "triggerThrottle": { "alias": "triggerThrottle"; "required": false; }; "triggerErrorThrottle": { "alias": "triggerErrorThrottle"; "required": false; }; "fastTrigger": { "alias": "fastTrigger"; "required": false; }; "instantTrigger": { "alias": "instantTrigger"; "required": false; }; "triggerLimit": { "alias": "triggerLimit"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionAutoTriggerDirective<any, any>, "dbxActionAutoTrigger,[dbxActionAutoTrigger]", never, { "triggerDebounce": { "alias": "triggerDebounce"; "required": false; "isSignal": true; }; "triggerThrottle": { "alias": "triggerThrottle"; "required": false; "isSignal": true; }; "triggerErrorThrottle": { "alias": "triggerErrorThrottle"; "required": false; "isSignal": true; }; "maxErrorsForThrottle": { "alias": "maxErrorsForThrottle"; "required": false; "isSignal": true; }; "triggerLimit": { "alias": "triggerLimit"; "required": false; "isSignal": true; }; "triggerEnabled": { "alias": "dbxActionAutoTrigger"; "required": false; "isSignal": true; }; "useFastTriggerPreset": { "alias": "useFastTriggerPreset"; "required": false; "isSignal": true; }; "useInstantTriggerPreset": { "alias": "useInstantTriggerPreset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/auto/index.d.ts

@@ -1,3 +1,2 @@
 export * from './action.automodify.directive';
 export * from './action.autotrigger.directive';
-export * from '../state/action.value.stream.directive';

package/lib/action/directive/context/action.directive.d.ts

@@ -8,5 +8,5 @@ export declare class DbxActionDirective<T = unknown, O = unknown> extends DbxAct
     constructor();
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDirective<any, any>, "dbx-action,[dbxAction],dbx-action-context,[dbxActionContext]", ["action", "dbxAction"], {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDirective<any, any>, "dbx-action,[dbxAction],dbx-action-context,[dbxActionContext]", ["action", "dbxAction"], {}, {}, never, never, true, never>;
 }

package/lib/action/directive/context/action.source.directive.d.ts

@@ -1,16 +1,12 @@
-import { OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
 import { SecondaryActionContextStoreSource, ActionContextStoreSource } from '../../action.store.source';
 import * as i0 from "@angular/core";
 /**
  * Directive that provides a DbxActionSourceDirective that is passed in.
  */
-export declare class DbxActionSourceDirective implements SecondaryActionContextStoreSource, OnDestroy {
-    private _source;
+export declare class DbxActionSourceDirective implements SecondaryActionContextStoreSource {
+    readonly dbxActionSource: import("@angular/core").InputSignal<Maybe<ActionContextStoreSource<unknown, unknown>>>;
     readonly store$: import("rxjs").Observable<import("@dereekb/dbx-core").ActionContextStore<unknown, unknown>>;
-    ngOnDestroy(): void;
-    get source(): Maybe<ActionContextStoreSource>;
-    set source(source: Maybe<ActionContextStoreSource>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionSourceDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionSourceDirective, "[dbxActionSource]", never, { "source": { "alias": "dbxActionSource"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionSourceDirective, "[dbxActionSource]", never, { "dbxActionSource": { "alias": "dbxActionSource"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/debug/action.logger.directive.d.ts

@@ -9,5 +9,5 @@ export declare class DbxActionContextLoggerDirective extends AbstractSubscriptio
     readonly source: DbxActionContextStoreSourceInstance<any, any>;
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionContextLoggerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionContextLoggerDirective, "[dbxActionLogger],[dbxActionContextLogger]", never, {}, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionContextLoggerDirective, "[dbxActionLogger],[dbxActionContextLogger]", never, {}, {}, never, never, true, never>;
 }

package/lib/action/directive/map/action.map.d.ts

@@ -1,13 +1,43 @@
+import { Observable } from 'rxjs';
 import { ActionContextStoreSource } from '../../action.store.source';
+import { Destroyable } from '@dereekb/util';
+/**
+ * Arbitrary string used to identify an action.
+ */
 export type ActionKey = string;
 /**
  * Map that returns sources for ActionKey values.
  */
-export declare abstract class ActionContextStoreSourceMap<T = unknown, O = unknown> {
+export declare abstract class ActionContextStoreSourceMap<T = unknown, O = unknown> implements Destroyable {
+    /**
+     * Returns the read-only map of action keys to sources.
+     */
+    abstract readonly actionKeySourceMap$: Observable<Map<ActionKey, ActionContextStoreSource<T, O>>>;
     /**
      * Returns a ActionContextStoreSource for the input action key.
      *
      * @param key Action key to retrieve the source for.
      */
     abstract sourceForKey(key: ActionKey): ActionContextStoreSource<T, O>;
+    /**
+     * Adds the store source for the input key.
+     * @param key Action key to add the source for.
+     * @param source Store source to add.
+     */
+    abstract addStoreSource(key: ActionKey, source: ActionContextStoreSource<T, O>): void;
+    /**
+     * Removes the store source for the input key.
+     * @param key Action key to remove the source for.
+     */
+    abstract removeStoreSource(key: ActionKey): void;
+    /**
+     * Destroys the map.
+     */
+    abstract destroy(): void;
 }
+/**
+ * Creates a new ActionContextStoreSourceMap.
+ *
+ * @returns A new ActionContextStoreSourceMap.
+ */
+export declare function actionContextStoreSourceMap<T = unknown, O = unknown>(): ActionContextStoreSourceMap<T, O>;

package/lib/action/directive/map/action.map.directive.d.ts

@@ -1,34 +1,14 @@
 import { OnDestroy } from '@angular/core';
-import { Observable } from 'rxjs';
-import { ActionContextStoreSource } from '../../action.store.source';
-import { ActionContextStore } from '../../action.store';
-import { ActionContextStoreSourceMap, ActionKey } from './action.map';
+import { ActionContextStoreSourceMap } from './action.map';
 import * as i0 from "@angular/core";
 /**
  * Context used for providing actions based on the action key.
  *
  * This is useful for passing action contexts around via the providers instead of explicit injection.
  */
-export declare class DbxActionContextMapDirective implements ActionContextStoreSourceMap, OnDestroy {
-    private readonly _map;
-    readonly map$: Observable<Map<string, ActionContextStoreSource<unknown, unknown>>>;
-    readonly areAnyWorking$: Observable<boolean>;
-    get map(): Map<ActionKey, ActionContextStoreSource>;
-    sourceForKey(key: ActionKey): ActionContextStoreSource<unknown, unknown>;
-    addStoreSource(key: ActionKey, source: ActionContextStoreSource): void;
-    removeStore(key: ActionKey): void;
+export declare class DbxActionContextMapDirective implements OnDestroy {
+    readonly actionContextStoreSourceMap: ActionContextStoreSourceMap<any, any>;
     ngOnDestroy(): void;
-    checkAnyAre(mapFn: (input: ActionContextStore) => Observable<boolean>, emptyArrayValue?: boolean): Observable<boolean>;
-    reduceFromAllSources<O, R>(mapFn: (input: ActionContextStore) => Observable<O>, reduceFn: (values: O[]) => R): Observable<R>;
-    fromAllSources<O>(mapFn: (input: ActionContextStore) => Observable<O>): Observable<O[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionContextMapDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionContextMapDirective, "[dbxActionContextMap]", ["actionMap"], {}, {}, never, never, false, never>;
-}
-export declare class DbxActionContextMapDirectiveSourceInstance implements ActionContextStoreSource {
-    private readonly _parent;
-    private readonly _key;
-    readonly store$: Observable<ActionContextStore>;
-    constructor(parent: DbxActionContextMapDirective, key: ActionKey);
-    get parent(): DbxActionContextMapDirective;
-    get key(): string;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionContextMapDirective, "[dbxActionContextMap]", ["actionMap"], {}, {}, never, never, true, never>;
 }

package/lib/action/directive/map/action.map.key.directive.d.ts

@@ -7,12 +7,12 @@ import * as i0 from "@angular/core";
  * Directive that provides a ActionContextStoreSource using the input key and DbxActionContextMapDirective.
  */
 export declare class DbxActionFromMapDirective implements SecondaryActionContextStoreSource, OnDestroy {
-    private readonly _map;
+    private readonly _actionContextStoreSourceMap;
     private readonly _key;
-    readonly store$: import("rxjs").Observable<import("@dereekb/dbx-core").ActionContextStore<unknown, unknown>>;
+    readonly store$: import("rxjs").Observable<import("@dereekb/dbx-core").ActionContextStore<any, any>>;
     ngOnDestroy(): void;
     get key(): Maybe<ActionKey>;
     set key(key: Maybe<ActionKey>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionFromMapDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionFromMapDirective, "[dbxActionFromMap]", never, { "key": { "alias": "dbxActionFromMap"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionFromMapDirective, "[dbxActionFromMap]", never, { "key": { "alias": "dbxActionFromMap"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/map/action.map.source.directive.d.ts

@@ -6,7 +6,7 @@ import * as i0 from "@angular/core";
  * Used to communicate with an dbxActionMap and set the ActionContextStore to the store based on the key.
  */
 export declare class DbxActionMapSourceDirective implements OnDestroy {
-    private readonly _map;
+    private readonly _actionContextStoreSourceMap;
     readonly source: ActionContextStoreSource<any, any>;
     private _key;
     ngOnDestroy(): void;
@@ -14,5 +14,5 @@ export declare class DbxActionMapSourceDirective implements OnDestroy {
     private _addToStore;
     private _removeFromToStore;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionMapSourceDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionMapSourceDirective, "[dbxActionMapSource]", never, { "key": { "alias": "dbxActionMapSource"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionMapSourceDirective, "[dbxActionMapSource]", never, { "key": { "alias": "dbxActionMapSource"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/map/action.map.utility.d.ts

@@ -0,0 +1,48 @@
+import { IsCheckFunction, ObservableOrValue } from '@dereekb/rxjs';
+import { Observable } from 'rxjs';
+import { ActionContextStore } from '../../action.store';
+import { ActionContextStoreSourceMap, ActionKey } from './action.map';
+import { ActionContextStoreSource } from '../../action.store.source';
+/**
+ * Utility interface that provides a set of functions to read from an ActionContextStoreSourceMap.
+ */
+export interface ActionContextStoreSourceMapReader<T = unknown, O = unknown> {
+    /**
+     * The input key source map.
+     */
+    readonly actionKeySourceMap$: Observable<Map<ActionKey, ActionContextStoreSource<T, O>>>;
+    /**
+     * Checks if any of the stores in the map match the input checkFunction.
+     *
+     * @param checkFunction Function to apply to each store.
+     * @param emptyArrayValue Value to return if the map is empty.
+     */
+    checkAny(checkFunction: IsCheckFunction<ActionContextStore<T, O>>, emptyArrayValue?: boolean): Observable<boolean>;
+    /**
+     * Reduces a value from all stores in the map.
+     *
+     * @param mapFn Function to apply to each store.
+     * @param reduceFn Function to apply to the results of the mapFn.
+     */
+    reduceFromAllSources<X, Y>(mapFn: (input: ActionContextStore<T, O>) => Observable<X>, reduceFn: (values: X[]) => Y): Observable<Y>;
+    /**
+     * Reads a value from each store in the map and returns an array of the results.
+     *
+     * @param mapFn Function to apply to each store.
+     */
+    fromAllSources<Y>(mapFn: (input: ActionContextStore<T, O>) => Observable<Y>): Observable<Y[]>;
+}
+/**
+ * Creates a new ActionContextStoreSourceMapReader from the input.
+ 
+ * @param actionKeySourceMap$
+ */
+export declare function actionContextStoreSourceMapReader<T = unknown, O = unknown>(actionKeySourceMap$: ObservableOrValue<Map<ActionKey, ActionContextStoreSource<T, O>>>): ActionContextStoreSourceMapReader<T, O>;
+/**
+ * Returns an Observable of the results of the mapFn for each source in the actionKeySourceMap$.
+ *
+ * @param actionKeySourceMap$ Observable of the action key source map.
+ * @param mapFn Function to apply to each source.
+ * @returns Observable of the results of the mapFn for each source.
+ */
+export declare function fromAllActionContextStoreSourceMapSources<O>(actionKeySourceMap$: ObservableOrValue<ActionContextStoreSourceMap>, mapFn: (input: ActionContextStore) => Observable<O>): Observable<O[]>;

package/lib/action/directive/map/action.map.working.disable.directive.d.ts

@@ -2,18 +2,18 @@ import { OnInit, OnDestroy } from '@angular/core';
 import { type Maybe } from '@dereekb/util';
 import { AbstractSubscriptionDirective } from '../../../subscription';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
-import { DbxActionDisabledKey } from '../../action';
 import * as i0 from "@angular/core";
 export declare const DEFAULT_ACTION_MAP_WORKING_DISABLED_KEY = "action_map_working_disable";
 /**
  * Used to communicate with an dbxActionMap and set the ActionContextStore to be disabled if any other element in the map is working.
  */
 export declare class DbxActionMapWorkingDisableDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
-    private readonly _map;
+    private readonly _actionContextStoreSourceMap;
     readonly source: DbxActionContextStoreSourceInstance<any, any>;
-    disabledKey: Maybe<DbxActionDisabledKey>;
+    readonly disabledKey: import("@angular/core").InputSignal<Maybe<string>>;
+    readonly areAnySourcesWorking$: import("rxjs").Observable<boolean>;
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionMapWorkingDisableDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionMapWorkingDisableDirective, "[dbxActionMapWorkingDisable]", never, { "disabledKey": { "alias": "dbxActionMapWorkingDisable"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionMapWorkingDisableDirective, "[dbxActionMapWorkingDisable]", never, { "disabledKey": { "alias": "dbxActionMapWorkingDisable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/map/index.d.ts

@@ -2,4 +2,5 @@ export * from './action.map.directive';
 export * from './action.map.key.directive';
 export * from './action.map.source.directive';
 export * from './action.map';
+export * from './action.map.utility';
 export * from './action.map.working.disable.directive';

package/lib/action/directive/state/action.disabled.directive.d.ts

@@ -16,5 +16,5 @@ export declare class DbxActionDisabledDirective<T, O> extends AbstractSubscripti
     get disabled(): boolean;
     set disabled(disabled: Maybe<boolean | ''>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDisabledDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledDirective<any, any>, "[dbxActionDisabled]", never, { "disabled": { "alias": "dbxActionDisabled"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledDirective<any, any>, "[dbxActionDisabled]", never, { "disabled": { "alias": "dbxActionDisabled"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/state/action.disableonsuccess.directive.d.ts

@@ -16,5 +16,5 @@ export declare class DbxActionDisabledOnSuccessDirective<T, O> extends AbstractS
     get disabled(): boolean;
     set disabled(disabled: Maybe<boolean | ''>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDisabledOnSuccessDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledOnSuccessDirective<any, any>, "[dbxActionDisabledOnSuccess]", never, { "disabled": { "alias": "dbxActionDisabledOnSuccess"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledOnSuccessDirective<any, any>, "[dbxActionDisabledOnSuccess]", never, { "disabled": { "alias": "dbxActionDisabledOnSuccess"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/state/action.enforce.modified.directive.d.ts

@@ -15,5 +15,5 @@ export declare class DbxActionEnforceModifiedDirective extends AbstractSubscript
     get enabled(): boolean;
     set enabled(enabled: Maybe<boolean | ''>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionEnforceModifiedDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionEnforceModifiedDirective, "[dbxActionEnforceModified]", never, { "enabled": { "alias": "dbxActionEnforceModified"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionEnforceModifiedDirective, "[dbxActionEnforceModified]", never, { "enabled": { "alias": "dbxActionEnforceModified"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/state/action.handler.directive.d.ts

@@ -1,4 +1,4 @@
-import { OnDestroy, OnInit } from '@angular/core';
+import { OnDestroy } from '@angular/core';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import { FactoryWithInput, GetterOrValue, type Maybe } from '@dereekb/util';
 import { DbxActionHandlerInstance } from './action.handler.instance';
@@ -7,30 +7,29 @@ import * as i0 from "@angular/core";
 /**
  * Abstract directive that wraps and handles a DbxActionHandlerInstance lifecycle.
  */
-export declare abstract class AbstractDbxActionHandlerDirective<T = unknown, O = unknown> implements OnInit, OnDestroy {
+export declare abstract class AbstractDbxActionHandlerDirective<T = unknown, O = unknown> implements OnDestroy {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
-    protected _dbxActionHandlerInstance: DbxActionHandlerInstance<T, O>;
-    ngOnInit(): void;
+    protected readonly _dbxActionHandlerInstance: DbxActionHandlerInstance<T, O>;
+    constructor();
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxActionHandlerDirective<any, any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxActionHandlerDirective<any, any>, never, never, {}, {}, never, never, false, never>;
 }
 /**
- * Directive that wraps and controls a DbxActionHandlerInstance.
+ * Directive that passes a Work function to handle a valueReady$ event from an action context.
  */
 export declare class DbxActionHandlerDirective<T = unknown, O = unknown> extends AbstractDbxActionHandlerDirective<T, O> {
-    get handlerFunction(): Maybe<Work<T, O>>;
-    set handlerFunction(handlerFunction: Maybe<Work<T, O>>);
+    readonly handlerFunction: import("@angular/core").InputSignal<Maybe<Work<T, O>>>;
+    protected readonly _handlerFunctionEffect: import("@angular/core").EffectRef;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionHandlerDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionHandlerDirective<any, any>, "[dbxActionHandler]", never, { "handlerFunction": { "alias": "dbxActionHandler"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionHandlerDirective<any, any>, "[dbxActionHandler]", never, { "handlerFunction": { "alias": "dbxActionHandler"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 /**
- * Directive that passes
+ * Directive that passes a value to handle a valueReady$ event from an action context.
  */
 export declare class DbxActionHandlerValueDirective<T = unknown, O = unknown> extends AbstractDbxActionHandlerDirective<T, O> {
-    get handlerValue(): Maybe<GetterOrValue<O> | FactoryWithInput<O, T>>;
-    set handlerValue(handlerValue: Maybe<GetterOrValue<O> | FactoryWithInput<O, T>>);
-    ngOnInit(): void;
+    readonly handlerValue: import("@angular/core").InputSignal<Maybe<GetterOrValue<O> | FactoryWithInput<O, T>>>;
+    protected readonly _handlerValueEffect: import("@angular/core").EffectRef;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionHandlerValueDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionHandlerValueDirective<any, any>, "[dbxActionHandlerValue]", never, { "handlerValue": { "alias": "dbxActionHandlerValue"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionHandlerValueDirective<any, any>, "[dbxActionHandlerValue]", never, { "handlerValue": { "alias": "dbxActionHandlerValue"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/state/action.handler.instance.d.ts

@@ -11,12 +11,12 @@ export declare class DbxActionHandlerInstance<T = unknown, O = unknown> implemen
     private readonly _handlerFunction;
     private readonly _handlerValue;
     readonly handlerFunction$: import("rxjs").Observable<Work<T, O>>;
-    get handlerFunction(): Maybe<Work<T, O>>;
-    set handlerFunction(handlerFunction: Maybe<Work<T, O>>);
-    get handlerValue(): Maybe<GetterOrValue<O> | FactoryWithInput<O, T>>;
-    set handlerValue(handlerValue: Maybe<GetterOrValue<O> | FactoryWithInput<O, T>>);
     constructor(source: DbxActionContextStoreSourceInstance<T, O>);
     get source(): DbxActionContextStoreSourceInstance<T, O>;
+    get handlerFunction(): Maybe<Work<T, O>>;
+    get handlerValue(): Maybe<GetterOrValue<O> | FactoryWithInput<O, T>>;
+    setHandlerFunction(handlerFunction: Maybe<Work<T, O>>): void;
+    setHandlerValue(handlerValue: Maybe<GetterOrValue<O> | FactoryWithInput<O, T>>): void;
     init(): void;
     destroy(): void;
 }

package/lib/action/directive/state/action.presuccess.directive.d.ts

@@ -10,5 +10,5 @@ export declare class DbxActionPreSuccessDirective extends AbstractIfDirective {
     hideFor?: Maybe<number> | '';
     readonly show$: import("rxjs").Observable<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionPreSuccessDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionPreSuccessDirective, "[dbxActionPreSuccess]", never, { "hideFor": { "alias": "dbxActionPreSuccess"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionPreSuccessDirective, "[dbxActionPreSuccess]", never, { "hideFor": { "alias": "dbxActionPreSuccess"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/state/action.success.directive.d.ts

@@ -11,5 +11,5 @@ export declare class DbxActionHasSuccessDirective extends AbstractIfDirective im
     hideAfter?: Maybe<number> | '';
     readonly show$: import("rxjs").Observable<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionHasSuccessDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionHasSuccessDirective, "[dbxActionHasSuccess]", never, { "hideAfter": { "alias": "dbxActionHasSuccess"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionHasSuccessDirective, "[dbxActionHasSuccess]", never, { "hideAfter": { "alias": "dbxActionHasSuccess"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/state/action.success.handler.directive.d.ts

@@ -12,12 +12,9 @@ export type DbxActionSuccessHandlerFunction<O = unknown> = (value: O) => void;
  */
 export declare class DbxActionSuccessHandlerDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
-    private readonly _successFunction;
+    readonly dbxActionSuccessHandler: import("@angular/core").InputSignal<Maybe<DbxActionSuccessHandlerFunction<O>>>;
     readonly successFunction$: import("rxjs").Observable<DbxActionSuccessHandlerFunction<O>>;
     ngOnInit(): void;
-    ngOnDestroy(): void;
-    get successFunction(): Maybe<DbxActionSuccessHandlerFunction<O>>;
-    set successFunction(successFunction: Maybe<DbxActionSuccessHandlerFunction<O>>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionSuccessHandlerDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionSuccessHandlerDirective<any, any>, "[dbxActionSuccessHandler]", never, { "successFunction": { "alias": "dbxActionSuccessHandler"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionSuccessHandlerDirective<any, any>, "[dbxActionSuccessHandler]", never, { "dbxActionSuccessHandler": { "alias": "dbxActionSuccessHandler"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/action/directive/state/action.value.directive.d.ts

@@ -1,5 +1,6 @@
 import { OnInit, OnDestroy } from '@angular/core';
 import { Maybe, GetterOrValue } from '@dereekb/util';
+import { Observable } from 'rxjs';
 import { AbstractSubscriptionDirective } from '../../../subscription';
 import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
@@ -7,16 +8,20 @@ import * as i0 from "@angular/core";
  * Directive that provides a default value when triggered.
  *
  * No value is required, allowing the directive to automatically call readyValue.
+ *
+ * The valueOrFunction will filter on null/undefined input and wait until the input value is non-null.
+ *
+ * Use a getter if null/undefined values should be passed to the action.
  */
 export declare class DbxActionValueDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+    readonly valueOrFunction: import("@angular/core").InputSignal<Maybe<"" | GetterOrValue<T>>>;
     readonly source: DbxActionContextStoreSourceInstance<T, O>;
-    private readonly _valueOrFunction;
-    readonly valueOrFunction$: import("rxjs").Observable<GetterOrValue<T>>;
+    private readonly _valueOrFunctionOverride;
+    readonly valueOrFunction$: Observable<GetterOrValue<T>>;
     constructor();
     ngOnInit(): void;
+    setValueOrFunction(value: Maybe<GetterOrValue<T>>): void;
     ngOnDestroy(): void;
-    get valueOrFunction(): Maybe<GetterOrValue<T>>;
-    set valueOrFunction(valueOrFunction: Maybe<GetterOrValue<T>>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionValueDirective<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionValueDirective<any, any>, "[dbxActionValue]", never, { "valueOrFunction": { "alias": "dbxActionValue"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionValueDirective<any, any>, "dbxActionValue,[dbxActionValue]", never, { "valueOrFunction": { "alias": "dbxActionValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }