@dereekb/dbx-core 0.0.1

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

@@ -0,0 +1,23 @@
+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> {
+    /**
+     * Whether or not the machine should clean itself up after being triggered.
+     */
+    oneTimeUse: boolean;
+    handleValueReady: HandleActionFunction<T, O>;
+    onSuccess?: (value: O) => void;
+}
+/**
+ * Configurable machine that handles components of the ActionContextStore lifecycle.
+ */
+export declare class ActionContextMachine<T = any, O = any> extends ActionContextBaseSource<T, O> implements Destroyable {
+    readonly config: ActionContextMachineConfig<T, O>;
+    private _isShutdown;
+    private _handleValueReadySub;
+    constructor(config: ActionContextMachineConfig<T, O>, source?: ActionContextStoreSource);
+    destroy(): void;
+    get isShutdown(): boolean;
+}

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

@@ -0,0 +1,25 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./directive/context/action.component";
+import * as i2 from "./directive/context/action.directive";
+import * as i3 from "./directive/map/action.map.directive";
+import * as i4 from "./directive/map/action.map.key.directive";
+import * as i5 from "./directive/map/action.map.source.directive";
+import * as i6 from "./directive/map/action.map.working.disable.directive";
+import * as i7 from "./directive/context/action.source.directive";
+import * as i8 from "./directive/state/action.handler.directive";
+import * as i9 from "./directive/state/action.disabled.directive";
+import * as i10 from "./directive/state/action.disabled.modified.directive";
+import * as i11 from "./directive/auto/action.autotrigger.directive";
+import * as i12 from "./directive/auto/action.autotrigger.value.directive";
+import * as i13 from "./directive/auto/action.automodify.directive";
+import * as i14 from "./directive/state/action.value.directive";
+import * as i15 from "./directive/debug/action.logger.directive";
+import * as i16 from "./directive/state/action.success.component";
+import * as i17 from "./directive/state/action.success.directive";
+import * as i18 from "./directive/state/action.working.component";
+import * as i19 from "@angular/common";
+export declare class DbNgxCoreActionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxCoreActionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbNgxCoreActionModule, [typeof i1.DbNgxActionComponent, typeof i2.DbNgxActionContextDirective, typeof i3.DbNgxActionContextMapDirective, typeof i4.DbNgxActionFromMapDirective, typeof i5.DbNgxActionMapSourceDirective, typeof i6.DbNgxActionMapWorkingDisableDirective, typeof i7.DbNgxActionSourceDirective, typeof i8.DbNgxActionHandlerDirective, typeof i9.DbNgxActionDisabledDirective, typeof i10.DbNgxActionDisabledUntilModifiedDirective, typeof i11.DbNgxActionAutoTriggerDirective, typeof i12.DbNgxActionAutoTriggerValueDirective, typeof i13.DbNgxActionAutoModifyDirective, typeof i14.DbNgxActionValueDirective, typeof i15.DbNgxActionContextLoggerDirective, typeof i16.DbNgxActionSuccessComponent, typeof i17.DbNgxActionSuccessDirective, typeof i18.DbNgxActionWorkingComponent], [typeof i19.CommonModule], [typeof i1.DbNgxActionComponent, typeof i2.DbNgxActionContextDirective, typeof i3.DbNgxActionContextMapDirective, typeof i4.DbNgxActionFromMapDirective, typeof i5.DbNgxActionMapSourceDirective, typeof i6.DbNgxActionMapWorkingDisableDirective, typeof i7.DbNgxActionSourceDirective, typeof i8.DbNgxActionHandlerDirective, typeof i9.DbNgxActionDisabledDirective, typeof i10.DbNgxActionDisabledUntilModifiedDirective, typeof i11.DbNgxActionAutoTriggerDirective, typeof i12.DbNgxActionAutoTriggerValueDirective, typeof i13.DbNgxActionAutoModifyDirective, typeof i14.DbNgxActionValueDirective, typeof i15.DbNgxActionContextLoggerDirective, typeof i16.DbNgxActionSuccessComponent, typeof i17.DbNgxActionSuccessDirective, typeof i18.DbNgxActionWorkingComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbNgxCoreActionModule>;
+}

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

@@ -0,0 +1,147 @@
+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 * 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 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 interface ActionContextState<T = any, O = any> {
+    actionState: ActionState;
+    isModified: boolean;
+    /**
+     * Value that is set after a triggered action.
+     */
+    value?: Maybe<T>;
+    result?: Maybe<O>;
+    error?: Maybe<ReadableError>;
+    /**
+     * Current disabled state.
+     */
+    disabled?: BooleanStringKeyArray;
+    /**
+     * Number of consecutive errors that have occured.
+     */
+    errorCount?: number;
+}
+export declare class ActionContextStore<T = any, O = any> extends ComponentStore<ActionContextState<T, O>> implements OnDestroy {
+    readonly lockSet: LockSet;
+    constructor();
+    readonly actionState$: Observable<ActionState>;
+    /**
+     * Returns the current disabled reasons.
+     */
+    readonly disabled$: Observable<string[]>;
+    /**
+     * Maps the current state to true or not when the action state changes to/from disabled.
+     */
+    readonly isDisabled$: Observable<boolean>;
+    /**
+     * Pipes when idle but modified.
+     */
+    readonly isModified$: Observable<boolean>;
+    /**
+     * Pipes true when triggered.
+     */
+    readonly triggered$: Observable<boolean>;
+    /**
+     * Pipes the readied value on ValueReady.
+     */
+    readonly valueReady$: Observable<any>;
+    /**
+     * Pipes the error on the rejection state.
+     */
+    readonly rejected$: Observable<Maybe<ReadableError>>;
+    /**
+     * Pipes the result when the ActionState becomes working.
+     */
+    readonly working$: Observable<boolean>;
+    /**
+     * Whether or not it is currently in a working state.
+     */
+    readonly isWorking$: Observable<boolean>;
+    /**
+     * Pipes the current error.
+     */
+    readonly error$: Observable<Maybe<ReadableError>>;
+    /**
+     * Pipes the result when the ActionState becomes success.
+     */
+    readonly success$: Observable<any>;
+    /**
+     * Whether or not it is currently in a success state.
+     */
+    readonly isSuccess$: Observable<boolean>;
+    /**
+     * Number of errors since last success.
+     */
+    readonly errorCountSinceLastSuccess$: Observable<number>;
+    /**
+     * Whether or not the state can be triggered.
+     */
+    readonly canTrigger$: Observable<boolean>;
+    /**
+     * Pipe that maps whether or not this is modified and can be triggered.
+     *
+     * Updates every state update instead of when the value changes.
+     */
+    readonly isModifiedAndCanTriggerUpdates$: Observable<boolean>;
+    /**
+     * Whether or not it can be triggered and modified.
+     */
+    readonly isModifiedAndCanTrigger$: Observable<boolean>;
+    readonly hasNoErrorAndIsModifiedAndCanTrigger$: Observable<boolean>;
+    /**
+     * Adds a disabled reason.
+     */
+    readonly disable: (() => void) | ((observableOrValue: string | void | Observable<string | void>) => import("rxjs").Subscription);
+    /**
+     * Removes a disabled reason.
+     */
+    readonly enable: (() => void) | ((observableOrValue: string | void | Observable<string | void>) => import("rxjs").Subscription);
+    /**
+     * Triggers the modified state, if not disabled.
+     */
+    readonly setIsModified: (() => void) | ((observableOrValue: boolean | void | Observable<boolean | void>) => import("rxjs").Subscription);
+    /**
+     * Triggers the action if the state is currently not idle. The current state is cleared, but the error is retained (as we may need the error from the previous attempt).
+     *
+     * Will not fire if the action is disabled.
+     */
+    readonly trigger: () => void;
+    /**
+     * 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);
+    /**
+     * Notifys the context that the action is in progress.
+     */
+    readonly startWorking: () => void;
+    /**
+     * Triggers rejection of the action. The value is cleared.
+     */
+    readonly reject: (() => void) | ((observableOrValue: Maybe<ReadableError> | Observable<Maybe<ReadableError>>) => import("rxjs").Subscription);
+    /**
+     * Updates the state to success, and optionally sets a result.
+     *
+     * Clears modified state, and any errors.
+     */
+    readonly success: O extends void ? () => void : (observableOrValue: O | Observable<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>;
+    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

@@ -0,0 +1,72 @@
+import { Observable, Subscription } from 'rxjs';
+import { Provider, Type } from '@angular/core';
+import { LockSet } 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 * as i0 from "@angular/core";
+/**
+ * Source that provides a ActionContextStore observable.
+ */
+export declare abstract class ActionContextStoreSource<T = any, O = any> {
+    /**
+     * Observable referencing the ActionContextStore.
+     *
+     * This observable by design is pre-filtered to not return null values.
+     */
+    abstract readonly store$: Observable<ActionContextStore<T, O>>;
+}
+/**
+ * Secondary source. Used by DbNgxActionContextComponent to find secondary sources.
+ */
+export declare abstract class SecondaryActionContextStoreSource<T = any, O = any> extends ActionContextStoreSource<T, O> {
+}
+export declare function actionContextStoreSourcePipe<T, O>(obs: Observable<Maybe<ActionContextStore<T, O>>>): Observable<ActionContextStore<T, O>>;
+export declare type PipeActionStoreFunction<R, T, O> = (store: ActionContextStore<T, O>) => Observable<R>;
+export declare function pipeActionStore<R = any, T = any, O = any>(source: ActionContextStoreSource<T, O>, pipeFn: PipeActionStoreFunction<R, T, O>): Observable<R>;
+export declare type UseActionStoreFunction<T, O> = (store: ActionContextStore<T, O>) => void;
+/**
+ * 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 {
+    readonly source: ActionContextStoreSource<T, O>;
+    readonly lockSet: LockSet;
+    constructor(source: ActionContextStoreSource<T, O>);
+    ngOnDestroy(): void;
+    get store$(): Observable<ActionContextStore<T, O>>;
+    pipeStore<R>(pipeFn: PipeActionStoreFunction<R, T, O>): Observable<R>;
+    useStore(useFn: UseActionStoreFunction<T, O>): Subscription;
+    get state$(): Observable<ActionContextState<T, O>>;
+    get triggered$(): Observable<boolean>;
+    get valueReady$(): Observable<T>;
+    get success$(): Observable<O>;
+    get error$(): Observable<Maybe<ReadableError>>;
+    get rejected$(): Observable<Maybe<ReadableError>>;
+    get isModified$(): Observable<boolean>;
+    get isModifiedAndCanTriggerUpdates$(): Observable<boolean>;
+    get isModifiedAndCanTrigger$(): Observable<boolean>;
+    get actionState$(): Observable<ActionState>;
+    get isWorking$(): Observable<boolean>;
+    get isSuccess$(): Observable<boolean>;
+    get isDisabled$(): Observable<boolean>;
+    get errorCountSinceLastSuccess$(): Observable<number>;
+    enable(key?: ActionDisabledKey, enable?: boolean): void;
+    disable(key?: ActionDisabledKey, disable?: boolean): void;
+    setIsModified(isModified?: boolean | Observable<boolean> | Observable<void>): void;
+    trigger(): void;
+    readyValue(value: Maybe<T | Observable<T>>): void;
+    startWorking(): void;
+    reject(error: Maybe<ReadableError | Observable<ReadableError>>): void;
+    success(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>;
+}
+export declare const actionContextStoreSourceInstanceFactory: (source: ActionContextStoreSource) => ActionContextStoreSourceInstance<any, any>;
+/**
+ * Provides an ActionContextStoreSource, as well as an ActionContextStoreSourceInstance.
+ */
+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

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

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

@@ -0,0 +1,54 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { AbstractSubscriptionDirective } from '../../../subscription';
+import { Observable } from 'rxjs';
+import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { Maybe } from '@dereekb/util';
+import * as i0 from "@angular/core";
+/**
+ * Extension of DbNgxActionTransitionSafetyDirective that automatically triggers the action periodically when it is in a modified state.
+ */
+export declare class DbNgxActionAutoTriggerDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+    readonly source: ActionContextStoreSourceInstance<T, O>;
+    private _triggerEnabled;
+    /**
+     * How much to throttle the auto-triggering.
+     */
+    get triggerEnabled(): boolean;
+    set triggerEnabled(triggerEnabled: 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: boolean);
+    /**
+     * Optional input to override both triggerDebounce and triggerThrottle to be 0.
+     *
+     * Used in forms that generally return a single value.
+     */
+    set instantTrigger(instantTrigger: boolean);
+    get triggerLimit(): Maybe<number>;
+    set triggerLimit(triggerLimit: Maybe<number>);
+    private readonly _triggerLimit;
+    private readonly _trigger;
+    private _triggerCount;
+    readonly _errorCount$: Observable<number>;
+    readonly _triggerCount$: Observable<number>;
+    /**
+     * Observable for the trigger mechanism.
+     */
+    readonly triggerCount$: Observable<number>;
+    private readonly _isTriggerLimited$;
+    readonly isTriggerLimited$: Observable<boolean>;
+    readonly trigger$: Observable<void>;
+    constructor(source: ActionContextStoreSourceInstance<T, O>);
+    get isEnabled(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionAutoTriggerDirective<any, any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionAutoTriggerDirective<any, any>, "[dbxActionAutoTrigger]", never, { "triggerEnabled": "dbxActionAutoTrigger"; "triggerDebounce": "triggerDebounce"; "triggerThrottle": "triggerThrottle"; "triggerErrorThrottle": "triggerErrorThrottle"; "fastTrigger": "fastTrigger"; "instantTrigger": "instantTrigger"; "triggerLimit": "triggerLimit"; }, {}, never>;
+}

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

@@ -0,0 +1,25 @@
+import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { OnInit } from '@angular/core';
+import { Observable } from 'rxjs';
+import { OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare type DbNgxActionAutoTriggerIsModifiedFn<T> = (value: T) => Observable<boolean>;
+/**
+ * Directive that watches an observable for changes and sets the new value and modified states as necessary.
+ */
+export declare class DbNgxActionAutoTriggerValueDirective<T, O> implements OnInit, OnDestroy {
+    readonly source: ActionContextStoreSourceInstance<T, O>;
+    private _valueObs;
+    private _isModifiedFn;
+    private _modifiedSub;
+    private _triggerSub;
+    set dbxActionAutoTriggerValue(dbxActionAutoTriggerValue: Observable<T>);
+    set dbxActionAutoTriggerModifiedNonEmptyValue(requireNonEmpty: boolean);
+    set dbxActionAutoTriggerModified(dbxActionAutoTriggerModified: DbNgxActionAutoTriggerIsModifiedFn<T>);
+    readonly modifiedValue$: Observable<[boolean, T]>;
+    constructor(source: ActionContextStoreSourceInstance<T, O>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionAutoTriggerValueDirective<any, any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionAutoTriggerValueDirective<any, any>, "[dbxActionAutoTriggerValue]", never, { "dbxActionAutoTriggerValue": "dbxActionAutoTriggerValue"; "dbxActionAutoTriggerModifiedNonEmptyValue": "dbxActionAutoTriggerModifiedNonEmptyValue"; "dbxActionAutoTriggerModified": "dbxActionAutoTriggerModified"; }, {}, never>;
+}

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

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

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

@@ -0,0 +1,6 @@
+import { DbNgxActionContextDirective } from './action.directive';
+import * as i0 from "@angular/core";
+export declare class DbNgxActionComponent<T = any, O = any> extends DbNgxActionContextDirective<T, O> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbNgxActionComponent<any, any>, "dbx-action", ["action"], {}, {}, never, ["*"]>;
+}

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

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

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

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

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

@@ -0,0 +1,3 @@
+export * from './action.component';
+export * from './action.directive';
+export * from './action.source.directive';

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

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

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

@@ -0,0 +1 @@
+export * from './action.logger.directive';

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

@@ -0,0 +1,5 @@
+export * from './auto';
+export * from './context';
+export * from './debug';
+export * from './map';
+export * from './state';

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

@@ -0,0 +1,13 @@
+import { ActionContextStoreSource } from '../../action.store.source';
+export declare type ActionKey = string;
+/**
+ * Map that returns sources for ActionKey values.
+ */
+export declare abstract class ActionContextStoreSourceMap<T = any, O = any> {
+    /**
+     * Returns a ActionContextStoreSource for the input action key.
+     *
+     * @param key Action key to retrieve the source for.
+     */
+    abstract sourceForKey(key: ActionKey): ActionContextStoreSource<T, O>;
+}

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

@@ -0,0 +1,35 @@
+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 * 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 DbNgxActionContextMapDirective implements ActionContextStoreSourceMap, OnDestroy {
+    private readonly _map;
+    readonly map$: Observable<Map<string, ActionContextStoreSource<any, any>>>;
+    readonly areAnyWorking$: Observable<boolean>;
+    constructor();
+    get map(): Map<ActionKey, ActionContextStoreSource>;
+    sourceForKey(key: ActionKey): ActionContextStoreSource<any, any>;
+    addStoreSource(key: ActionKey, source: ActionContextStoreSource): void;
+    removeStore(key: ActionKey): void;
+    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<DbNgxActionContextMapDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionContextMapDirective, "[dbxActionContextMap]", ["actionMap"], {}, {}, never>;
+}
+export declare class DbNgxActionContextMapDirectiveSourceInstance implements ActionContextStoreSource {
+    private readonly parent;
+    readonly key: ActionKey;
+    readonly _source$: Observable<ActionContextStoreSource<any, any> | undefined>;
+    readonly _store$: Observable<ActionContextStore<any, any> | undefined>;
+    readonly store$: Observable<ActionContextStore<any, any>>;
+    constructor(parent: DbNgxActionContextMapDirective, key: ActionKey);
+}

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

@@ -0,0 +1,20 @@
+import { OnDestroy } from '@angular/core';
+import { Maybe } from '@dereekb/util';
+import { ActionKey } from './action.map';
+import { SecondaryActionContextStoreSource } from '../../action.store.source';
+import { DbNgxActionContextMapDirective } from './action.map.directive';
+import * as i0 from "@angular/core";
+/**
+ * Directive that provides a ActionContextStoreSource using the input key and DbNgxActionContextMapDirective.
+ */
+export declare class DbNgxActionFromMapDirective implements SecondaryActionContextStoreSource, OnDestroy {
+    private readonly _map;
+    private _key;
+    readonly store$: import("rxjs").Observable<import("@dereekb/dbx-core").ActionContextStore<any, any>>;
+    constructor(_map: DbNgxActionContextMapDirective);
+    ngOnDestroy(): void;
+    get key(): Maybe<ActionKey>;
+    set key(key: Maybe<ActionKey>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionFromMapDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionFromMapDirective, "[dbxActionFromMap]", never, { "key": "dbxActionFromMap"; }, {}, never>;
+}

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

@@ -0,0 +1,20 @@
+import { OnDestroy } from '@angular/core';
+import { ActionContextStoreSource } from '../../action.store.source';
+import { DbNgxActionContextMapDirective } from './action.map.directive';
+import { ActionKey } from './action.map';
+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 DbNgxActionMapSourceDirective implements OnDestroy {
+    readonly source: ActionContextStoreSource;
+    private readonly _map;
+    private _key;
+    constructor(source: ActionContextStoreSource, _map: DbNgxActionContextMapDirective);
+    ngOnDestroy(): void;
+    set key(key: ActionKey);
+    private _addToStore;
+    private _removeFromToStore;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionMapSourceDirective, [{ host: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionMapSourceDirective, "[dbxActionMapSource]", never, { "key": "dbxActionMapSource"; }, {}, never>;
+}

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

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

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

@@ -0,0 +1,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.working.disable.directive';

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

@@ -0,0 +1,20 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { AbstractSubscriptionDirective } from '../../../subscription';
+import { ActionContextStoreSourceInstance } 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 DbNgxActionDisabledDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+    readonly source: ActionContextStoreSourceInstance<T, O>;
+    private _disabled;
+    readonly disabled$: import("rxjs").Observable<boolean>;
+    constructor(source: ActionContextStoreSourceInstance<T, O>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get disabled(): boolean;
+    set disabled(disabled: boolean);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionDisabledDirective<any, any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionDisabledDirective<any, any>, "[dbxActionDisabled]", never, { "disabled": "dbxActionDisabled"; }, {}, never>;
+}

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

@@ -0,0 +1,16 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { AbstractSubscriptionDirective } from '../../../subscription';
+import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import * as i0 from "@angular/core";
+export declare const APP_ACTION_DISABLED_UNTIL_MODIFIED_DIRECTIVE_KEY = "dbx_action_is_not_modified";
+/**
+ * Directive that sets the disabled state based on the current isModified state.
+ */
+export declare class DbNgxActionDisabledUntilModifiedDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+    readonly source: ActionContextStoreSourceInstance<T, O>;
+    constructor(source: ActionContextStoreSourceInstance<T, O>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionDisabledUntilModifiedDirective<any, any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionDisabledUntilModifiedDirective<any, any>, "[dbxActionDisabledUntilModified]", never, {}, {}, never>;
+}

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

@@ -0,0 +1,22 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { AbstractSubscriptionDirective } from '../../../subscription';
+import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { HandleActionFunction } from '../../action.handler';
+import { Maybe } from '@dereekb/util';
+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 DbNgxActionHandlerDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+    readonly source: ActionContextStoreSourceInstance<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>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionHandlerDirective<any, any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionHandlerDirective<any, any>, "[dbxActionHandler]", never, { "handlerFunction": "dbxActionHandler"; }, {}, never>;
+}