@dereekb/dbx-core 1.0.0 → 2.0.0

package/lib/action/action.d.ts

@@ -1,43 +1,45 @@
+import { LoadingStateType } from "@dereekb/rxjs";
 /**
  * Used by ActionContextState to denote what state the action is in.
  */
-export declare enum ActionState {
+export declare enum DbxActionState {
     /**
      * No action in progress. Waiting for the trigger.
      */
-    Idle = "idle",
+    IDLE = "idle",
     /**
      * Idle state that can be set to show that the source is not yet ready.
      */
-    Disabled = "disabled",
+    DISABLED = "disabled",
     /**
      * The action was triggered. We wait (and allow) the value to be updated.
      */
-    Triggered = "triggered",
+    TRIGGERED = "triggered",
     /**
      * The trigger was accepted and the value is updated. It should begin working immediately.
      *
      * ValueReady cannot be set until triggered is set.
      */
-    ValueReady = "valueReady",
+    VALUE_READY = "valueReady",
     /**
      * The action is in progress.
      */
-    Working = "working",
+    WORKING = "working",
     /**
      * The trigger, action, or value was rejected due to an error or other issue.
      *
      * An error may be specified optionally.
      */
-    Rejected = "rejected",
+    REJECTED = "rejected",
     /**
-     * The action was successful.
+     * The action resolved without issue.
      */
-    Success = "success"
+    RESOLVED = "resolved"
 }
 /**
  * Unique key for disabling/enabling.
  */
-export declare type ActionDisabledKey = string;
-export declare const DEFAULT_ACTION_DISABLED_KEY = "default";
-export declare function isIdleActionState(actionState: ActionState): boolean;
+export declare type DbxActionDisabledKey = string;
+export declare const DEFAULT_ACTION_DISABLED_KEY = "dbx_action_disabled";
+export declare function isIdleActionState(actionState: DbxActionState): boolean;
+export declare function loadingStateTypeForActionState(actionState: DbxActionState): LoadingStateType;

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

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { ActionContextStoreSourceInstance } from './action.store.source';
+import { DbxActionContextStoreSourceInstance } from './action.store.source';
 import { Maybe, Destroyable } from '@dereekb/util';
 export interface WorkHandlerContextDelegate<O = any> {
     startWorking(): void;
@@ -7,11 +7,11 @@ export interface WorkHandlerContextDelegate<O = any> {
     reject(error?: Maybe<any>): void;
 }
 /**
- * WorkHandlerContextDelegate implementation using an ActionContextStoreSourceInstance.
+ * WorkHandlerContextDelegate implementation using an DbxActionContextStoreSourceInstance.
  */
 export declare class WorkHandlerContextSourceDelegate<T = any, O = any> implements WorkHandlerContextDelegate<O> {
-    readonly source: ActionContextStoreSourceInstance<T, O>;
-    constructor(source: ActionContextStoreSourceInstance<T, O>);
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
+    constructor(source: DbxActionContextStoreSourceInstance<T, O>);
     startWorking(): void;
     success(result: O): void;
     reject(error: any): void;
@@ -63,10 +63,18 @@ export interface HandleWorkValueReadyConfig<T, O> {
     handlerFunction: HandleActionFunction<T, O>;
     delegate: WorkHandlerContextDelegate<O>;
 }
+/**
+ * Performs the action using the value and returns an observable.
+ */
+export declare type HandleActionUsingObservable<T = any, O = any> = (value: T) => Observable<O>;
+/**
+ * Performs the action that uses the context handler to handle the event.
+ */
+export declare type HandleActionUsingContext<T = any, O = any> = (value: T, context: WorkHandlerContext<T, O>) => void;
 /**
  * Performs the action. Can either return an observable that will use the handler, or can use the handler itself.
  */
-export declare type HandleActionFunction<T = any, O = any> = (value: T, context: WorkHandlerContext<T, O>) => Observable<O> | void;
+export declare type HandleActionFunction<T = any, O = any> = HandleActionUsingObservable<T, O> | HandleActionUsingContext<T, O>;
 /**
  * Creates a function that handles the incoming value and creates a WorkHandlerContext.
  */

package/lib/action/action.holder.d.ts

@@ -1,23 +1,24 @@
 import { Observable } from 'rxjs';
-import { Destroyable } from '@dereekb/util';
+import { Destroyable, Maybe } from '@dereekb/util';
 import { LockSet } from '@dereekb/rxjs';
-import { ActionContextStoreSource, ActionContextStoreSourceInstance, SecondaryActionContextStoreSource } from './action.store.source';
+import { ActionContextStoreSource, DbxActionContextStoreSourceInstance, SecondaryActionContextStoreSource } from './action.store.source';
 import { ActionContextStore } from './action.store';
+import { DbxActionDisabledKey } from './action';
 /**
  * Abstract class that can either use SecondaryActionContextStoreSource or create it's own.
  */
-export declare class ActionContextBaseSource<T = any, O = any> implements ActionContextStoreSource, Destroyable {
+export declare class DbxActionContextBaseSource<T = any, O = any> implements ActionContextStoreSource, Destroyable {
     readonly inputSource?: SecondaryActionContextStoreSource<any, any> | undefined;
     private readonly _store?;
     private readonly _store$;
     private readonly _instance;
     readonly isModified$: Observable<boolean>;
     readonly triggered$: Observable<boolean>;
-    readonly success$: Observable<O>;
+    readonly success$: Observable<Maybe<O>>;
     constructor(inputSource?: SecondaryActionContextStoreSource<any, any> | undefined);
     destroy(): void;
     get lockSet(): LockSet;
-    get sourceInstance(): ActionContextStoreSourceInstance<T, O>;
+    get sourceInstance(): DbxActionContextStoreSourceInstance<T, O>;
     get store$(): Observable<ActionContextStore<T, O>>;
     /**
      * Use to trigger the action directly.
@@ -25,4 +26,7 @@ export declare class ActionContextBaseSource<T = any, O = any> implements Action
     trigger(): void;
     readyValue(value: T): void;
     reset(): void;
+    enable(key?: DbxActionDisabledKey, enable?: boolean): void;
+    disable(key?: DbxActionDisabledKey, disable?: boolean): void;
+    setIsModified(isModified?: boolean): void;
 }

package/lib/action/action.machine.d.ts

@@ -1,23 +1,36 @@
+import { DbxActionContextSourceReference } from './action.reference';
 import { ActionContextStoreSource } from './action.store.source';
 import { HandleActionFunction } from './action.handler';
-import { ActionContextBaseSource } from './action.holder';
-import { Destroyable } from '@dereekb/util';
-export interface ActionContextMachineConfig<T = any, O = any> {
+import { DbxActionContextBaseSource } from './action.holder';
+import { Destroyable, Maybe } from '@dereekb/util';
+/**
+ * DbxActionContextMachine configuration.
+ */
+export interface DbxActionContextMachineConfig<T = any, O = any> {
     /**
-     * Whether or not the machine should clean itself up after being triggered.
+     * Whether or not the machine should clean itself up after being triggered once.
      */
     oneTimeUse: boolean;
+    /**
+     * Function to handle any valueReady events.
+     */
     handleValueReady: HandleActionFunction<T, O>;
-    onSuccess?: (value: O) => void;
+    /**
+     * Optional function to execute after the action has succeeded.
+     */
+    onSuccess?: (value: Maybe<O>) => void;
 }
 /**
  * Configurable machine that handles components of the ActionContextStore lifecycle.
+ *
+ * It can be configured to activate only once before cleaning itself up. It can be used directly as a DbxActionContextSourceReference in cases where it is created as a one-off action.
  */
-export declare class ActionContextMachine<T = any, O = any> extends ActionContextBaseSource<T, O> implements Destroyable {
-    readonly config: ActionContextMachineConfig<T, O>;
+export declare class DbxActionContextMachine<T = any, O = any> extends DbxActionContextBaseSource<T, O> implements DbxActionContextSourceReference<T, O>, Destroyable {
+    readonly config: DbxActionContextMachineConfig<T, O>;
     private _isShutdown;
     private _handleValueReadySub;
-    constructor(config: ActionContextMachineConfig<T, O>, source?: ActionContextStoreSource);
+    private _successSub;
+    constructor(config: DbxActionContextMachineConfig<T, O>, source?: ActionContextStoreSource<T, O>);
     destroy(): void;
     get isShutdown(): boolean;
 }

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

@@ -7,9 +7,9 @@ import * as i5 from "./directive/map/action.map.working.disable.directive";
 import * as i6 from "./directive/context/action.source.directive";
 import * as i7 from "./directive/state/action.handler.directive";
 import * as i8 from "./directive/state/action.disabled.directive";
-import * as i9 from "./directive/state/action.disabled.modified.directive";
+import * as i9 from "./directive/state/action.enforce.modified.directive";
 import * as i10 from "./directive/auto/action.autotrigger.directive";
-import * as i11 from "./directive/auto/action.autotrigger.value.directive";
+import * as i11 from "./directive/state/action.value.stream.directive";
 import * as i12 from "./directive/auto/action.automodify.directive";
 import * as i13 from "./directive/state/action.value.directive";
 import * as i14 from "./directive/debug/action.logger.directive";
@@ -19,6 +19,6 @@ import * as i17 from "./directive/state/action.working.component";
 import * as i18 from "@angular/common";
 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 i8.DbxActionDisabledDirective, typeof i9.DbxActionDisabledUntilModifiedDirective, typeof i10.DbxActionAutoTriggerDirective, typeof i11.DbxActionAutoTriggerValueDirective, typeof i12.DbxActionAutoModifyDirective, typeof i13.DbxActionValueDirective, typeof i14.DbxActionContextLoggerDirective, typeof i15.DbxActionSuccessComponent, typeof i16.DbxActionSuccessDirective, typeof i17.DbxActionWorkingComponent], [typeof i18.CommonModule], [typeof i1.DbxActionDirective, typeof i2.DbxActionContextMapDirective, typeof i3.DbxActionFromMapDirective, typeof i4.DbxActionMapSourceDirective, typeof i5.DbxActionMapWorkingDisableDirective, typeof i6.DbxActionSourceDirective, typeof i7.DbxActionHandlerDirective, typeof i8.DbxActionDisabledDirective, typeof i9.DbxActionDisabledUntilModifiedDirective, typeof i10.DbxActionAutoTriggerDirective, typeof i11.DbxActionAutoTriggerValueDirective, typeof i12.DbxActionAutoModifyDirective, typeof i13.DbxActionValueDirective, typeof i14.DbxActionContextLoggerDirective, typeof i15.DbxActionSuccessComponent, typeof i16.DbxActionSuccessDirective, typeof i17.DbxActionWorkingComponent]>;
+    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 i8.DbxActionDisabledDirective, typeof i9.DbxActionEnforceModifiedDirective, typeof i10.DbxActionAutoTriggerDirective, typeof i11.dbxActionValueStreamDirective, typeof i12.DbxActionAutoModifyDirective, typeof i13.DbxActionValueDirective, typeof i14.DbxActionContextLoggerDirective, typeof i15.DbxActionSuccessComponent, typeof i16.DbxActionSuccessDirective, typeof i17.DbxActionWorkingComponent], [typeof i18.CommonModule], [typeof i1.DbxActionDirective, typeof i2.DbxActionContextMapDirective, typeof i3.DbxActionFromMapDirective, typeof i4.DbxActionMapSourceDirective, typeof i5.DbxActionMapWorkingDisableDirective, typeof i6.DbxActionSourceDirective, typeof i7.DbxActionHandlerDirective, typeof i8.DbxActionDisabledDirective, typeof i9.DbxActionEnforceModifiedDirective, typeof i10.DbxActionAutoTriggerDirective, typeof i11.dbxActionValueStreamDirective, typeof i12.DbxActionAutoModifyDirective, typeof i13.DbxActionValueDirective, typeof i14.DbxActionContextLoggerDirective, typeof i15.DbxActionSuccessComponent, typeof i16.DbxActionSuccessDirective, typeof i17.DbxActionWorkingComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DbxCoreActionModule>;
 }

package/lib/action/action.reference.d.ts

@@ -0,0 +1,11 @@
+import { Destroyable } from "@dereekb/util";
+import { DbxActionContextStoreSourceInstance } from "./action.store.source";
+/**
+ * Acts as a reference to a DbxActionContextStoreSourceInstance that can be destroyed.
+ *
+ * This is used in cases where the action is passed around and the context it is passed to needs to clean up.
+ */
+export interface DbxActionContextSourceReference<T = any, O = any> extends Destroyable {
+    readonly sourceInstance: DbxActionContextStoreSourceInstance<T, O>;
+}
+export declare function makeDbxActionContextSourceReference<T, O>(sourceInstance: DbxActionContextStoreSourceInstance<T, O>): DbxActionContextSourceReference<T, O>;

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

@@ -2,26 +2,34 @@ import { OnDestroy } from '@angular/core';
 import { ComponentStore } from '@ngrx/component-store';
 import { Observable } from 'rxjs';
 import { BooleanStringKeyArray, Maybe, ReadableError } from '@dereekb/util';
-import { LockSet } from '@dereekb/rxjs';
-import { ActionState } from './action';
+import { LoadingStateType, LoadingState, LockSet } from '@dereekb/rxjs';
+import { DbxActionState } from './action';
 import * as i0 from "@angular/core";
 export declare function isActionContextEnabled(state: ActionContextState): boolean;
 export declare function isActionContextDisabled(state: ActionContextState): boolean;
 export declare function isDisabledActionContextState(state: ActionContextState): boolean;
-export declare function isWorkingActionState(actionState: ActionState): boolean;
-export declare function canTriggerActionState(actionState: ActionState): boolean;
+export declare function isWorkingActionState(actionState: DbxActionState): boolean;
+export declare function canTriggerActionState(actionState: DbxActionState): boolean;
 export declare function canTriggerAction(state: ActionContextState): boolean;
 export declare function canReadyValue(state: ActionContextState): boolean;
 export declare function actionContextIsModifiedAndCanTrigger(state: ActionContextState): boolean;
 export declare function actionContextHasNoErrorAndIsModifiedAndCanTrigger(state: ActionContextState): boolean;
+export declare function loadingStateForActionContextState<O>(state: ActionContextState): LoadingState<O>;
+export declare function loadingStateTypeForActionContextState(state: ActionContextState): LoadingStateType;
 export interface ActionContextState<T = any, O = any> {
-    actionState: ActionState;
+    actionState: DbxActionState;
     isModified: boolean;
     /**
-     * Value that is set after a triggered action.
+     * Value that is set after a triggered action. Not to be confused with result.
      */
     value?: Maybe<T>;
+    /**
+     * Resolved result value.
+     */
     result?: Maybe<O>;
+    /**
+     * Rejected error, if available.
+     */
     error?: Maybe<ReadableError>;
     /**
      * Current disabled state.
@@ -35,11 +43,11 @@ export interface ActionContextState<T = any, O = any> {
 export declare class ActionContextStore<T = any, O = any> extends ComponentStore<ActionContextState<T, O>> implements OnDestroy {
     readonly lockSet: LockSet;
     constructor();
-    readonly actionState$: Observable<ActionState>;
+    readonly actionState$: Observable<DbxActionState>;
     /**
-     * Returns the current disabled reasons.
+     * Returns the current disabled reasons/keys.
      */
-    readonly disabled$: Observable<string[]>;
+    readonly disabledKeys$: Observable<string[]>;
     /**
      * Maps the current state to true or not when the action state changes to/from disabled.
      */
@@ -55,7 +63,7 @@ export declare class ActionContextStore<T = any, O = any> extends ComponentStore
     /**
      * Pipes the readied value on ValueReady.
      */
-    readonly valueReady$: Observable<any>;
+    readonly valueReady$: Observable<T>;
     /**
      * Pipes the error on the rejection state.
      */
@@ -75,11 +83,19 @@ export declare class ActionContextStore<T = any, O = any> extends ComponentStore
     /**
      * Pipes the result when the ActionState becomes success.
      */
-    readonly success$: Observable<any>;
+    readonly success$: Observable<Maybe<O>>;
     /**
      * Whether or not it is currently in a success state.
      */
     readonly isSuccess$: Observable<boolean>;
+    /**
+     * Returns a loading state based on the current state.
+     */
+    readonly loadingState$: Observable<LoadingState<O>>;
+    /**
+     * Returns the current LoadingStateType based on the current state.
+     */
+    readonly loadingStateType$: Observable<LoadingStateType>;
     /**
      * Number of errors since last success.
      */
@@ -120,7 +136,7 @@ export declare class ActionContextStore<T = any, O = any> extends ComponentStore
     /**
      * Updates the value, setting value ready. The current result is cleared.
      */
-    readonly readyValue: (() => void) | ((observableOrValue: Maybe<T> | Observable<Maybe<T>>) => import("rxjs").Subscription) | (T extends void ? () => void : (observableOrValue: Maybe<T> | Observable<Maybe<T>>) => import("rxjs").Subscription);
+    readonly readyValue: T extends void ? () => void : (observableOrValue: T | Observable<T>) => import("rxjs").Subscription;
     /**
      * Notifys the context that the action is in progress.
      */
@@ -134,13 +150,15 @@ export declare class ActionContextStore<T = any, O = any> extends ComponentStore
      *
      * Clears modified state, and any errors.
      */
-    readonly success: O extends void ? () => void : (observableOrValue: O | Observable<O>) => import("rxjs").Subscription;
+    readonly resolve: (() => void) | ((observableOrValue: Maybe<O> | Observable<Maybe<O>>) => import("rxjs").Subscription) | (O extends void ? () => void : (observableOrValue: Maybe<O> | Observable<Maybe<O>>) => import("rxjs").Subscription);
     /**
      * Completely resets the store.
      */
     readonly reset: () => void;
-    afterDistinctBoolean(fromState: (state: ActionContextState) => boolean): Observable<boolean>;
-    afterDistinctActionState<X>(actionState: ActionState, fromState: (state: ActionContextState) => X): Observable<X>;
+    afterDistinctBoolean(fromState: (state: ActionContextState<T, O>) => boolean): Observable<boolean>;
+    afterDistinctActionState<X>(actionState: DbxActionState, fromState: (state: ActionContextState<T, O>) => X): Observable<X>;
+    afterDistinctActionStateChange(): Observable<ActionContextState<T, O>>;
+    afterDistinctLoadingStateTypeChange(): Observable<ActionContextState<T, O>>;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ActionContextStore<any, any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ActionContextStore<any, any>>;

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

@@ -1,10 +1,10 @@
 import { Observable, Subscription } from 'rxjs';
 import { Provider, Type } from '@angular/core';
-import { LockSet } from '@dereekb/rxjs';
+import { LockSet, LoadingState, LoadingStateType } from '@dereekb/rxjs';
 import { OnDestroy } from '@angular/core';
 import { Maybe, ReadableError } from '@dereekb/util';
 import { ActionContextState, ActionContextStore } from './action.store';
-import { ActionDisabledKey, ActionState } from './action';
+import { DbxActionDisabledKey, DbxActionState } from './action';
 import * as i0 from "@angular/core";
 /**
  * Source that provides a ActionContextStore observable.
@@ -30,7 +30,10 @@ export declare type UseActionStoreFunction<T, O> = (store: ActionContextStore<T,
  * Convenience function for subscribing to the input source once and using the provided store.
  */
 export declare function useActionStore<T = any, O = any>(source: ActionContextStoreSource<T, O>, useFn: UseActionStoreFunction<T, O>): Subscription;
-export declare class ActionContextStoreSourceInstance<T = any, O = any> implements OnDestroy {
+/**
+ * Service that wraps a ActionContextStoreSource.
+ */
+export declare class DbxActionContextStoreSourceInstance<T = any, O = any> implements ActionContextStoreSource, OnDestroy {
     readonly source: ActionContextStoreSource<T, O>;
     readonly lockSet: LockSet;
     constructor(source: ActionContextStoreSource<T, O>);
@@ -41,32 +44,36 @@ export declare class ActionContextStoreSourceInstance<T = any, O = any> implemen
     get state$(): Observable<ActionContextState<T, O>>;
     get triggered$(): Observable<boolean>;
     get valueReady$(): Observable<T>;
-    get success$(): Observable<O>;
+    get success$(): Observable<Maybe<O>>;
     get error$(): Observable<Maybe<ReadableError>>;
     get rejected$(): Observable<Maybe<ReadableError>>;
     get isModified$(): Observable<boolean>;
+    get canTrigger$(): Observable<boolean>;
     get isModifiedAndCanTriggerUpdates$(): Observable<boolean>;
     get isModifiedAndCanTrigger$(): Observable<boolean>;
-    get actionState$(): Observable<ActionState>;
+    get actionState$(): Observable<DbxActionState>;
+    get loadingState$(): Observable<LoadingState<O>>;
+    get loadingStateType$(): Observable<LoadingStateType>;
     get isWorking$(): Observable<boolean>;
     get isSuccess$(): Observable<boolean>;
+    get disabledKeys$(): Observable<string[]>;
     get isDisabled$(): Observable<boolean>;
     get errorCountSinceLastSuccess$(): Observable<number>;
-    enable(key?: ActionDisabledKey, enable?: boolean): void;
-    disable(key?: ActionDisabledKey, disable?: boolean): void;
+    enable(key?: DbxActionDisabledKey, enable?: boolean): void;
+    disable(key?: DbxActionDisabledKey, disable?: boolean): void;
     setIsModified(isModified?: boolean | Observable<boolean> | Observable<void>): void;
     trigger(): void;
-    readyValue(value: Maybe<T | Observable<T>>): void;
+    readyValue(value: T | Observable<T>): void;
     startWorking(): void;
     reject(error: Maybe<ReadableError | Observable<ReadableError>>): void;
-    success(value: O | Observable<O>): void;
+    resolve(value: O | Observable<O>): void;
     reset(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ActionContextStoreSourceInstance<any, any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<ActionContextStoreSourceInstance<any, any>, never, never, {}, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionContextStoreSourceInstance<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxActionContextStoreSourceInstance<any, any>>;
 }
-export declare const actionContextStoreSourceInstanceFactory: (source: ActionContextStoreSource) => ActionContextStoreSourceInstance<any, any>;
+export declare const actionContextStoreSourceInstanceFactory: (source: ActionContextStoreSource) => DbxActionContextStoreSourceInstance<any, any>;
 /**
- * Provides an ActionContextStoreSource, as well as an ActionContextStoreSourceInstance.
+ * Provides an ActionContextStoreSource, as well as an DbxActionContextStoreSourceInstance.
  */
 export declare function ProvideActionStoreSource<S>(sourceType: Type<S>): Provider[];
 export declare function ProvideSecondaryActionStoreSource<S>(sourceType: Type<S>): Provider[];

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

@@ -1,13 +1,14 @@
 import { OnInit, OnDestroy } from '@angular/core';
 import { AbstractSubscriptionDirective } from '../../../subscription';
-import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
+import { Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
 export declare class DbxActionAutoModifyDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
-    readonly source: ActionContextStoreSourceInstance<T, O>;
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
     private readonly _autoModifyEnabled;
     get autoModifyEnabled(): boolean;
-    set autoModifyEnabled(autoModifyEnabled: boolean);
-    constructor(source: ActionContextStoreSourceInstance<T, O>);
+    set autoModifyEnabled(autoModifyEnabled: Maybe<any>);
+    constructor(source: DbxActionContextStoreSourceInstance<T, O>);
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionAutoModifyDirective<any, any>, [{ host: true; }]>;

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

@@ -1,14 +1,14 @@
 import { OnInit, OnDestroy } from '@angular/core';
 import { AbstractSubscriptionDirective } from '../../../subscription';
 import { Observable } from 'rxjs';
-import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import { Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
 /**
- * Extension of DbxActionTransitionSafetyDirective that automatically triggers the action periodically when it is in a modified state.
+ * Directive that automatically triggers the action periodically when it is in a modified state.
  */
 export declare class DbxActionAutoTriggerDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
-    readonly source: ActionContextStoreSourceInstance<T, O>;
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
     private _triggerEnabled;
     /**
      * How much to throttle the auto-triggering.
@@ -24,13 +24,13 @@ export declare class DbxActionAutoTriggerDirective<T, O> extends AbstractSubscri
      *
      * Used in forms that are simple.
      */
-    set fastTrigger(fastTrigger: boolean);
+    set fastTrigger(fastTrigger: any);
     /**
      * Optional input to override both triggerDebounce and triggerThrottle to be 0.
      *
      * Used in forms that generally return a single value.
      */
-    set instantTrigger(instantTrigger: boolean);
+    set instantTrigger(instantTrigger: any);
     get triggerLimit(): Maybe<number>;
     set triggerLimit(triggerLimit: Maybe<number>);
     private readonly _triggerLimit;
@@ -45,7 +45,7 @@ export declare class DbxActionAutoTriggerDirective<T, O> extends AbstractSubscri
     private readonly _isTriggerLimited$;
     readonly isTriggerLimited$: Observable<boolean>;
     readonly trigger$: Observable<void>;
-    constructor(source: ActionContextStoreSourceInstance<T, O>);
+    constructor(source: DbxActionContextStoreSourceInstance<T, O>);
     get isEnabled(): boolean;
     ngOnInit(): void;
     ngOnDestroy(): void;

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

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

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

@@ -1,13 +1,13 @@
 import { OnDestroy } from '@angular/core';
 import { SecondaryActionContextStoreSource } from '../../action.store.source';
-import { ActionContextBaseSource } from '../../action.holder';
+import { DbxActionContextBaseSource } from '../../action.holder';
 import * as i0 from "@angular/core";
 /**
  * Provides an DbxActionContext.
  */
-export declare class DbxActionDirective<T = any, O = any> extends ActionContextBaseSource implements OnDestroy {
+export declare class DbxActionDirective<T = any, O = any> extends DbxActionContextBaseSource implements OnDestroy {
     constructor(inputSource: SecondaryActionContextStoreSource);
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDirective<any, any>, [{ optional: true; host: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDirective<any, any>, "dbx-action,[dbxAction],dbx-action-context,[dbxActionContext]", ["action"], {}, {}, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDirective<any, any>, "dbx-action,[dbxAction],dbx-action-context,[dbxActionContext]", ["action", "dbxAction"], {}, {}, never>;
 }

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

@@ -1,13 +1,13 @@
 import { OnInit } from '@angular/core';
 import { AbstractSubscriptionDirective } from '../../../subscription';
-import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
 /**
  * Prints out the current state to the console. Useful for debugging.
  */
 export declare class DbxActionContextLoggerDirective extends AbstractSubscriptionDirective implements OnInit {
-    readonly source: ActionContextStoreSourceInstance;
-    constructor(source: ActionContextStoreSourceInstance);
+    readonly source: DbxActionContextStoreSourceInstance;
+    constructor(source: DbxActionContextStoreSourceInstance);
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionContextLoggerDirective, [{ host: true; }]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionContextLoggerDirective, "[dbxActionLogger],[dbxActionContextLogger]", never, {}, {}, never>;

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

@@ -1,19 +1,19 @@
 import { OnInit, OnDestroy } from '@angular/core';
 import { Maybe } from '@dereekb/util';
 import { AbstractSubscriptionDirective } from '../../../subscription';
-import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import { DbxActionContextMapDirective } from './action.map.directive';
-import { ActionDisabledKey } from '../../action';
+import { DbxActionDisabledKey } from '../../action';
 import * as i0 from "@angular/core";
-export declare const DEFAULT_ACTION_MAP_WORKING_DISABLED_KEY = "__disabled";
+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 {
-    readonly source: ActionContextStoreSourceInstance;
+    readonly source: DbxActionContextStoreSourceInstance;
     private readonly _map;
-    disabledKey: Maybe<ActionDisabledKey>;
-    constructor(source: ActionContextStoreSourceInstance, _map: DbxActionContextMapDirective);
+    disabledKey: Maybe<DbxActionDisabledKey>;
+    constructor(source: DbxActionContextStoreSourceInstance, _map: DbxActionContextMapDirective);
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionMapWorkingDisableDirective, [{ host: true; }, null]>;

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

@@ -1,20 +1,21 @@
 import { OnInit, OnDestroy } from '@angular/core';
+import { Maybe } from '@dereekb/util';
 import { AbstractSubscriptionDirective } from '../../../subscription';
-import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
 export declare const APP_ACTION_DISABLED_DIRECTIVE_KEY = "dbx_action_disabled";
 /**
  * Directive that allows disabling an action using the inputs.
  */
 export declare class DbxActionDisabledDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
-    readonly source: ActionContextStoreSourceInstance<T, O>;
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
     private _disabled;
     readonly disabled$: import("rxjs").Observable<boolean>;
-    constructor(source: ActionContextStoreSourceInstance<T, O>);
+    constructor(source: DbxActionContextStoreSourceInstance<T, O>);
     ngOnInit(): void;
     ngOnDestroy(): void;
     get disabled(): boolean;
-    set disabled(disabled: boolean);
+    set disabled(disabled: Maybe<any>);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDisabledDirective<any, any>, [{ host: true; }]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledDirective<any, any>, "[dbxActionDisabled]", never, { "disabled": "dbxActionDisabled"; }, {}, never>;
 }

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

@@ -0,0 +1,19 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { AbstractSubscriptionDirective } from '../../../subscription';
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
+import * as i0 from "@angular/core";
+export declare const APP_ACTION_ENFORCE_MODIFIED_DIRECTIVE_KEY = "dbx_action_enforce_modified";
+/**
+ * Directive that toggles disabling an action if the action is not marked modified.
+ */
+export declare class DbxActionEnforceModifiedDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+    readonly source: DbxActionContextStoreSourceInstance;
+    private _enabled;
+    constructor(source: DbxActionContextStoreSourceInstance);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get enabled(): boolean;
+    set enabled(enabled: boolean);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionEnforceModifiedDirective, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionEnforceModifiedDirective, "[dbxActionEnforceModified]", never, { "enabled": "[dbxActionEnforceModified]"; }, {}, never>;
+}

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

@@ -1,6 +1,6 @@
 import { OnDestroy, OnInit } from '@angular/core';
 import { AbstractSubscriptionDirective } from '../../../subscription';
-import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import { HandleActionFunction } from '../../action.handler';
 import { Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
@@ -8,13 +8,13 @@ import * as i0 from "@angular/core";
  * Context used for defining a function that performs an action using the input function on ValueReady.
  */
 export declare class DbxActionHandlerDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
-    readonly source: ActionContextStoreSourceInstance<T, O>;
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
     private _handlerFunction;
     readonly handlerFunction$: import("rxjs").Observable<HandleActionFunction<T, O>>;
     get handlerFunction(): Maybe<HandleActionFunction<T, O>>;
     set handlerFunction(handlerFunction: Maybe<HandleActionFunction<T, O>>);
     private _delegate;
-    constructor(source: ActionContextStoreSourceInstance<T, O>);
+    constructor(source: DbxActionContextStoreSourceInstance<T, O>);
     ngOnInit(): void;
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionHandlerDirective<any, any>, [{ host: true; }]>;

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

@@ -1,4 +1,4 @@
-import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { DbxActionContextStoreSourceInstance } from '../../action.store.source';
 import * as i0 from "@angular/core";
 /**
  * Displays the input content when success is set.
@@ -6,10 +6,10 @@ import * as i0 from "@angular/core";
  * Can be configured to show for a limited time afterwards, etc.
  */
 export declare class DbxActionSuccessComponent {
-    readonly source: ActionContextStoreSourceInstance;
+    readonly source: DbxActionContextStoreSourceInstance;
     hideAfter?: number;
     readonly show$: import("rxjs").Observable<boolean>;
-    constructor(source: ActionContextStoreSourceInstance);
+    constructor(source: DbxActionContextStoreSourceInstance);
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionSuccessComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DbxActionSuccessComponent, "dbx-action-success", never, { "hideAfter": "hideAfter"; }, {}, never, ["*"]>;
 }