@dereekb/dbx-core 0.0.1

package/README.md

@@ -0,0 +1,7 @@
+# dbx-core
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test dbx-core` to execute the unit tests.

package/dereekb-dbx-core.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@dereekb/dbx-core" />
+export * from './index';

package/esm2020/dereekb-dbx-core.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVyZWVrYi1kYngtY29yZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL2RieC1jb3JlL3NyYy9kZXJlZWtiLWRieC1jb3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2020/index.mjs

@@ -0,0 +1,2 @@
+export * from './lib';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtY29yZS9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxPQUFPLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYic7XG4iXX0=

package/esm2020/lib/action/action.handler.mjs

@@ -0,0 +1,140 @@
+import { BehaviorSubject, isObservable, of } from 'rxjs';
+import { first } from 'rxjs/operators';
+/**
+ * WorkHandlerContextDelegate implementation using an ActionContextStoreSourceInstance.
+ */
+export class WorkHandlerContextSourceDelegate {
+    constructor(source) {
+        this.source = source;
+    }
+    startWorking() {
+        this.source.startWorking();
+    }
+    success(result) {
+        this.source.success(result);
+    }
+    reject(error) {
+        this.source.reject(error);
+    }
+}
+/**
+ * Used by DbNgxActionHandlerDirective when handling a function.
+ */
+export class WorkHandlerContext {
+    constructor(value, delegate) {
+        this.value = value;
+        this.delegate = delegate;
+        this._done = false;
+        this._doneActionBegan = false;
+        this._actionBegan = new BehaviorSubject(false);
+        this._isComplete = new BehaviorSubject(false);
+        // Schedule to cleanup self once isComplete is true.
+        this._isComplete.subscribe((done) => {
+            if (done) {
+                this.destroy();
+            }
+        });
+    }
+    get actionBegan() {
+        return this._doneActionBegan ?? this._actionBegan.value;
+    }
+    get actionBegan$() {
+        return this._done ? of(this._doneActionBegan) : this._actionBegan.asObservable();
+    }
+    get isComplete() {
+        return this._done || this._isComplete.value;
+    }
+    get isComplete$() {
+        return this._done ? of(true) : this._isComplete.asObservable();
+    }
+    /**
+     * Begins working using an observable.
+     */
+    startWorkingWithObservable(actionObs) {
+        this.startWorking();
+        actionObs.pipe(first()).subscribe((actionResult) => {
+            this.success(actionResult);
+        }, (error) => {
+            const message = error.message ?? error.code ?? undefined;
+            this.reject((message) ? ({ message }) : undefined);
+        });
+    }
+    /**
+     * Notifies the system that the action has begun.
+     */
+    startWorking() {
+        this._setWorking();
+        this.delegate.startWorking();
+    }
+    /**
+     * Sets success on the action.
+     */
+    success(result) {
+        this._setComplete();
+        this.delegate.success(result);
+    }
+    /**
+     * Sets rejected on the action.
+     */
+    reject(error) {
+        this._setComplete();
+        this.delegate.reject(error);
+    }
+    destroy() {
+        this._doneActionBegan = this.actionBegan;
+        this._done = true;
+        // Delay to prevent error.
+        setTimeout(() => {
+            this._actionBegan.complete();
+            this._isComplete.complete();
+        });
+    }
+    _setWorking() {
+        if (this.actionBegan) {
+            throw new Error('Action already has been triggered for this context.');
+        }
+        this._actionBegan.next(true);
+    }
+    _setComplete() {
+        if (this.isComplete) {
+            throw new Error('Action has already been marked as completed.');
+        }
+        this._isComplete.next(true);
+    }
+}
+/**
+ * Creates a function that uses a provider to always handle new values.
+ */
+export function handleWorkValueReadyWithConfigFn(providerFn) {
+    return (value) => {
+        const config = providerFn(value);
+        return handleWorkValueReadyFn(config)(value);
+    };
+}
+/**
+ * Creates a function that handles the incoming value and creates a WorkHandlerContext.
+ */
+export function handleWorkValueReadyFn({ handlerFunction, delegate }) {
+    return (value) => {
+        const handler = new WorkHandlerContext(value, delegate);
+        let fnResult;
+        try {
+            fnResult = handlerFunction(value, handler);
+        }
+        catch (e) {
+            console.error('Action encountered an unexpected error.', e);
+            handler.reject(e);
+            return;
+        }
+        if (!handler.isComplete) {
+            if (fnResult && isObservable(fnResult)) {
+                if (handler.actionBegan) {
+                    throw new Error('Action already marked as begun from handlerFunction result. Either return an observable or use the handler directly.');
+                }
+                handler.startWorkingWithObservable(fnResult);
+            }
+        }
+        return handler;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action.handler.js","sourceRoot":"","sources":["../../../../../../packages/dbx-core/src/lib/action/action.handler.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject, isObservable, Observable, of } from 'rxjs';\nimport { first } from 'rxjs/operators';\nimport { ActionContextStoreSourceInstance } from './action.store.source';\nimport { Maybe, Destroyable } from '@dereekb/util';\n\nexport interface WorkHandlerContextDelegate<O = any> {\n  startWorking(): void;\n  success(result?: Maybe<O>): void;\n  reject(error?: Maybe<any>): void;\n}\n\n/**\n * WorkHandlerContextDelegate implementation using an ActionContextStoreSourceInstance.\n */\nexport class WorkHandlerContextSourceDelegate<T = any, O = any> implements WorkHandlerContextDelegate<O> {\n\n  constructor(readonly source: ActionContextStoreSourceInstance<T, O>) { }\n\n  startWorking(): void {\n    this.source.startWorking();\n  }\n\n  success(result: O): void {\n    this.source.success(result);\n  }\n\n  reject(error: any): void {\n    this.source.reject(error);\n  }\n\n}\n\n/**\n * Used by DbNgxActionHandlerDirective when handling a function.\n */\nexport class WorkHandlerContext<T = any, O = any> implements Destroyable {\n\n  private _done = false;\n  private _doneActionBegan = false;\n\n  private _actionBegan = new BehaviorSubject<boolean>(false);\n  private _isComplete = new BehaviorSubject<boolean>(false);\n\n  constructor(public readonly value: T, readonly delegate: WorkHandlerContextDelegate<O>) {\n    // Schedule to cleanup self once isComplete is true.\n    this._isComplete.subscribe((done) => {\n      if (done) {\n        this.destroy();\n      }\n    });\n  }\n\n  get actionBegan(): boolean {\n    return this._doneActionBegan ?? this._actionBegan.value;\n  }\n\n  get actionBegan$(): Observable<boolean> {\n    return this._done ? of(this._doneActionBegan) : this._actionBegan.asObservable();\n  }\n\n  get isComplete(): boolean {\n    return this._done || this._isComplete.value;\n  }\n\n  get isComplete$(): Observable<boolean> {\n    return this._done ? of(true) : this._isComplete.asObservable();\n  }\n\n  /**\n   * Begins working using an observable.\n   */\n  startWorkingWithObservable(actionObs: Observable<O>): void {\n    this.startWorking();\n    actionObs.pipe(first()).subscribe((actionResult: O) => {\n      this.success(actionResult);\n    }, (error: any) => {\n      const message = error.message ?? error.code ?? undefined;\n      this.reject((message) ? ({ message }) : undefined);\n    });\n  }\n\n  /**\n   * Notifies the system that the action has begun.\n   */\n  startWorking(): void {\n    this._setWorking();\n    this.delegate.startWorking();\n  }\n\n  /**\n   * Sets success on the action.\n   */\n  success(result?: O): void {\n    this._setComplete();\n    this.delegate.success(result);\n  }\n\n  /**\n   * Sets rejected on the action.\n   */\n  reject(error?: any): void {\n    this._setComplete();\n    this.delegate.reject(error);\n  }\n\n  destroy(): void {\n    this._doneActionBegan = this.actionBegan;\n    this._done = true;\n\n    // Delay to prevent error.\n    setTimeout(() => {\n      this._actionBegan.complete();\n      this._isComplete.complete();\n    });\n  }\n\n  private _setWorking(): void {\n    if (this.actionBegan) {\n      throw new Error('Action already has been triggered for this context.');\n    }\n\n    this._actionBegan.next(true);\n  }\n\n  private _setComplete(): void {\n    if (this.isComplete) {\n      throw new Error('Action has already been marked as completed.');\n    }\n\n    this._isComplete.next(true);\n  }\n\n}\n\nexport type HandleActionFunctionConfigFn<T, O> = (value: T) => HandleWorkValueReadyConfig<T, O>;\n\n/**\n * Creates a function that uses a provider to always handle new values.\n */\nexport function handleWorkValueReadyWithConfigFn<T, O>(providerFn: HandleActionFunctionConfigFn<T, O>): (value: T) => Maybe<WorkHandlerContext<T, O>> {\n  return (value) => {\n    const config: HandleWorkValueReadyConfig<T, O> = providerFn(value);\n    return handleWorkValueReadyFn(config)(value);\n  };\n}\n\n/**\n * Config for handleWorkValueReadyFn().\n */\nexport interface HandleWorkValueReadyConfig<T, O> {\n  handlerFunction: HandleActionFunction<T, O>;\n  delegate: WorkHandlerContextDelegate<O>;\n}\n\n/**\n * Performs the action. Can either return an observable that will use the handler, or can use the handler itself.\n */\nexport type HandleActionFunction<T = any, O = any> = (value: T, context: WorkHandlerContext<T, O>) => Observable<O> | void;\n\n/**\n * Creates a function that handles the incoming value and creates a WorkHandlerContext.\n */\nexport function handleWorkValueReadyFn<T, O>({ handlerFunction, delegate }: HandleWorkValueReadyConfig<T, O>): (value: T) => Maybe<WorkHandlerContext<T, O>> {\n  return (value: T) => {\n    const handler = new WorkHandlerContext<T, O>(value, delegate);\n    let fnResult: void | Observable<O>;\n\n    try {\n      fnResult = handlerFunction(value, handler);\n    } catch (e: any) {\n      console.error('Action encountered an unexpected error.', e);\n      handler.reject(e);\n      return;\n    }\n\n    if (!handler.isComplete) {\n      if (fnResult && isObservable(fnResult)) {\n        if (handler.actionBegan) {\n          throw new Error('Action already marked as begun from handlerFunction result. Either return an observable or use the handler directly.');\n        }\n\n        handler.startWorkingWithObservable(fnResult);\n      }\n    }\n\n    return handler;\n  };\n}\n"]}

package/esm2020/lib/action/action.holder.mjs

@@ -0,0 +1,50 @@
+import { of } from 'rxjs';
+import { ActionContextStoreSourceInstance } from './action.store.source';
+import { ActionContextStore } from './action.store';
+/**
+ * Abstract class that can either use SecondaryActionContextStoreSource or create it's own.
+ */
+export class ActionContextBaseSource {
+    constructor(inputSource) {
+        this.inputSource = inputSource;
+        if (this.inputSource) {
+            this._store$ = this.inputSource.store$;
+        }
+        else {
+            this._store = new ActionContextStore();
+            this._store$ = of(this._store);
+        }
+        this._instance = new ActionContextStoreSourceInstance(this);
+        this.isModified$ = this._instance.isModified$;
+        this.triggered$ = this._instance.triggered$;
+        this.success$ = this._instance.success$;
+    }
+    destroy() {
+        if (this._store) {
+            this._store.ngOnDestroy();
+            this._instance.ngOnDestroy();
+        }
+    }
+    get lockSet() {
+        return this._instance.lockSet;
+    }
+    get sourceInstance() {
+        return this._instance;
+    }
+    get store$() {
+        return this._store$;
+    }
+    /**
+     * Use to trigger the action directly.
+     */
+    trigger() {
+        this._instance.trigger();
+    }
+    readyValue(value) {
+        this._instance.readyValue(value);
+    }
+    reset() {
+        this._instance.reset();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/action/action.machine.mjs

@@ -0,0 +1,37 @@
+import { delay, first } from 'rxjs/operators';
+import { handleWorkValueReadyFn, WorkHandlerContextSourceDelegate } from './action.handler';
+import { ActionContextBaseSource } from './action.holder';
+import { SubscriptionObject } from '@dereekb/rxjs';
+/**
+ * Configurable machine that handles components of the ActionContextStore lifecycle.
+ */
+export class ActionContextMachine extends ActionContextBaseSource {
+    constructor(config, source) {
+        super(source);
+        this.config = config;
+        this._isShutdown = true;
+        this._handleValueReadySub = new SubscriptionObject();
+        // Handle Value Ready
+        this._handleValueReadySub.subscription = this.sourceInstance.valueReady$.subscribe((value) => {
+            handleWorkValueReadyFn({ handlerFunction: config.handleValueReady, delegate: new WorkHandlerContextSourceDelegate(this.sourceInstance) })(value);
+        });
+        // If this is a one-time use, then destroy it after the first success comes through.
+        if (this.config.oneTimeUse) {
+            this.sourceInstance.success$.pipe(first(), delay(1000)).subscribe(() => {
+                this.destroy();
+            });
+        }
+        if (this.config.onSuccess) {
+            this.sourceInstance.success$.subscribe(this.config.onSuccess);
+        }
+    }
+    destroy() {
+        super.destroy();
+        this._handleValueReadySub.destroy();
+        this._isShutdown = true;
+    }
+    get isShutdown() {
+        return this._isShutdown;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/action/action.mjs

@@ -0,0 +1,51 @@
+/**
+ * Used by ActionContextState to denote what state the action is in.
+ */
+export var ActionState;
+(function (ActionState) {
+    /**
+     * No action in progress. Waiting for the trigger.
+     */
+    ActionState["Idle"] = "idle";
+    /**
+     * Idle state that can be set to show that the source is not yet ready.
+     */
+    ActionState["Disabled"] = "disabled";
+    /**
+     * The action was triggered. We wait (and allow) the value to be updated.
+     */
+    ActionState["Triggered"] = "triggered";
+    /**
+     * The trigger was accepted and the value is updated. It should begin working immediately.
+     *
+     * ValueReady cannot be set until triggered is set.
+     */
+    ActionState["ValueReady"] = "valueReady";
+    /**
+     * The action is in progress.
+     */
+    ActionState["Working"] = "working";
+    /**
+     * The trigger, action, or value was rejected due to an error or other issue.
+     *
+     * An error may be specified optionally.
+     */
+    ActionState["Rejected"] = "rejected";
+    /**
+     * The action was successful.
+     */
+    ActionState["Success"] = "success";
+})(ActionState || (ActionState = {}));
+export const DEFAULT_ACTION_DISABLED_KEY = 'default';
+export function isIdleActionState(actionState) {
+    switch (actionState) {
+        case ActionState.Idle:
+        case ActionState.Disabled:
+        case ActionState.Rejected:
+        case ActionState.Success:
+            return true;
+        default:
+            return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/action/action.module.mjs

@@ -0,0 +1,38 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { DbNgxActionComponent, DbNgxActionContextDirective, DbNgxActionContextMapDirective, DbNgxActionFromMapDirective, DbNgxActionMapSourceDirective, DbNgxActionMapWorkingDisableDirective, DbNgxActionSourceDirective, DbNgxActionHandlerDirective, DbNgxActionDisabledDirective, DbNgxActionDisabledUntilModifiedDirective, DbNgxActionAutoTriggerDirective, DbNgxActionAutoTriggerValueDirective, DbNgxActionAutoModifyDirective, DbNgxActionValueDirective, DbNgxActionContextLoggerDirective, DbNgxActionSuccessComponent, DbNgxActionSuccessDirective, DbNgxActionWorkingComponent } from './directive';
+import * as i0 from "@angular/core";
+export class DbNgxCoreActionModule {
+}
+DbNgxCoreActionModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreActionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DbNgxCoreActionModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreActionModule, declarations: [DbNgxActionComponent, DbNgxActionContextDirective, DbNgxActionContextMapDirective, DbNgxActionFromMapDirective, DbNgxActionMapSourceDirective,
+        DbNgxActionMapWorkingDisableDirective, DbNgxActionSourceDirective, DbNgxActionHandlerDirective, DbNgxActionDisabledDirective, DbNgxActionDisabledUntilModifiedDirective,
+        DbNgxActionAutoTriggerDirective, DbNgxActionAutoTriggerValueDirective, DbNgxActionAutoModifyDirective, DbNgxActionValueDirective, DbNgxActionContextLoggerDirective,
+        DbNgxActionSuccessComponent, DbNgxActionSuccessDirective, DbNgxActionWorkingComponent], imports: [CommonModule], exports: [DbNgxActionComponent, DbNgxActionContextDirective, DbNgxActionContextMapDirective, DbNgxActionFromMapDirective, DbNgxActionMapSourceDirective,
+        DbNgxActionMapWorkingDisableDirective, DbNgxActionSourceDirective, DbNgxActionHandlerDirective, DbNgxActionDisabledDirective, DbNgxActionDisabledUntilModifiedDirective,
+        DbNgxActionAutoTriggerDirective, DbNgxActionAutoTriggerValueDirective, DbNgxActionAutoModifyDirective, DbNgxActionValueDirective, DbNgxActionContextLoggerDirective,
+        DbNgxActionSuccessComponent, DbNgxActionSuccessDirective, DbNgxActionWorkingComponent] });
+DbNgxCoreActionModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreActionModule, imports: [[
+            CommonModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreActionModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule
+                    ],
+                    declarations: [
+                        DbNgxActionComponent, DbNgxActionContextDirective, DbNgxActionContextMapDirective, DbNgxActionFromMapDirective, DbNgxActionMapSourceDirective,
+                        DbNgxActionMapWorkingDisableDirective, DbNgxActionSourceDirective, DbNgxActionHandlerDirective, DbNgxActionDisabledDirective, DbNgxActionDisabledUntilModifiedDirective,
+                        DbNgxActionAutoTriggerDirective, DbNgxActionAutoTriggerValueDirective, DbNgxActionAutoModifyDirective, DbNgxActionValueDirective, DbNgxActionContextLoggerDirective,
+                        DbNgxActionSuccessComponent, DbNgxActionSuccessDirective, DbNgxActionWorkingComponent
+                    ],
+                    exports: [
+                        DbNgxActionComponent, DbNgxActionContextDirective, DbNgxActionContextMapDirective, DbNgxActionFromMapDirective, DbNgxActionMapSourceDirective,
+                        DbNgxActionMapWorkingDisableDirective, DbNgxActionSourceDirective, DbNgxActionHandlerDirective, DbNgxActionDisabledDirective, DbNgxActionDisabledUntilModifiedDirective,
+                        DbNgxActionAutoTriggerDirective, DbNgxActionAutoTriggerValueDirective, DbNgxActionAutoModifyDirective, DbNgxActionValueDirective, DbNgxActionContextLoggerDirective,
+                        DbNgxActionSuccessComponent, DbNgxActionSuccessDirective, DbNgxActionWorkingComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/action/action.store.mjs

@@ -0,0 +1,188 @@
+import { Injectable } from '@angular/core';
+import { ComponentStore } from '@ngrx/component-store';
+import { distinctUntilChanged, filter, map, shareReplay, switchMap, startWith } from 'rxjs/operators';
+import { BooleanStringKeyArrayUtilityInstance } from '@dereekb/util';
+import { filterMaybe, LockSet, scanCount } from '@dereekb/rxjs';
+import { ActionState, DEFAULT_ACTION_DISABLED_KEY, isIdleActionState } from './action';
+import * as i0 from "@angular/core";
+export function isActionContextEnabled(state) {
+    return BooleanStringKeyArrayUtilityInstance.isFalse(state.disabled);
+}
+export function isActionContextDisabled(state) {
+    return BooleanStringKeyArrayUtilityInstance.isTrue(state.disabled);
+}
+export function isDisabledActionContextState(state) {
+    return isIdleActionState(state.actionState) && isActionContextDisabled(state);
+}
+export function isWorkingActionState(actionState) {
+    return !isIdleActionState(actionState);
+}
+export function canTriggerActionState(actionState) {
+    return actionState !== ActionState.Disabled && isIdleActionState(actionState);
+}
+export function canTriggerAction(state) {
+    return isActionContextEnabled(state) && isIdleActionState(state.actionState);
+}
+export function canReadyValue(state) {
+    return state.actionState === ActionState.Triggered;
+}
+export function actionContextIsModifiedAndCanTrigger(state) {
+    // console.log('check: ', state, state.isModified, canTriggerAction(state));
+    return state.isModified && canTriggerAction(state);
+}
+export function actionContextHasNoErrorAndIsModifiedAndCanTrigger(state) {
+    return !state.error && actionContextIsModifiedAndCanTrigger(state);
+}
+const INITIAL_STATE = {
+    isModified: false,
+    actionState: ActionState.Idle
+};
+export class ActionContextStore extends ComponentStore {
+    constructor() {
+        super({ ...INITIAL_STATE });
+        this.lockSet = new LockSet();
+        // MARK: Accessors
+        this.actionState$ = this.state$.pipe(map(x => isDisabledActionContextState(x) ? ActionState.Disabled : x.actionState), shareReplay(1));
+        /**
+         * Returns the current disabled reasons.
+         */
+        this.disabled$ = this.state$.pipe(map(x => [...x.disabled ?? []]), distinctUntilChanged(), shareReplay(1));
+        /**
+         * Maps the current state to true or not when the action state changes to/from disabled.
+         */
+        this.isDisabled$ = this.state$.pipe(map(isDisabledActionContextState), distinctUntilChanged(), shareReplay(1));
+        /**
+         * Pipes when idle but modified.
+         */
+        this.isModified$ = this.afterDistinctBoolean(x => x.isModified);
+        /**
+         * Pipes true when triggered.
+         */
+        this.triggered$ = this.afterDistinctActionState(ActionState.Triggered, () => true);
+        /**
+         * Pipes the readied value on ValueReady.
+         */
+        this.valueReady$ = this.afterDistinctActionState(ActionState.ValueReady, x => x.value);
+        /**
+         * Pipes the error on the rejection state.
+         */
+        this.rejected$ = this.afterDistinctActionState(ActionState.Rejected, x => x.error);
+        /**
+         * Pipes the result when the ActionState becomes working.
+         */
+        this.working$ = this.afterDistinctActionState(ActionState.Working, () => true);
+        /**
+         * Whether or not it is currently in a working state.
+         */
+        this.isWorking$ = this.afterDistinctBoolean(x => isWorkingActionState(x.actionState));
+        /**
+         * Pipes the current error.
+         */
+        this.error$ = this.state$.pipe(map(x => x.error), distinctUntilChanged(), shareReplay(1));
+        /**
+         * Pipes the result when the ActionState becomes success.
+         */
+        this.success$ = this.afterDistinctActionState(ActionState.Success, x => x.result);
+        /**
+         * Whether or not it is currently in a success state.
+         */
+        this.isSuccess$ = this.afterDistinctBoolean(x => x.actionState === ActionState.Success);
+        /**
+         * Number of errors since last success.
+         */
+        this.errorCountSinceLastSuccess$ = this.isSuccess$.pipe(startWith(false), distinctUntilChanged(), switchMap(() => this.error$.pipe(filterMaybe(), scanCount(), startWith(0))), shareReplay(1));
+        /**
+         * Whether or not the state can be triggered.
+         */
+        this.canTrigger$ = this.state$.pipe(map(canTriggerAction), distinctUntilChanged(), shareReplay(1));
+        /**
+         * Pipe that maps whether or not this is modified and can be triggered.
+         *
+         * Updates every state update instead of when the value changes.
+         */
+        this.isModifiedAndCanTriggerUpdates$ = this.state$.pipe(map((x) => actionContextIsModifiedAndCanTrigger(x), shareReplay(1)));
+        /**
+         * Whether or not it can be triggered and modified.
+         */
+        this.isModifiedAndCanTrigger$ = this.isModifiedAndCanTriggerUpdates$.pipe(distinctUntilChanged());
+        this.hasNoErrorAndIsModifiedAndCanTrigger$ = this.state$.pipe(map((x) => actionContextHasNoErrorAndIsModifiedAndCanTrigger(x)), distinctUntilChanged(), shareReplay(1));
+        // MARK: State Changes
+        /**
+         * Adds a disabled reason.
+         */
+        this.disable = this.updater((state, key) => ({
+            ...state,
+            disabled: BooleanStringKeyArrayUtilityInstance.insert(state.disabled, (key ?? DEFAULT_ACTION_DISABLED_KEY))
+        }));
+        /**
+         * Removes a disabled reason.
+         */
+        this.enable = this.updater((state, key) => ({
+            ...state,
+            disabled: BooleanStringKeyArrayUtilityInstance.remove(state.disabled, (key ?? DEFAULT_ACTION_DISABLED_KEY))
+        }));
+        /**
+         * Triggers the modified state, if not disabled.
+         */
+        this.setIsModified = this.updater((state, isModified) => ({
+            ...state,
+            actionState: (state.actionState === ActionState.Success) ? ActionState.Idle : state.actionState,
+            isModified: isModified ?? true
+        }));
+        /**
+         * 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.
+         */
+        this.trigger = this.updater((state) => canTriggerAction(state)
+            ? ({ isModified: state.isModified, actionState: ActionState.Triggered, error: state.error, value: undefined })
+            : state);
+        /**
+         * Updates the value, setting value ready. The current result is cleared.
+         */
+        this.readyValue = this.updater((state, value) => canReadyValue(state)
+            ? ({ ...state, actionState: ActionState.ValueReady, value, result: undefined })
+            : state);
+        /**
+         * Notifys the context that the action is in progress.
+         */
+        this.startWorking = this.updater((state) => ({ ...state, actionState: ActionState.Working }));
+        /**
+         * Triggers rejection of the action. The value is cleared.
+         */
+        this.reject = this.updater((state, error) => ({ isModified: state.isModified, actionState: ActionState.Rejected, error, errorCount: (state.errorCount ?? 0) + 1 }));
+        /**
+         * Updates the state to success, and optionally sets a result.
+         *
+         * Clears modified state, and any errors.
+         */
+        this.success = this.updater((state, result) => ({ isModified: false, actionState: ActionState.Success, value: state.value, result, error: undefined }));
+        /**
+         * Completely resets the store.
+         */
+        this.reset = this.updater((state) => ({ ...INITIAL_STATE }));
+        this.lockSet.addLock('working', this.isWorking$);
+    }
+    // MARK: Utility
+    afterDistinctBoolean(fromState) {
+        return this.state$.pipe(map(x => fromState(x)), distinctUntilChanged(), shareReplay(1));
+    }
+    afterDistinctActionState(actionState, fromState) {
+        return this.state$.pipe(map((x) => ([x, x.actionState])), distinctUntilChanged((a, b) => a?.[1] === b?.[1]), // Filter out when the state remains the same.
+        filter(([x, y]) => y === actionState), // Only pipe when the action state matches.
+        map(x => fromState(x[0])), shareReplay(1));
+    }
+    // MARK: Cleanup
+    ngOnDestroy() {
+        // Wait for any actions to complete before destroying.
+        this.lockSet.onNextUnlock(() => {
+            super.ngOnDestroy();
+        }, 2000);
+    }
+}
+ActionContextStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: ActionContextStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ActionContextStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: ActionContextStore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: ActionContextStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action.store.js","sourceRoot":"","sources":["../../../../../../packages/dbx-core/src/lib/action/action.store.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\nimport { ComponentStore } from '@ngrx/component-store';\nimport { Observable } from 'rxjs';\nimport { distinctUntilChanged, filter, map, shareReplay, switchMap, startWith } from 'rxjs/operators';\nimport { BooleanStringKeyArray, BooleanStringKeyArrayUtilityInstance, Maybe, ReadableError } from '@dereekb/util';\nimport { filterMaybe, LockSet, scanCount } from '@dereekb/rxjs';\nimport { ActionDisabledKey, ActionState, DEFAULT_ACTION_DISABLED_KEY, isIdleActionState } from './action';\n\nexport function isActionContextEnabled(state: ActionContextState): boolean {\n  return BooleanStringKeyArrayUtilityInstance.isFalse(state.disabled);\n}\n\nexport function isActionContextDisabled(state: ActionContextState): boolean {\n  return BooleanStringKeyArrayUtilityInstance.isTrue(state.disabled);\n}\n\nexport function isDisabledActionContextState(state: ActionContextState): boolean {\n  return isIdleActionState(state.actionState) && isActionContextDisabled(state);\n}\n\nexport function isWorkingActionState(actionState: ActionState): boolean {\n  return !isIdleActionState(actionState);\n}\n\nexport function canTriggerActionState(actionState: ActionState): boolean {\n  return actionState !== ActionState.Disabled && isIdleActionState(actionState);\n}\n\nexport function canTriggerAction(state: ActionContextState): boolean {\n  return isActionContextEnabled(state) && isIdleActionState(state.actionState);\n}\n\nexport function canReadyValue(state: ActionContextState): boolean {\n  return state.actionState === ActionState.Triggered;\n}\n\nexport function actionContextIsModifiedAndCanTrigger(state: ActionContextState): boolean {\n  // console.log('check: ', state, state.isModified, canTriggerAction(state));\n  return state.isModified && canTriggerAction(state);\n}\n\nexport function actionContextHasNoErrorAndIsModifiedAndCanTrigger(state: ActionContextState): boolean {\n  return !state.error && actionContextIsModifiedAndCanTrigger(state);\n}\n\nexport interface ActionContextState<T = any, O = any> {\n  actionState: ActionState;\n  isModified: boolean;\n  /**\n   * Value that is set after a triggered action.\n   */\n  value?: Maybe<T>;\n  result?: Maybe<O>;\n  error?: Maybe<ReadableError>;\n  /**\n   * Current disabled state.\n   */\n  disabled?: BooleanStringKeyArray;\n  /**\n   * Number of consecutive errors that have occured.\n   */\n  errorCount?: number;\n}\n\nconst INITIAL_STATE: ActionContextState = {\n  isModified: false,\n  actionState: ActionState.Idle\n};\n\n@Injectable()\nexport class ActionContextStore<T = any, O = any> extends ComponentStore<ActionContextState<T, O>> implements OnDestroy {\n\n  readonly lockSet = new LockSet();\n\n  constructor() {\n    super({ ...INITIAL_STATE });\n    this.lockSet.addLock('working', this.isWorking$);\n  }\n\n  // MARK: Accessors\n  readonly actionState$ = this.state$.pipe(map(x => isDisabledActionContextState(x) ? ActionState.Disabled : x.actionState), shareReplay(1));\n\n  /**\n   * Returns the current disabled reasons.\n   */\n  readonly disabled$ = this.state$.pipe(map(x => [...x.disabled ?? []]), distinctUntilChanged(), shareReplay(1));\n\n  /**\n   * Maps the current state to true or not when the action state changes to/from disabled.\n   */\n  readonly isDisabled$ = this.state$.pipe(map(isDisabledActionContextState), distinctUntilChanged(), shareReplay(1));\n\n  /**\n   * Pipes when idle but modified.\n   */\n  readonly isModified$ = this.afterDistinctBoolean(x => x.isModified);\n\n  /**\n   * Pipes true when triggered.\n   */\n  readonly triggered$ = this.afterDistinctActionState(ActionState.Triggered, () => true);\n\n  /**\n   * Pipes the readied value on ValueReady.\n   */\n  readonly valueReady$ = this.afterDistinctActionState(ActionState.ValueReady, x => x.value);\n\n  /**\n   * Pipes the error on the rejection state.\n   */\n  readonly rejected$ = this.afterDistinctActionState(ActionState.Rejected, x => x.error);\n\n  /**\n   * Pipes the result when the ActionState becomes working.\n   */\n  readonly working$ = this.afterDistinctActionState(ActionState.Working, () => true);\n\n  /**\n   * Whether or not it is currently in a working state.\n   */\n  readonly isWorking$ = this.afterDistinctBoolean(x => isWorkingActionState(x.actionState));\n\n  /**\n   * Pipes the current error.\n   */\n  readonly error$ = this.state$.pipe(map(x => x.error), distinctUntilChanged(), shareReplay(1));\n\n  /**\n   * Pipes the result when the ActionState becomes success.\n   */\n  readonly success$ = this.afterDistinctActionState(ActionState.Success, x => x.result);\n\n  /**\n   * Whether or not it is currently in a success state.\n   */\n  readonly isSuccess$ = this.afterDistinctBoolean(x => x.actionState === ActionState.Success);\n\n  /**\n   * Number of errors since last success.\n   */\n  readonly errorCountSinceLastSuccess$ = this.isSuccess$.pipe(\n    startWith(false),\n    distinctUntilChanged(),\n    switchMap(() => this.error$.pipe(filterMaybe(), scanCount(), startWith(0))),\n    shareReplay(1)\n  );\n\n  /**\n   * Whether or not the state can be triggered.\n   */\n  readonly canTrigger$ = this.state$.pipe(\n    map(canTriggerAction),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  /**\n   * Pipe that maps whether or not this is modified and can be triggered.\n   *\n   * Updates every state update instead of when the value changes.\n   */\n  readonly isModifiedAndCanTriggerUpdates$ = this.state$.pipe(\n    map((x) => actionContextIsModifiedAndCanTrigger(x), shareReplay(1))\n  );\n\n  /**\n   * Whether or not it can be triggered and modified.\n   */\n  readonly isModifiedAndCanTrigger$ = this.isModifiedAndCanTriggerUpdates$.pipe(\n    distinctUntilChanged()\n  );\n\n  readonly hasNoErrorAndIsModifiedAndCanTrigger$ = this.state$.pipe(\n    map((x) => actionContextHasNoErrorAndIsModifiedAndCanTrigger(x)),\n    distinctUntilChanged(), shareReplay(1)\n  );\n\n  // MARK: State Changes\n  /**\n   * Adds a disabled reason.\n   */\n  readonly disable = this.updater((state, key?: void | ActionDisabledKey) => ({\n    ...state,\n    disabled: BooleanStringKeyArrayUtilityInstance.insert(state.disabled, ((key as any) ?? DEFAULT_ACTION_DISABLED_KEY))\n  }));\n\n  /**\n   * Removes a disabled reason.\n   */\n  readonly enable = this.updater((state, key?: void | ActionDisabledKey) => ({\n    ...state,\n    disabled: BooleanStringKeyArrayUtilityInstance.remove(state.disabled, ((key as any) ?? DEFAULT_ACTION_DISABLED_KEY))\n  }));\n\n  /**\n   * Triggers the modified state, if not disabled.\n   */\n  readonly setIsModified = this.updater((state, isModified: void | boolean) => ({\n    ...state,\n    actionState: (state.actionState === ActionState.Success) ? ActionState.Idle : state.actionState,  // Set to idle from success.\n    isModified: (isModified as boolean) ?? true\n  }));\n\n  /**\n   * 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).\n   *\n   * Will not fire if the action is disabled.\n   */\n  readonly trigger = this.updater((state) => canTriggerAction(state)\n    ? ({ isModified: state.isModified, actionState: ActionState.Triggered, error: state.error, value: undefined })\n    : state);\n\n  /**\n   * Updates the value, setting value ready. The current result is cleared.\n   */\n  readonly readyValue = this.updater((state, value: Maybe<T>) => canReadyValue(state)\n    ? ({ ...state, actionState: ActionState.ValueReady, value, result: undefined })\n    : state);\n\n  /**\n   * Notifys the context that the action is in progress.\n   */\n  readonly startWorking = this.updater((state) => ({ ...state, actionState: ActionState.Working }));\n\n  /**\n   * Triggers rejection of the action. The value is cleared.\n   */\n  readonly reject = this.updater((state, error?: Maybe<ReadableError>) => ({ isModified: state.isModified, actionState: ActionState.Rejected, error, errorCount: (state.errorCount ?? 0) + 1 }));\n\n  /**\n   * Updates the state to success, and optionally sets a result.\n   *\n   * Clears modified state, and any errors.\n   */\n  readonly success = this.updater((state, result?: O) => ({ isModified: false, actionState: ActionState.Success, value: state.value, result, error: undefined }));\n\n  /**\n   * Completely resets the store.\n   */\n  readonly reset = this.updater((state) => ({ ...INITIAL_STATE }));\n\n  // MARK: Utility\n  afterDistinctBoolean(fromState: (state: ActionContextState) => boolean): Observable<boolean> {\n    return this.state$.pipe(\n      map(x => fromState(x)),\n      distinctUntilChanged(),\n      shareReplay(1)\n    );\n  }\n\n  afterDistinctActionState<X>(actionState: ActionState, fromState: (state: ActionContextState) => X): Observable<X> {\n    return this.state$.pipe(\n      map((x) => ([x, x.actionState]) as [ActionContextState, ActionState]),\n      distinctUntilChanged((a, b) => a?.[1] === b?.[1]),  // Filter out when the state remains the same.\n      filter(([x, y]) => y === actionState),  // Only pipe when the action state matches.\n      map(x => fromState(x[0])),\n      shareReplay(1)\n    );\n  }\n\n  // MARK: Cleanup\n  override ngOnDestroy(): void {\n    // Wait for any actions to complete before destroying.\n    this.lockSet.onNextUnlock(() => {\n      super.ngOnDestroy();\n    }, 2000);\n  }\n\n}\n"]}