@dereekb/dbx-core 0.0.1

package/fesm2020/dereekb-dbx-core.mjs

@@ -0,0 +1,2856 @@
+import * as i0 from '@angular/core';
+import { Directive, forwardRef, Host, Input, Injectable, Optional, Component, NgModule, EventEmitter, Output, LOCALE_ID, Pipe, Inject, ViewContainerRef, ViewChild, InjectionToken } from '@angular/core';
+import * as i1 from 'rxjs';
+import { BehaviorSubject, combineLatest, Subject, interval, EMPTY, of, isObservable, Observable } from 'rxjs';
+import { SubscriptionObject, LockSet, filterMaybe, scanCount, combineLatestFromMapValuesObsFn, skipFirstMaybe } from '@dereekb/rxjs';
+import { switchMap, first, distinctUntilChanged, filter, debounce, throttle, exhaustMap, mergeMap, map, shareReplay, withLatestFrom, startWith, tap, delay } from 'rxjs/operators';
+import * as i1$3 from '@dereekb/util';
+import { hasValueOrNotEmpty, BooleanStringKeyArrayUtilityInstance, reduceBooleansWithOrFn, getValueFromObjectOrGetter, DataIsExpiredError, DataDoesNotExistError, filterMaybeValuesFn, StorageObjectUtility, SHARED_MEMORY_STORAGE } from '@dereekb/util';
+import { ComponentStore } from '@ngrx/component-store';
+import * as i2 from '@angular/common';
+import { CommonModule, formatDate } from '@angular/common';
+import ms from 'ms';
+import * as i1$1 from '@angular/router';
+import { NavigationStart, NavigationEnd } from '@angular/router';
+import { isArray } from 'class-validator';
+import * as i1$2 from '@uirouter/core';
+import { addMinutes, isPast, formatDistance, isValid, formatDistanceToNow, startOfDay, isSameDay } from 'date-fns';
+import { toJsDate, formatToTimeString, unixTimeNumberForNow, timeNumberHasExpired } from '@dereekb/date';
+
+/**
+ * Abstract component that contains a SubscriptionObject and will clean it up automatically.
+ */
+class AbstractSubscriptionDirective {
+    constructor(subscription) {
+        this._subscriptionObject = new SubscriptionObject();
+        this.sub = subscription;
+    }
+    ngOnDestroy() {
+        this._subscriptionObject.destroy();
+    }
+    set sub(subscription) {
+        this._subscriptionObject.subscription = subscription;
+    }
+}
+AbstractSubscriptionDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractSubscriptionDirective, deps: [{ token: i1.Subscription }], target: i0.ɵɵFactoryTarget.Directive });
+AbstractSubscriptionDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: AbstractSubscriptionDirective, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractSubscriptionDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.Subscription }]; } });
+/**
+ * AbstractSubscriptionDirective extension that prevents the OnDestroy from occuring until the lockset is unlocked.
+ */
+class AbstractLockSetSubscriptionDirective extends AbstractSubscriptionDirective {
+    constructor() {
+        super(...arguments);
+        this.lockSet = new LockSet();
+    }
+    ngOnDestroy() {
+        this.lockSet.onNextUnlock(() => this.onLockSetDestroy());
+    }
+    onLockSetDestroy() {
+        super.ngOnDestroy();
+    }
+}
+AbstractLockSetSubscriptionDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractLockSetSubscriptionDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+AbstractLockSetSubscriptionDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: AbstractLockSetSubscriptionDirective, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractLockSetSubscriptionDirective, decorators: [{
+            type: Directive
+        }] });
+
+/**
+ * Source that provides a ActionContextStore observable.
+ */
+class ActionContextStoreSource {
+}
+/**
+ * Secondary source. Used by DbNgxActionContextComponent to find secondary sources.
+ */
+class SecondaryActionContextStoreSource extends ActionContextStoreSource {
+}
+function actionContextStoreSourcePipe(obs) {
+    return obs.pipe(filterMaybe());
+}
+function pipeActionStore(source, pipeFn) {
+    return source.store$.pipe(switchMap(pipeFn));
+}
+/**
+ * Convenience function for subscribing to the input source once and using the provided store.
+ */
+function useActionStore(source, useFn) {
+    return source.store$.pipe(first()).subscribe(useFn);
+}
+// tslint:disable-next-line: directive-class-suffix
+class ActionContextStoreSourceInstance {
+    constructor(source) {
+        this.source = source;
+        this.lockSet = new LockSet();
+        if (!source) {
+            throw new Error('Source is required.');
+        }
+    }
+    ngOnDestroy() {
+        this.lockSet.destroyOnNextUnlock();
+    }
+    // MARK: Store
+    get store$() {
+        return this.source.store$;
+    }
+    pipeStore(pipeFn) {
+        return pipeActionStore(this.source, pipeFn);
+    }
+    useStore(useFn) {
+        return useActionStore(this.source, useFn);
+    }
+    get state$() {
+        return this.pipeStore(x => x.state$);
+    }
+    get triggered$() {
+        return this.pipeStore(x => x.triggered$);
+    }
+    get valueReady$() {
+        return this.pipeStore(x => x.valueReady$);
+    }
+    get success$() {
+        return this.pipeStore(x => x.success$);
+    }
+    get error$() {
+        return this.pipeStore(x => x.error$);
+    }
+    get rejected$() {
+        return this.pipeStore(x => x.rejected$);
+    }
+    get isModified$() {
+        return this.pipeStore(x => x.isModified$);
+    }
+    get isModifiedAndCanTriggerUpdates$() {
+        return this.pipeStore(x => x.isModifiedAndCanTriggerUpdates$);
+    }
+    get isModifiedAndCanTrigger$() {
+        return this.pipeStore(x => x.isModifiedAndCanTrigger$);
+    }
+    get actionState$() {
+        return this.pipeStore(x => x.actionState$);
+    }
+    get isWorking$() {
+        return this.pipeStore(x => x.isWorking$);
+    }
+    get isSuccess$() {
+        return this.pipeStore(x => x.isSuccess$);
+    }
+    get isDisabled$() {
+        return this.pipeStore(x => x.isDisabled$);
+    }
+    get errorCountSinceLastSuccess$() {
+        return this.pipeStore(x => x.errorCountSinceLastSuccess$);
+    }
+    enable(key, enable = true) {
+        this.disable(key, !enable);
+    }
+    disable(key, disable = true) {
+        this.useStore((x) => (disable) ? x.disable(key) : x.enable(key));
+    }
+    setIsModified(isModified) {
+        this.useStore((x) => x.setIsModified(isModified));
+    }
+    trigger() {
+        this.useStore((x) => x.trigger());
+    }
+    readyValue(value) {
+        this.useStore((x) => x.readyValue(value));
+    }
+    startWorking() {
+        this.useStore((x) => x.startWorking());
+    }
+    reject(error) {
+        this.useStore((x) => x.reject(error));
+    }
+    success(value) {
+        this.useStore((x) => x.success(value));
+    }
+    reset() {
+        this.useStore((x) => x.reset());
+    }
+}
+ActionContextStoreSourceInstance.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: ActionContextStoreSourceInstance, deps: [{ token: ActionContextStoreSource }], target: i0.ɵɵFactoryTarget.Directive });
+ActionContextStoreSourceInstance.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: ActionContextStoreSourceInstance, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: ActionContextStoreSourceInstance, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: ActionContextStoreSource }]; } });
+const actionContextStoreSourceInstanceFactory = (source) => {
+    return new ActionContextStoreSourceInstance(source);
+};
+/**
+ * Provides an ActionContextStoreSource, as well as an ActionContextStoreSourceInstance.
+ */
+function ProvideActionStoreSource(sourceType) {
+    return [{
+            provide: ActionContextStoreSource,
+            useExisting: forwardRef(() => sourceType)
+        },
+        {
+            provide: ActionContextStoreSourceInstance,
+            useFactory: actionContextStoreSourceInstanceFactory,
+            deps: [ActionContextStoreSource]
+        }];
+}
+function ProvideSecondaryActionStoreSource(sourceType) {
+    return [{
+            provide: SecondaryActionContextStoreSource,
+            useExisting: forwardRef(() => sourceType)
+        },
+        ...ProvideActionStoreSource(sourceType)
+    ];
+}
+
+class DbNgxActionAutoModifyDirective extends AbstractSubscriptionDirective {
+    constructor(source) {
+        super();
+        this.source = source;
+        this._autoModifyEnabled = new BehaviorSubject(true);
+    }
+    get autoModifyEnabled() {
+        return this._autoModifyEnabled.value;
+    }
+    set autoModifyEnabled(autoModifyEnabled) {
+        this._autoModifyEnabled.next(autoModifyEnabled !== 'false');
+    }
+    ngOnInit() {
+        const obs = combineLatest([
+            this._autoModifyEnabled.pipe(distinctUntilChanged()),
+            this.source.isModified$.pipe(filter(x => !x)) // Only when not modified send a value.
+        ]);
+        this.sub = obs.subscribe(([autoModifyEnabled, isModified]) => {
+            if (autoModifyEnabled && !isModified) {
+                this.source.setIsModified(true);
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.source.lockSet.onNextUnlock(() => {
+            super.ngOnDestroy();
+            this._autoModifyEnabled.complete();
+        });
+    }
+}
+DbNgxActionAutoModifyDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionAutoModifyDirective, deps: [{ token: ActionContextStoreSourceInstance, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionAutoModifyDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionAutoModifyDirective, selector: "[dbxActionAutoModify]", inputs: { autoModifyEnabled: ["dbxActionAutoModify", "autoModifyEnabled"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionAutoModifyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionAutoModify]',
+                }]
+        }], ctorParameters: function () { return [{ type: ActionContextStoreSourceInstance, decorators: [{
+                    type: Host
+                }] }]; }, propDecorators: { autoModifyEnabled: [{
+                type: Input,
+                args: ['dbxActionAutoModify']
+            }] } });
+
+const DEFAULT_DEBOUNCE_MS = 2 * 1000;
+const DEFAULT_THROTTLE_MS = 10 * 1000;
+const DEFAULT_ERROR_THROTTLE_MS = 3 * 1000;
+const MAX_ERRORS_TO_THROTTLE_ON = 6;
+/**
+ * Extension of DbNgxActionTransitionSafetyDirective that automatically triggers the action periodically when it is in a modified state.
+ */
+class DbNgxActionAutoTriggerDirective extends AbstractSubscriptionDirective {
+    constructor(source) {
+        super();
+        this.source = source;
+        this._triggerEnabled = new BehaviorSubject(true);
+        this.triggerDebounce = DEFAULT_DEBOUNCE_MS;
+        this.triggerThrottle = DEFAULT_THROTTLE_MS;
+        this.triggerErrorThrottle = DEFAULT_ERROR_THROTTLE_MS;
+        this.maxErrorsForThrottle = MAX_ERRORS_TO_THROTTLE_ON;
+        this._triggerLimit = new BehaviorSubject(undefined);
+        this._trigger = new Subject();
+        this._triggerCount = 0;
+        this._errorCount$ = this.source.errorCountSinceLastSuccess$;
+        this._triggerCount$ = this.source.isModifiedAndCanTriggerUpdates$.pipe(filter(() => this.isEnabled), filter((x) => x), debounce(() => interval(this.triggerDebounce)), throttle(() => this._errorCount$.pipe(first(), exhaustMap((count) => interval(this.triggerThrottle + (Math.min(count, this.maxErrorsForThrottle) * this.triggerErrorThrottle)))), { leading: true, trailing: true }), 
+        // Check again for the "trailing" piece.
+        filter(() => this.isEnabled), mergeMap(() => this.source.isModifiedAndCanTrigger$.pipe(first())), filter((x) => x), map(() => this._triggerCount += 1), shareReplay(1));
+        /**
+         * Observable for the trigger mechanism.
+         */
+        this.triggerCount$ = this._triggerEnabled.pipe(switchMap((enabled) => {
+            if (enabled) {
+                return this._triggerCount$;
+            }
+            else {
+                return EMPTY;
+            }
+        }));
+        this._isTriggerLimited$ = combineLatest([this.triggerCount$, this._triggerLimit]).pipe(map(([triggerCount, limit]) => [triggerCount, ((limit) ? (triggerCount > limit) : false)]), shareReplay(1));
+        this.isTriggerLimited$ = this._isTriggerLimited$.pipe(map(x => x[1]));
+        this.trigger$ = this._isTriggerLimited$.pipe(filter(x => !x[1]), distinctUntilChanged((a, b) => a[0] === b[0]), // Only trigger when the count changes.
+        map(() => undefined));
+    }
+    /**
+     * How much to throttle the auto-triggering.
+     */
+    get triggerEnabled() {
+        return this._triggerEnabled.value;
+    }
+    set triggerEnabled(triggerEnabled) {
+        triggerEnabled = triggerEnabled !== false; // Default to true
+        if (this.triggerEnabled !== triggerEnabled) {
+            this._triggerEnabled.next(triggerEnabled);
+        }
+    }
+    /**
+     * Optional input to override both triggerDebounce and triggerThrottle.
+     *
+     * Used in forms that are simple.
+     */
+    set fastTrigger(fastTrigger) {
+        if (fastTrigger) {
+            this.triggerDebounce = 200;
+            this.triggerThrottle = 500;
+        }
+    }
+    /**
+     * Optional input to override both triggerDebounce and triggerThrottle to be 0.
+     *
+     * Used in forms that generally return a single value.
+     */
+    set instantTrigger(instantTrigger) {
+        if (instantTrigger) {
+            this.triggerDebounce = 10;
+            this.triggerThrottle = 0;
+        }
+    }
+    get triggerLimit() {
+        return this._triggerLimit.value;
+    }
+    set triggerLimit(triggerLimit) {
+        triggerLimit = triggerLimit || 0;
+        this._triggerLimit.next(triggerLimit);
+    }
+    get isEnabled() {
+        return this.triggerEnabled !== false;
+    }
+    ngOnInit() {
+        this.sub = this.trigger$.subscribe(() => {
+            this.source.trigger();
+        });
+    }
+    ngOnDestroy() {
+        this.source.lockSet.onNextUnlock(() => {
+            super.ngOnDestroy();
+            this._trigger.complete();
+            this._triggerLimit.complete();
+        });
+    }
+}
+DbNgxActionAutoTriggerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionAutoTriggerDirective, deps: [{ token: ActionContextStoreSourceInstance, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionAutoTriggerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionAutoTriggerDirective, selector: "[dbxActionAutoTrigger]", inputs: { triggerEnabled: ["dbxActionAutoTrigger", "triggerEnabled"], triggerDebounce: "triggerDebounce", triggerThrottle: "triggerThrottle", triggerErrorThrottle: "triggerErrorThrottle", fastTrigger: "fastTrigger", instantTrigger: "instantTrigger", triggerLimit: "triggerLimit" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionAutoTriggerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionAutoTrigger]',
+                }]
+        }], ctorParameters: function () { return [{ type: ActionContextStoreSourceInstance, decorators: [{
+                    type: Host
+                }] }]; }, propDecorators: { triggerEnabled: [{
+                type: Input,
+                args: ['dbxActionAutoTrigger']
+            }], triggerDebounce: [{
+                type: Input
+            }], triggerThrottle: [{
+                type: Input
+            }], triggerErrorThrottle: [{
+                type: Input
+            }], fastTrigger: [{
+                type: Input
+            }], instantTrigger: [{
+                type: Input
+            }], triggerLimit: [{
+                type: Input
+            }] } });
+
+/**
+ * Directive that watches an observable for changes and sets the new value and modified states as necessary.
+ */
+class DbNgxActionAutoTriggerValueDirective {
+    constructor(source) {
+        this.source = source;
+        this._valueObs = new BehaviorSubject(EMPTY);
+        this._isModifiedFn = new BehaviorSubject(undefined);
+        this._modifiedSub = new SubscriptionObject();
+        this._triggerSub = new SubscriptionObject();
+        this.modifiedValue$ = this._valueObs.pipe(switchMap((obs) => obs.pipe(withLatestFrom(this._isModifiedFn), mergeMap(([value, dbxActionAutoTriggerModified]) => {
+            let result;
+            if (dbxActionAutoTriggerModified) {
+                result = dbxActionAutoTriggerModified(value).pipe(map((isModified) => [isModified, value]));
+            }
+            else {
+                result = of([true, value]);
+            }
+            return result;
+        }), shareReplay(1))));
+    }
+    set dbxActionAutoTriggerValue(dbxActionAutoTriggerValue) {
+        this._valueObs.next(dbxActionAutoTriggerValue);
+    }
+    set dbxActionAutoTriggerModifiedNonEmptyValue(requireNonEmpty) {
+        if (requireNonEmpty) {
+            this.dbxActionAutoTriggerModified = (value) => {
+                return of(hasValueOrNotEmpty(value));
+            };
+        }
+    }
+    set dbxActionAutoTriggerModified(dbxActionAutoTriggerModified) {
+        this._isModifiedFn.next(dbxActionAutoTriggerModified);
+    }
+    ngOnInit() {
+        // Update Modified value.
+        this._modifiedSub.subscription = this.modifiedValue$.subscribe(([isModified, value]) => {
+            this.source.setIsModified(isModified);
+        });
+        // Set the value on triggers.
+        this._triggerSub.subscription = this.source.triggered$.pipe(mergeMap(x => this.modifiedValue$)).subscribe(([isModified, value]) => {
+            this.source.readyValue(value);
+        });
+    }
+    ngOnDestroy() {
+        this.source.lockSet.onNextUnlock(() => {
+            this._isModifiedFn.complete();
+            this._valueObs.complete();
+            this._modifiedSub.destroy();
+            this._triggerSub.destroy();
+        });
+    }
+}
+DbNgxActionAutoTriggerValueDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionAutoTriggerValueDirective, deps: [{ token: ActionContextStoreSourceInstance, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionAutoTriggerValueDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionAutoTriggerValueDirective, selector: "[dbxActionAutoTriggerValue]", inputs: { dbxActionAutoTriggerValue: "dbxActionAutoTriggerValue", dbxActionAutoTriggerModifiedNonEmptyValue: "dbxActionAutoTriggerModifiedNonEmptyValue", dbxActionAutoTriggerModified: "dbxActionAutoTriggerModified" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionAutoTriggerValueDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionAutoTriggerValue]',
+                }]
+        }], ctorParameters: function () { return [{ type: ActionContextStoreSourceInstance, decorators: [{
+                    type: Host
+                }] }]; }, propDecorators: { dbxActionAutoTriggerValue: [{
+                type: Input,
+                args: ['dbxActionAutoTriggerValue']
+            }], dbxActionAutoTriggerModifiedNonEmptyValue: [{
+                type: Input
+            }], dbxActionAutoTriggerModified: [{
+                type: Input
+            }] } });
+
+/**
+ * Used by ActionContextState to denote what state the action is in.
+ */
+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 = {}));
+const DEFAULT_ACTION_DISABLED_KEY = 'default';
+function isIdleActionState(actionState) {
+    switch (actionState) {
+        case ActionState.Idle:
+        case ActionState.Disabled:
+        case ActionState.Rejected:
+        case ActionState.Success:
+            return true;
+        default:
+            return false;
+    }
+}
+
+function isActionContextEnabled(state) {
+    return BooleanStringKeyArrayUtilityInstance.isFalse(state.disabled);
+}
+function isActionContextDisabled(state) {
+    return BooleanStringKeyArrayUtilityInstance.isTrue(state.disabled);
+}
+function isDisabledActionContextState(state) {
+    return isIdleActionState(state.actionState) && isActionContextDisabled(state);
+}
+function isWorkingActionState(actionState) {
+    return !isIdleActionState(actionState);
+}
+function canTriggerActionState(actionState) {
+    return actionState !== ActionState.Disabled && isIdleActionState(actionState);
+}
+function canTriggerAction(state) {
+    return isActionContextEnabled(state) && isIdleActionState(state.actionState);
+}
+function canReadyValue(state) {
+    return state.actionState === ActionState.Triggered;
+}
+function actionContextIsModifiedAndCanTrigger(state) {
+    // console.log('check: ', state, state.isModified, canTriggerAction(state));
+    return state.isModified && canTriggerAction(state);
+}
+function actionContextHasNoErrorAndIsModifiedAndCanTrigger(state) {
+    return !state.error && actionContextIsModifiedAndCanTrigger(state);
+}
+const INITIAL_STATE = {
+    isModified: false,
+    actionState: ActionState.Idle
+};
+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 []; } });
+
+/**
+ * Abstract class that can either use SecondaryActionContextStoreSource or create it's own.
+ */
+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();
+    }
+}
+
+/**
+ * Provides an DbNgxActionContext.
+ */
+class DbNgxActionContextDirective extends ActionContextBaseSource {
+    constructor(inputSource) {
+        super(inputSource);
+    }
+    ngOnDestroy() {
+        this.lockSet.destroyOnNextUnlock(() => {
+            this.destroy();
+        });
+    }
+}
+DbNgxActionContextDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionContextDirective, deps: [{ token: SecondaryActionContextStoreSource, host: true, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionContextDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionContextDirective, selector: "[dbxActionContext]", providers: ProvideActionStoreSource(DbNgxActionContextDirective), exportAs: ["action"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionContextDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionContext]',
+                    exportAs: 'action',
+                    providers: ProvideActionStoreSource(DbNgxActionContextDirective)
+                }]
+        }], ctorParameters: function () { return [{ type: SecondaryActionContextStoreSource, decorators: [{
+                    type: Optional
+                }, {
+                    type: Host
+                }] }]; } });
+
+class DbNgxActionComponent extends DbNgxActionContextDirective {
+}
+DbNgxActionComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+DbNgxActionComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionComponent, selector: "dbx-action", providers: ProvideActionStoreSource(DbNgxActionComponent), exportAs: ["action"], usesInheritance: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-action',
+                    exportAs: 'action',
+                    template: '<ng-content></ng-content>',
+                    providers: ProvideActionStoreSource(DbNgxActionComponent)
+                }]
+        }] });
+
+/**
+ * Directive that provides a DbNgxActionSourceDirective that is passed in.
+ */
+class DbNgxActionSourceDirective {
+    constructor() {
+        this._source = new BehaviorSubject(undefined);
+        this.store$ = this._source.pipe(filterMaybe(), switchMap((x) => actionContextStoreSourcePipe(x.store$)));
+    }
+    ngOnDestroy() {
+        this._source.complete();
+    }
+    get source() {
+        return this._source.value;
+    }
+    set source(source) {
+        if (source && !source.store$) {
+            throw new Error('Invalid source passed to dbxActionSource.');
+        }
+        this._source.next(source);
+    }
+}
+DbNgxActionSourceDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionSourceDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionSourceDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionSourceDirective, selector: "[dbxActionSource]", inputs: { source: ["dbxActionSource", "source"] }, providers: ProvideSecondaryActionStoreSource(DbNgxActionSourceDirective), ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionSourceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionSource]',
+                    providers: ProvideSecondaryActionStoreSource(DbNgxActionSourceDirective)
+                }]
+        }], propDecorators: { source: [{
+                type: Input,
+                args: ['dbxActionSource']
+            }] } });
+
+/**
+ * Prints out the current state to the console. Useful for debugging.
+ */
+class DbNgxActionContextLoggerDirective extends AbstractSubscriptionDirective {
+    constructor(source) {
+        super();
+        this.source = source;
+    }
+    ngOnInit() {
+        this.sub = this.source.state$.subscribe((state) => {
+            console.log('State: ', state);
+        });
+    }
+}
+DbNgxActionContextLoggerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionContextLoggerDirective, deps: [{ token: ActionContextStoreSourceInstance, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionContextLoggerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionContextLoggerDirective, selector: "[dbxActionContextLogger]", usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionContextLoggerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionContextLogger]'
+                }]
+        }], ctorParameters: function () { return [{ type: ActionContextStoreSourceInstance, decorators: [{
+                    type: Host
+                }] }]; } });
+
+/**
+ * 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.
+ */
+class DbNgxActionContextMapDirective {
+    constructor() {
+        this._map = new BehaviorSubject(new Map());
+        this.map$ = this._map.asObservable();
+        this.areAnyWorking$ = this.checkAnyAre(x => x.isWorking$, false);
+    }
+    get map() {
+        return this._map.value;
+    }
+    sourceForKey(key) {
+        return new DbNgxActionContextMapDirectiveSourceInstance(this, key);
+    }
+    addStoreSource(key, source) {
+        if (this.map.has(key)) {
+            throw new Error(`Key already existed for "${key}" in map. Ensure the previous store is removed before setting another.`);
+        }
+        else if (!source) {
+            throw new Error('addStoreSource requires a source.');
+        }
+        this.map.set(key, source);
+        this._map.next(this.map);
+    }
+    removeStore(key) {
+        if (!this.map.delete(key)) {
+            console.warn('removeStore called and no value was found.');
+        }
+        this._map.next(this.map);
+    }
+    ngOnDestroy() {
+        this._map.complete();
+    }
+    // MARK: Utility
+    checkAnyAre(mapFn, emptyArrayValue = false) {
+        return this.reduceFromAllSources(mapFn, reduceBooleansWithOrFn(emptyArrayValue));
+    }
+    reduceFromAllSources(mapFn, reduceFn) {
+        return this.fromAllSources(mapFn).pipe(map(reduceFn));
+    }
+    fromAllSources(mapFn) {
+        return this.map$.pipe(switchMap(combineLatestFromMapValuesObsFn((x) => x.store$.pipe(switchMap(mapFn)))));
+    }
+}
+DbNgxActionContextMapDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionContextMapDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionContextMapDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionContextMapDirective, selector: "[dbxActionContextMap]", providers: [], exportAs: ["actionMap"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionContextMapDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionContextMap]',
+                    exportAs: 'actionMap',
+                    providers: [],
+                }]
+        }], ctorParameters: function () { return []; } });
+class DbNgxActionContextMapDirectiveSourceInstance {
+    constructor(parent, key) {
+        this.parent = parent;
+        this.key = key;
+        this._source$ = this.parent.map$.pipe(map(x => x.get(this.key)), distinctUntilChanged());
+        this._store$ = this._source$.pipe(switchMap((x) => x?.store$ ?? of(undefined)), shareReplay(1));
+        this.store$ = actionContextStoreSourcePipe(this._store$);
+    }
+}
+
+/**
+ * Directive that provides a ActionContextStoreSource using the input key and DbNgxActionContextMapDirective.
+ */
+class DbNgxActionFromMapDirective {
+    constructor(_map) {
+        this._map = _map;
+        this._key = new BehaviorSubject(undefined);
+        this.store$ = this._key.pipe(filterMaybe(), switchMap((x) => this._map.sourceForKey(x).store$));
+    }
+    ngOnDestroy() {
+        this._key.complete();
+    }
+    get key() {
+        return this._key.value;
+    }
+    set key(key) {
+        this._key.next(key);
+    }
+}
+DbNgxActionFromMapDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionFromMapDirective, deps: [{ token: DbNgxActionContextMapDirective }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionFromMapDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionFromMapDirective, selector: "[dbxActionFromMap]", inputs: { key: ["dbxActionFromMap", "key"] }, providers: ProvideSecondaryActionStoreSource(DbNgxActionFromMapDirective), ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionFromMapDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionFromMap]',
+                    providers: ProvideSecondaryActionStoreSource(DbNgxActionFromMapDirective)
+                }]
+        }], ctorParameters: function () { return [{ type: DbNgxActionContextMapDirective }]; }, propDecorators: { key: [{
+                type: Input,
+                args: ['dbxActionFromMap']
+            }] } });
+
+/**
+ * Used to communicate with an dbxActionMap and set the ActionContextStore to the store based on the key.
+ */
+class DbNgxActionMapSourceDirective {
+    constructor(source, _map) {
+        this.source = source;
+        this._map = _map;
+    }
+    ngOnDestroy() {
+        this._removeFromToStore();
+    }
+    set key(key) {
+        if (this._key !== key) {
+            this._removeFromToStore();
+        }
+        this._key = key;
+        this._addToStore();
+    }
+    _addToStore() {
+        if (this._key) {
+            this._map.addStoreSource(this._key, this.source);
+        }
+    }
+    _removeFromToStore() {
+        if (this._key) {
+            this._map.removeStore(this._key);
+        }
+    }
+}
+DbNgxActionMapSourceDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionMapSourceDirective, deps: [{ token: ActionContextStoreSource, host: true }, { token: DbNgxActionContextMapDirective }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionMapSourceDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionMapSourceDirective, selector: "[dbxActionMapSource]", inputs: { key: ["dbxActionMapSource", "key"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionMapSourceDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionMapSource]'
+                }]
+        }], ctorParameters: function () { return [{ type: ActionContextStoreSource, decorators: [{
+                    type: Host
+                }] }, { type: DbNgxActionContextMapDirective }]; }, propDecorators: { key: [{
+                type: Input,
+                args: ['dbxActionMapSource']
+            }] } });
+
+/**
+ * Map that returns sources for ActionKey values.
+ */
+class ActionContextStoreSourceMap {
+}
+
+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.
+ */
+class DbNgxActionMapWorkingDisableDirective extends AbstractSubscriptionDirective {
+    constructor(source, _map) {
+        super();
+        this.source = source;
+        this._map = _map;
+    }
+    ngOnInit() {
+        this.sub = this._map.areAnyWorking$.subscribe((x) => {
+            this.source.disable(this.disabledKey || DEFAULT_ACTION_MAP_WORKING_DISABLED_KEY, x);
+        });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.source.enable(this.disabledKey || DEFAULT_ACTION_MAP_WORKING_DISABLED_KEY);
+    }
+}
+DbNgxActionMapWorkingDisableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionMapWorkingDisableDirective, deps: [{ token: ActionContextStoreSourceInstance, host: true }, { token: DbNgxActionContextMapDirective }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionMapWorkingDisableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionMapWorkingDisableDirective, selector: "[dbxActionMapWorkingDisable]", inputs: { disabledKey: ["dbxActionMapWorkingDisable", "disabledKey"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionMapWorkingDisableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionMapWorkingDisable]'
+                }]
+        }], ctorParameters: function () { return [{ type: ActionContextStoreSourceInstance, decorators: [{
+                    type: Host
+                }] }, { type: DbNgxActionContextMapDirective }]; }, propDecorators: { disabledKey: [{
+                type: Input,
+                args: ['dbxActionMapWorkingDisable']
+            }] } });
+
+const APP_ACTION_DISABLED_DIRECTIVE_KEY = 'dbx_action_disabled';
+/**
+ * Directive that allows disabling an action using the inputs.
+ */
+class DbNgxActionDisabledDirective extends AbstractSubscriptionDirective {
+    constructor(source) {
+        super();
+        this.source = source;
+        this._disabled = new BehaviorSubject(false);
+        this.disabled$ = this._disabled.pipe(distinctUntilChanged());
+    }
+    ngOnInit() {
+        this.sub = this.disabled$.subscribe((x) => {
+            this.source.disable(APP_ACTION_DISABLED_DIRECTIVE_KEY, x);
+        });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._disabled.complete();
+        this.source.enable(APP_ACTION_DISABLED_DIRECTIVE_KEY);
+    }
+    get disabled() {
+        return this._disabled.value;
+    }
+    set disabled(disabled) {
+        this._disabled.next(disabled);
+    }
+}
+DbNgxActionDisabledDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionDisabledDirective, deps: [{ token: ActionContextStoreSourceInstance, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionDisabledDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionDisabledDirective, selector: "[dbxActionDisabled]", inputs: { disabled: ["dbxActionDisabled", "disabled"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionDisabledDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionDisabled]'
+                }]
+        }], ctorParameters: function () { return [{ type: ActionContextStoreSourceInstance, decorators: [{
+                    type: Host
+                }] }]; }, propDecorators: { disabled: [{
+                type: Input,
+                args: ['dbxActionDisabled']
+            }] } });
+
+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.
+ */
+class DbNgxActionDisabledUntilModifiedDirective extends AbstractSubscriptionDirective {
+    constructor(source) {
+        super();
+        this.source = source;
+    }
+    ngOnInit() {
+        this.sub = this.source.isModified$.subscribe((x) => {
+            this.source.disable(APP_ACTION_DISABLED_UNTIL_MODIFIED_DIRECTIVE_KEY, !x);
+        });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.source.enable(APP_ACTION_DISABLED_UNTIL_MODIFIED_DIRECTIVE_KEY);
+    }
+}
+DbNgxActionDisabledUntilModifiedDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionDisabledUntilModifiedDirective, deps: [{ token: ActionContextStoreSourceInstance, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionDisabledUntilModifiedDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionDisabledUntilModifiedDirective, selector: "[dbxActionDisabledUntilModified]", usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionDisabledUntilModifiedDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionDisabledUntilModified]'
+                }]
+        }], ctorParameters: function () { return [{ type: ActionContextStoreSourceInstance, decorators: [{
+                    type: Host
+                }] }]; } });
+
+/**
+ * WorkHandlerContextDelegate implementation using an ActionContextStoreSourceInstance.
+ */
+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.
+ */
+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.
+ */
+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.
+ */
+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;
+    };
+}
+
+/**
+ * Context used for defining a function that performs an action using the input function on ValueReady.
+ */
+class DbNgxActionHandlerDirective extends AbstractSubscriptionDirective {
+    constructor(source) {
+        super();
+        this.source = source;
+        this._handlerFunction = new BehaviorSubject(undefined);
+        this.handlerFunction$ = this._handlerFunction.pipe(filterMaybe(), shareReplay(1));
+        this._delegate = new WorkHandlerContextSourceDelegate(this.source);
+    }
+    get handlerFunction() {
+        return this._handlerFunction.value;
+    }
+    set handlerFunction(handlerFunction) {
+        this._handlerFunction.next(handlerFunction);
+    }
+    ngOnInit() {
+        this.sub = this.handlerFunction$.pipe(switchMap(handlerFunction => this.source.valueReady$.pipe(map((x) => [handlerFunction, x]), tap(([handlerFunction, value]) => {
+            const context = handleWorkValueReadyFn({ handlerFunction, delegate: this._delegate })(value);
+            if (context) {
+                // Add the action to the lockSet for the source to prevent it from being destroyed until the action completes.
+                this.source.lockSet.addLock('actionhandler', context.isComplete$.pipe(map(x => !x)));
+            }
+        })))).subscribe();
+    }
+    ngOnDestroy() {
+        this.source.lockSet.onNextUnlock(() => {
+            super.ngOnDestroy();
+        });
+    }
+}
+DbNgxActionHandlerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionHandlerDirective, deps: [{ token: ActionContextStoreSourceInstance, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionHandlerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionHandlerDirective, selector: "[dbxActionHandler]", inputs: { handlerFunction: ["dbxActionHandler", "handlerFunction"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionHandlerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionHandler]',
+                }]
+        }], ctorParameters: function () { return [{ type: ActionContextStoreSourceInstance, decorators: [{
+                    type: Host
+                }] }]; }, propDecorators: { handlerFunction: [{
+                type: Input,
+                args: ['dbxActionHandler']
+            }] } });
+
+/**
+ * Displays the input content when success is set.
+ *
+ * Can be configured to show for a limited time afterwards, etc.
+ */
+class DbNgxActionSuccessComponent {
+    constructor(source) {
+        this.source = source;
+        this.show$ = this.source.isSuccess$.pipe(exhaustMap((success) => {
+            if (success) {
+                if (this.hideAfter) {
+                    return of(false).pipe(delay(this.hideAfter), startWith(true));
+                }
+                else {
+                    return of(true);
+                }
+            }
+            else {
+                return of(false);
+            }
+        }), shareReplay(1));
+    }
+}
+DbNgxActionSuccessComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionSuccessComponent, deps: [{ token: ActionContextStoreSourceInstance }], target: i0.ɵɵFactoryTarget.Component });
+DbNgxActionSuccessComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionSuccessComponent, selector: "dbx-action-success", inputs: { hideAfter: "hideAfter" }, ngImport: i0, template: `
+    <ng-container *ngIf="show$ | async">
+      <ng-content></ng-content>
+    </ng-container>
+  `, isInline: true, directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "async": i2.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionSuccessComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-action-success',
+                    template: `
+    <ng-container *ngIf="show$ | async">
+      <ng-content></ng-content>
+    </ng-container>
+  `
+                }]
+        }], ctorParameters: function () { return [{ type: ActionContextStoreSourceInstance }]; }, propDecorators: { hideAfter: [{
+                type: Input
+            }] } });
+
+/**
+ * Directive that executes a function on ActionContextStore Success.
+ */
+class DbNgxActionSuccessDirective extends AbstractSubscriptionDirective {
+    constructor(source) {
+        super();
+        this.source = source;
+        this._successFunction = new BehaviorSubject(undefined);
+        this.successFunction$ = this._successFunction.pipe(filterMaybe(), shareReplay(1));
+    }
+    get successFunction() {
+        return this._successFunction.value;
+    }
+    set successFunction(successFunction) {
+        this._successFunction.next(successFunction);
+    }
+    ngOnInit() {
+        this.sub = this.successFunction$.pipe(switchMap(successFunction => this.source.success$.pipe(map(x => ([successFunction, x])), tap(([successFn, result]) => {
+            successFn(result);
+        })))).subscribe();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._successFunction.complete();
+    }
+}
+DbNgxActionSuccessDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionSuccessDirective, deps: [{ token: ActionContextStoreSourceInstance, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionSuccessDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionSuccessDirective, selector: "[dbxActionSuccess]", inputs: { successFunction: ["dbxActionSuccess", "successFunction"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionSuccessDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionSuccess]',
+                }]
+        }], ctorParameters: function () { return [{ type: ActionContextStoreSourceInstance, decorators: [{
+                    type: Host
+                }] }]; }, propDecorators: { successFunction: [{
+                type: Input,
+                args: ['dbxActionSuccess']
+            }] } });
+
+/**
+ * Directive that provides a default value when triggered.
+ *
+ * No value is required, allowing the directive to automatically call readyValue with undefined.
+ */
+class DbNgxActionValueDirective extends AbstractSubscriptionDirective {
+    constructor(source) {
+        super();
+        this.source = source;
+        this._valueOrFunction = new BehaviorSubject(undefined);
+        this.valueOrFunction$ = this._valueOrFunction.pipe(filterMaybe(), shareReplay(1));
+    }
+    get valueOrFunction() {
+        return this._valueOrFunction.value;
+    }
+    set valueOrFunction(valueOrFunction) {
+        this._valueOrFunction.next(valueOrFunction);
+    }
+    ngOnInit() {
+        this.sub = this.valueOrFunction$.pipe(switchMap(valueOrFunction => this.source.triggered$.pipe(tap(() => {
+            const value = getValueFromObjectOrGetter(valueOrFunction);
+            this.source.readyValue(value);
+        })))).subscribe();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._valueOrFunction.complete();
+    }
+}
+DbNgxActionValueDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionValueDirective, deps: [{ token: ActionContextStoreSourceInstance, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionValueDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionValueDirective, selector: "[dbxActionValue]", inputs: { valueOrFunction: ["dbxActionValue", "valueOrFunction"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionValueDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionValue]',
+                }]
+        }], ctorParameters: function () { return [{ type: ActionContextStoreSourceInstance, decorators: [{
+                    type: Host
+                }] }]; }, propDecorators: { valueOrFunction: [{
+                type: Input,
+                args: ['dbxActionValue']
+            }] } });
+
+/**
+ * Displays the input content when working is set.
+ */
+class DbNgxActionWorkingComponent {
+    constructor(source) {
+        this.source = source;
+        this.show$ = this.source.isWorking$;
+    }
+}
+DbNgxActionWorkingComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionWorkingComponent, deps: [{ token: ActionContextStoreSourceInstance }], target: i0.ɵɵFactoryTarget.Component });
+DbNgxActionWorkingComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionWorkingComponent, selector: "dbx-action-working", ngImport: i0, template: `
+    <ng-container *ngIf="show$ | async">
+      <ng-content></ng-content>
+    </ng-container>
+  `, isInline: true, directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "async": i2.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionWorkingComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-action-working',
+                    template: `
+    <ng-container *ngIf="show$ | async">
+      <ng-content></ng-content>
+    </ng-container>
+  `
+                }]
+        }], ctorParameters: function () { return [{ type: ActionContextStoreSourceInstance }]; } });
+
+const DEFAULT_SNACKBAR_DIRECTIVE_DURATION = ms('4s');
+const DEFAULT_SNACKBAR_UNDO_DIRECTIVE_DURATION = ms('30s');
+var ActionSnackbarDefaultType;
+(function (ActionSnackbarDefaultType) {
+    ActionSnackbarDefaultType["NONE"] = "none";
+    ActionSnackbarDefaultType["CREATE"] = "create";
+    ActionSnackbarDefaultType["SAVE"] = "save";
+    ActionSnackbarDefaultType["DELETE"] = "delete";
+    ActionSnackbarDefaultType["MERGE"] = "merge";
+    ActionSnackbarDefaultType["SEND"] = "send";
+    ActionSnackbarDefaultType["CANCEL"] = "cancel";
+    ActionSnackbarDefaultType["RESTORE"] = "restore";
+    ActionSnackbarDefaultType["REFRESH"] = "refresh";
+    ActionSnackbarDefaultType["MARK_READ"] = "read";
+    ActionSnackbarDefaultType["MARK_UNREAD"] = "unread";
+})(ActionSnackbarDefaultType || (ActionSnackbarDefaultType = {}));
+var ActionSnackbarEventType;
+(function (ActionSnackbarEventType) {
+    ActionSnackbarEventType[ActionSnackbarEventType["WORKING"] = 0] = "WORKING";
+    ActionSnackbarEventType[ActionSnackbarEventType["SUCCESS"] = 1] = "SUCCESS";
+    ActionSnackbarEventType[ActionSnackbarEventType["REJECTED"] = 2] = "REJECTED";
+})(ActionSnackbarEventType || (ActionSnackbarEventType = {}));
+
+// export * from './snackbar.directive';
+
+/**
+ * Configurable machine that handles components of the ActionContextStore lifecycle.
+ */
+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;
+    }
+}
+
+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
+                    ]
+                }]
+        }] });
+
+class DbNgxButton {
+}
+function ProvideDbNgxButton(sourceType) {
+    return [{
+            provide: DbNgxButton,
+            useExisting: sourceType
+        }];
+}
+
+/**
+ * Context used for linking a button to an ActionContext and only look for triggers.
+ */
+class DbNgxActionButtonTriggerDirective extends AbstractSubscriptionDirective {
+    constructor(button, source) {
+        super();
+        this.button = button;
+        this.source = source;
+    }
+    ngOnInit() {
+        this.sub = this.button.clicked$.subscribe(() => {
+            this._buttonClicked();
+        });
+    }
+    _buttonClicked() {
+        this.source.trigger();
+    }
+}
+DbNgxActionButtonTriggerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionButtonTriggerDirective, deps: [{ token: DbNgxButton, host: true }, { token: ActionContextStoreSourceInstance }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionButtonTriggerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionButtonTriggerDirective, selector: "[dbxActionButtonTrigger]", usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionButtonTriggerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionButtonTrigger]'
+                }]
+        }], ctorParameters: function () { return [{ type: DbNgxButton, decorators: [{
+                    type: Host
+                }] }, { type: ActionContextStoreSourceInstance }]; } });
+
+/**
+ * Context used for linking a button to an ActionContext.
+ */
+class DbNgxActionButtonDirective extends DbNgxActionButtonTriggerDirective {
+    constructor(button, source, ngZone) {
+        super(button, source);
+        this.ngZone = ngZone;
+        this._workingSub = new SubscriptionObject();
+        this._disabledSub = new SubscriptionObject();
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this._workingSub.subscription = this.source.isWorking$.subscribe((working) => {
+            // console.log('Working: ', working);
+            this.ngZone.run(() => this.button.working = working);
+        });
+        this._disabledSub.subscription = this.source.isDisabled$.subscribe((disabled) => {
+            // console.log('Disabled: ', disabled);
+            this.ngZone.run(() => this.button.disabled = disabled);
+        });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._workingSub.destroy();
+        this._disabledSub.destroy();
+    }
+}
+DbNgxActionButtonDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionButtonDirective, deps: [{ token: DbNgxButton, host: true }, { token: ActionContextStoreSourceInstance }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxActionButtonDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxActionButtonDirective, selector: "[dbxActionButton]", usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxActionButtonDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxActionButton]'
+                }]
+        }], ctorParameters: function () { return [{ type: DbNgxButton, decorators: [{
+                    type: Host
+                }] }, { type: ActionContextStoreSourceInstance }, { type: i0.NgZone }]; } });
+
+var AnchorType;
+(function (AnchorType) {
+    AnchorType[AnchorType["None"] = 0] = "None";
+    AnchorType[AnchorType["Clickable"] = 1] = "Clickable";
+    AnchorType[AnchorType["Sref"] = 2] = "Sref";
+    AnchorType[AnchorType["Href"] = 3] = "Href";
+    AnchorType[AnchorType["Disabled"] = 4] = "Disabled";
+})(AnchorType || (AnchorType = {}));
+function anchorTypeForAnchor(anchor, disabled) {
+    let type = AnchorType.Disabled;
+    if (!disabled && anchor) {
+        if (anchor.disabled) {
+            type = AnchorType.Disabled;
+        }
+        else if (anchor.ref) {
+            type = AnchorType.Sref;
+        }
+        else if (anchor.onClick) {
+            type = AnchorType.Clickable;
+        }
+        else if (anchor.url) {
+            type = AnchorType.Href;
+        }
+    }
+    return type;
+}
+class DbNgxAnchor {
+}
+function ProvideDbNgxAnchor(sourceType) {
+    return [{
+            provide: DbNgxAnchor,
+            useExisting: sourceType
+        }];
+}
+
+/**
+ * Abstract anchor directive.
+ */
+class AbstractDbNgxAnchorDirective {
+    constructor() {
+        this._disabled = new BehaviorSubject(false);
+        this._anchor = new BehaviorSubject(undefined);
+        this.disabled$ = this._disabled.asObservable();
+        this.anchor$ = this._anchor.pipe(skipFirstMaybe(), distinctUntilChanged(), shareReplay(1));
+        this.type$ = combineLatest([this.disabled$, this.anchor$]).pipe(map(([disabled, anchor]) => anchorTypeForAnchor(anchor, disabled)), distinctUntilChanged(), shareReplay(1));
+    }
+    get anchor() {
+        return this._anchor.value;
+    }
+    set anchor(anchor) {
+        this._anchor.next(anchor);
+    }
+    get disabled() {
+        return this._disabled.value;
+    }
+    set disabled(disabled) {
+        this._disabled.next(disabled);
+    }
+}
+AbstractDbNgxAnchorDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractDbNgxAnchorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+AbstractDbNgxAnchorDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: AbstractDbNgxAnchorDirective, inputs: { anchor: "anchor", disabled: "disabled" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractDbNgxAnchorDirective, decorators: [{
+            type: Directive
+        }], propDecorators: { anchor: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }] } });
+
+var DbNgxRouterTransitionEventType;
+(function (DbNgxRouterTransitionEventType) {
+    /**
+     * A transition started.
+     */
+    DbNgxRouterTransitionEventType["START"] = "start";
+    /**
+     * A transition ended.
+     */
+    DbNgxRouterTransitionEventType["SUCCESS"] = "ended";
+})(DbNgxRouterTransitionEventType || (DbNgxRouterTransitionEventType = {}));
+
+/**
+ * AngularRouter implementation of DbNgxRouterService and DbNgxRouterTransitionService.
+ */
+class DbNgxAngularRouterService {
+    constructor(router, activatedRoute) {
+        this.router = router;
+        this.activatedRoute = activatedRoute;
+        this.transitions$ = this.router.events.pipe(map((x) => {
+            let event;
+            if (x instanceof NavigationStart) {
+                event = {
+                    type: DbNgxRouterTransitionEventType.START
+                };
+            }
+            else if (x instanceof NavigationEnd) {
+                event = {
+                    type: DbNgxRouterTransitionEventType.SUCCESS
+                };
+            }
+            return event;
+        }), filterMaybe());
+    }
+    go(segueRef) {
+        let ref = segueRef.ref;
+        if (isArray(ref)) {
+            return this.router.navigate(ref, {
+                ...segueRef.refOptions,
+                queryParams: segueRef.refParams
+            });
+        }
+        else {
+            return this.router.navigateByUrl(ref, {
+                ...segueRef.refOptions
+            });
+        }
+    }
+}
+DbNgxAngularRouterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxAngularRouterService, deps: [{ token: i1$1.Router }, { token: i1$1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Injectable });
+DbNgxAngularRouterService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxAngularRouterService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxAngularRouterService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1$1.Router }, { type: i1$1.ActivatedRoute }]; } });
+
+/**
+ * Router service definition that can route the app and provide routing details.
+ */
+class DbNgxRouterService {
+}
+
+/**
+ * Router service definition that provides high level information about router transitions.
+ */
+class DbNgxRouterTransitionService {
+}
+
+class DbNgxCoreAngularRouterSegueModule {
+    static forRoot() {
+        return {
+            ngModule: DbNgxCoreAngularRouterSegueModule,
+            providers: [
+                DbNgxAngularRouterService,
+                {
+                    provide: DbNgxRouterService,
+                    useExisting: DbNgxAngularRouterService
+                },
+                {
+                    provide: DbNgxRouterTransitionService,
+                    useExisting: DbNgxAngularRouterService
+                }
+            ]
+        };
+    }
+}
+DbNgxCoreAngularRouterSegueModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreAngularRouterSegueModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DbNgxCoreAngularRouterSegueModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreAngularRouterSegueModule });
+DbNgxCoreAngularRouterSegueModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreAngularRouterSegueModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreAngularRouterSegueModule, decorators: [{
+            type: NgModule,
+            args: [{}]
+        }] });
+
+/**
+ * UIRouter implementation of DbNgxRouterService and DbNgxRouterTransitionService.
+ */
+class DbNgxUIRouterService {
+    constructor(state, transitionService, uiRouterGlobals) {
+        this.state = state;
+        this.transitionService = transitionService;
+        this.uiRouterGlobals = uiRouterGlobals;
+        this._transitions = new Subject();
+        this.transitions$ = this._transitions.asObservable();
+        const emitTransition = (type) => {
+            this._transitions.next({
+                type
+            });
+        };
+        this.transitionService.onStart({}, () => {
+            emitTransition(DbNgxRouterTransitionEventType.START);
+        });
+        this.transitionService.onSuccess({}, () => {
+            emitTransition(DbNgxRouterTransitionEventType.SUCCESS);
+        });
+    }
+    go(segueRef) {
+        const params = { ...this.uiRouterGlobals.current.params, ...segueRef.refParams };
+        return this.state.go(segueRef.ref, params, segueRef.refOptions).then(_ => true).catch(_ => false);
+    }
+}
+DbNgxUIRouterService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxUIRouterService, deps: [{ token: i1$2.StateService }, { token: i1$2.TransitionService }, { token: i1$2.UIRouterGlobals }], target: i0.ɵɵFactoryTarget.Injectable });
+DbNgxUIRouterService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxUIRouterService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxUIRouterService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1$2.StateService }, { type: i1$2.TransitionService }, { type: i1$2.UIRouterGlobals }]; } });
+
+class DbNgxCoreUIRouterSegueModule {
+    static forRoot() {
+        return {
+            ngModule: DbNgxCoreUIRouterSegueModule,
+            providers: [
+                DbNgxUIRouterService,
+                {
+                    provide: DbNgxRouterService,
+                    useExisting: DbNgxUIRouterService
+                },
+                {
+                    provide: DbNgxRouterTransitionService,
+                    useExisting: DbNgxUIRouterService
+                }
+            ]
+        };
+    }
+}
+DbNgxCoreUIRouterSegueModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreUIRouterSegueModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DbNgxCoreUIRouterSegueModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreUIRouterSegueModule });
+DbNgxCoreUIRouterSegueModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreUIRouterSegueModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreUIRouterSegueModule, decorators: [{
+            type: NgModule,
+            args: [{}]
+        }] });
+
+/**
+ * Abstract directive that listens to onSuccess transition events and runs a function.
+ */
+class AbstractTransitionWatcherDirective {
+    constructor(dbNgxRouterTransitionService, ngZone) {
+        this.dbNgxRouterTransitionService = dbNgxRouterTransitionService;
+        this.ngZone = ngZone;
+        this._transitionSub = new SubscriptionObject();
+    }
+    ngOnInit() {
+        this._transitionSub.subscription = this.dbNgxRouterTransitionService.transitions$.pipe(filter(x => x.type === DbNgxRouterTransitionEventType.SUCCESS)).subscribe(() => {
+            this.updateForSuccessfulTransition();
+        });
+    }
+    ngOnDestroy() {
+        this._transitionSub.destroy();
+    }
+    // MARK: Action
+    zoneUpdateForSuccessfulTransition() {
+        this.ngZone.run(() => this.updateForSuccessfulTransition());
+    }
+}
+AbstractTransitionWatcherDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractTransitionWatcherDirective, deps: [{ token: DbNgxRouterTransitionService }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+AbstractTransitionWatcherDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: AbstractTransitionWatcherDirective, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractTransitionWatcherDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: DbNgxRouterTransitionService }, { type: i0.NgZone }]; } });
+
+function refStringToSegueRef(ref, options) {
+    return { ...options, ref };
+}
+function mapRefStringObsToSegueRefObs(obs, options) {
+    return obs.pipe(map(x => refStringToSegueRef(x, options)));
+}
+
+// MARK: Button Directives
+class DbNgxButtonSegueDirective extends AbstractSubscriptionDirective {
+    constructor(dbxButton, dbxRouterService) {
+        super();
+        this.dbxButton = dbxButton;
+        this.dbxRouterService = dbxRouterService;
+        this._segueRef = new BehaviorSubject(undefined);
+        this.segueRef$ = this._segueRef.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));
+    }
+    get segueRef() {
+        return this._segueRef.value;
+    }
+    set segueRef(segueRef) {
+        this._segueRef.next(segueRef);
+    }
+    ngOnInit() {
+        this.sub = this.segueRef$.pipe(switchMap(segueRef => this.dbxButton.clicked$.pipe(tap(() => {
+            this.dbxRouterService.go(segueRef);
+        })))).subscribe();
+    }
+}
+DbNgxButtonSegueDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxButtonSegueDirective, deps: [{ token: DbNgxButton }, { token: DbNgxRouterService }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxButtonSegueDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxButtonSegueDirective, selector: "[dbxButtonSegue]", inputs: { segueRef: ["dbxButtonSegue", "segueRef"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxButtonSegueDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxButtonSegue]'
+                }]
+        }], ctorParameters: function () { return [{ type: DbNgxButton }, { type: DbNgxRouterService }]; }, propDecorators: { segueRef: [{
+                type: Input,
+                args: ['dbxButtonSegue']
+            }] } });
+
+/**
+ * Abstract button component.
+ */
+class AbstractDbNgxButtonDirective extends AbstractSubscriptionDirective {
+    constructor() {
+        super();
+        this._disabled = new BehaviorSubject(false);
+        this._working = new BehaviorSubject(false);
+        this.disabled$ = this._disabled.asObservable();
+        this.working$ = this._working.asObservable();
+        this.buttonClick = new EventEmitter();
+        this.clicked$ = this.buttonClick.asObservable();
+        /**
+         * Pre-interceptor button click.
+         */
+        this._buttonClick = new Subject();
+        this._buttonInterceptor = new BehaviorSubject(undefined);
+    }
+    get disabled() {
+        return this._disabled.value;
+    }
+    set disabled(disabled) {
+        this._disabled.next(disabled);
+    }
+    get working() {
+        return this._working.value;
+    }
+    set working(working) {
+        this._working.next(working);
+    }
+    ngOnInit() {
+        this.sub = this._buttonClick.pipe(switchMap(() => this._buttonInterceptor.pipe(switchMap((x) => {
+            if (x) {
+                return x.interceptButtonClick().pipe(first());
+            }
+            else {
+                return of(true);
+            }
+        }), filter((x) => Boolean(x)) // Ignore false values.
+        ))).subscribe(() => {
+            this._forceButtonClicked();
+        });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._disabled.complete();
+        this._working.complete();
+        this._buttonClick.complete();
+        this._buttonInterceptor.complete();
+    }
+    /**
+     * Sets the button interceptor. If any interceptor is already set, it is replaced.
+     */
+    setButtonInterceptor(interceptor) {
+        this._buttonInterceptor.next(interceptor);
+    }
+    /**
+     * Main function to use for handling clicks on the button.
+     */
+    clickButton() {
+        if (!this.disabled) {
+            this._buttonClick.next();
+        }
+    }
+    /**
+     * Forces a button click. Skips the interceptors if any are configured.
+     */
+    _forceButtonClicked() {
+        this.buttonClick.emit();
+    }
+}
+AbstractDbNgxButtonDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractDbNgxButtonDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+AbstractDbNgxButtonDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: AbstractDbNgxButtonDirective, inputs: { disabled: "disabled", working: "working", icon: "icon", text: "text" }, outputs: { buttonClick: "buttonClick" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractDbNgxButtonDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return []; }, propDecorators: { disabled: [{
+                type: Input
+            }], working: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], text: [{
+                type: Input
+            }], buttonClick: [{
+                type: Output
+            }] } });
+// MARK: Implementation
+/**
+ * Provides an DbNgxButton directive.
+ */
+class DbNgxButtonDirective extends AbstractDbNgxButtonDirective {
+}
+DbNgxButtonDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxButtonDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+DbNgxButtonDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxButtonDirective, selector: "[dbxButton]", providers: ProvideDbNgxButton(DbNgxButtonDirective), exportAs: ["dbxButton"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxButtonDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxButton]',
+                    exportAs: 'dbxButton',
+                    providers: ProvideDbNgxButton(DbNgxButtonDirective)
+                }]
+        }] });
+
+/**
+ * Context used for linking a button to a LoadingContext.
+ *
+ * It will be set working when the context is set loading.
+ */
+class DbNgxLoadingButtonDirective extends AbstractSubscriptionDirective {
+    constructor(button, ngZone) {
+        super();
+        this.button = button;
+        this.ngZone = ngZone;
+    }
+    /**
+     * Sets a LoadingContext that is watched for the loading state.
+     */
+    set context(context) {
+        let subscription;
+        if (context) {
+            subscription = context.stream$.subscribe((x) => {
+                this.ngZone.run(() => this.button.working = x.loading);
+            });
+        }
+        this.sub = subscription;
+    }
+}
+DbNgxLoadingButtonDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxLoadingButtonDirective, deps: [{ token: DbNgxButton, host: true }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+DbNgxLoadingButtonDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxLoadingButtonDirective, selector: "[dbxLoadingButton]", inputs: { context: ["dbxLoadingButton", "context"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxLoadingButtonDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxLoadingButton]'
+                }]
+        }], ctorParameters: function () { return [{ type: DbNgxButton, decorators: [{
+                    type: Host
+                }] }, { type: i0.NgZone }]; }, propDecorators: { context: [{
+                type: Input,
+                args: ['dbxLoadingButton']
+            }] } });
+
+class DbNgxCoreButtonModule {
+}
+DbNgxCoreButtonModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreButtonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DbNgxCoreButtonModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreButtonModule, declarations: [DbNgxButtonDirective,
+        DbNgxLoadingButtonDirective,
+        DbNgxActionButtonTriggerDirective,
+        DbNgxActionButtonDirective,
+        DbNgxButtonSegueDirective], exports: [DbNgxButtonDirective,
+        DbNgxLoadingButtonDirective,
+        DbNgxActionButtonTriggerDirective,
+        DbNgxActionButtonDirective,
+        DbNgxButtonSegueDirective] });
+DbNgxCoreButtonModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreButtonModule, imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxCoreButtonModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    declarations: [
+                        DbNgxButtonDirective,
+                        DbNgxLoadingButtonDirective,
+                        DbNgxActionButtonTriggerDirective,
+                        DbNgxActionButtonDirective,
+                        DbNgxButtonSegueDirective
+                    ],
+                    exports: [
+                        DbNgxButtonDirective,
+                        DbNgxLoadingButtonDirective,
+                        DbNgxActionButtonTriggerDirective,
+                        DbNgxActionButtonDirective,
+                        DbNgxButtonSegueDirective
+                    ],
+                }]
+        }] });
+
+/**
+ * Pipe that takes in a date and number of minutes and outputs a formatted date.
+ */
+class DateFromToTimePipe {
+    constructor(locale) {
+        this.locale = locale;
+    }
+    transform(input, format, minutes) {
+        return DateFromToTimePipe.formatFromTo(input, format, minutes, this.locale);
+    }
+    static formatFromTo(input, format, minutes, locale) {
+        if (input) {
+            const date = toJsDate(input);
+            const endDate = addMinutes(date, minutes);
+            const dateString = formatDate(date, format, locale);
+            return dateString + ' - ' + formatToTimeString(endDate);
+        }
+        return undefined;
+    }
+}
+DateFromToTimePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DateFromToTimePipe, deps: [{ token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Pipe });
+DateFromToTimePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DateFromToTimePipe, name: "dateFromPlusTo" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DateFromToTimePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'dateFromPlusTo' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCALE_ID]
+                }] }]; } });
+
+class MinutesStringPipe {
+    transform(input) {
+        const minutes = Number(input);
+        if (input != null && !isNaN(minutes)) {
+            if (minutes > 3600) {
+                const unrounded = minutes / 3600;
+                const days = Math.ceil(unrounded);
+                return ((unrounded !== days) ? '~' : '') + days + ' days';
+            }
+            else if (minutes > 180) {
+                const unrounded = minutes / 60;
+                const hours = Math.ceil(unrounded);
+                return ((unrounded !== hours) ? '~' : '') + hours + ' hours';
+            }
+            else {
+                return minutes + ' minutes';
+            }
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+MinutesStringPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: MinutesStringPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+MinutesStringPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: MinutesStringPipe, name: "minutesString", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: MinutesStringPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'minutesString', pure: false }]
+        }] });
+
+class ToJsDatePipe {
+    static toJsDate(input) {
+        return (input) ? toJsDate(input) : undefined;
+    }
+    transform(input) {
+        return ToJsDatePipe.toJsDate(input);
+    }
+}
+ToJsDatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: ToJsDatePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ToJsDatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: ToJsDatePipe, name: "toJsDate" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: ToJsDatePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'toJsDate' }]
+        }] });
+
+class TimeDistanceCountdownPipe {
+    transform(input, soonString = 'Soon', unavailable = 'Not Available') {
+        if (input) {
+            const from = ToJsDatePipe.toJsDate(input);
+            if (isPast(from)) {
+                return soonString;
+            }
+            else {
+                const to = new Date();
+                return formatDistance(from, to, {
+                    addSuffix: true
+                });
+            }
+        }
+        else {
+            return unavailable;
+        }
+    }
+}
+TimeDistanceCountdownPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: TimeDistanceCountdownPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+TimeDistanceCountdownPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: TimeDistanceCountdownPipe, name: "timeCountdownDistance", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: TimeDistanceCountdownPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'timeCountdownDistance', pure: false }]
+        }] });
+class TimeDistancePipe {
+    transform(input, to = new Date(), unavailable = 'Not Available') {
+        if (input) {
+            const from = ToJsDatePipe.toJsDate(input);
+            return formatDistance(from, to, {
+                addSuffix: true
+            });
+        }
+        else {
+            return unavailable;
+        }
+    }
+}
+TimeDistancePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: TimeDistancePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+TimeDistancePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: TimeDistancePipe, name: "timeDistance", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: TimeDistancePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'timeDistance', pure: false }]
+        }] });
+
+class ToMinutesPipe {
+    transform(milliseconds) {
+        if (milliseconds) {
+            return Math.floor(milliseconds / (60 * 1000));
+        }
+        return milliseconds;
+    }
+}
+ToMinutesPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: ToMinutesPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ToMinutesPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: ToMinutesPipe, name: "toMinutes" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: ToMinutesPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'toMinutes' }]
+        }] });
+
+/**
+ * Pipe that takes in a date and appends the distance to it in parenthesis.
+ */
+class DateFormatDistancePipe {
+    constructor(locale) {
+        this.locale = locale;
+    }
+    transform(input, format, includeSeconds = false) {
+        if (input) {
+            const date = toJsDate(input);
+            if (isValid(date)) {
+                const dateString = formatDate(date, format, this.locale);
+                const distance = formatDistanceToNow(date, {
+                    includeSeconds,
+                    addSuffix: true
+                });
+                return `${dateString} (${distance})`;
+            }
+        }
+        return undefined;
+    }
+}
+DateFormatDistancePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DateFormatDistancePipe, deps: [{ token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Pipe });
+DateFormatDistancePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DateFormatDistancePipe, name: "dateFormatDistance", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DateFormatDistancePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'dateFormatDistance', pure: false }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCALE_ID]
+                }] }]; } });
+
+class DateDistancePipe {
+    transform(input, to, unavailable = 'Not Available') {
+        if (input) {
+            const defaultTo = !to;
+            if (defaultTo) {
+                to = new Date();
+            }
+            const from = ToJsDatePipe.toJsDate(input);
+            const fromStart = startOfDay(from);
+            const toStart = startOfDay(to);
+            if (isSameDay(fromStart, toStart)) {
+                let text;
+                if (defaultTo || isSameDay(from, new Date())) {
+                    text = 'Today';
+                }
+                else {
+                    text = 'Same Day';
+                }
+                return text;
+            }
+            else {
+                return formatDistance(fromStart, toStart, {
+                    addSuffix: true
+                });
+            }
+        }
+        else {
+            return unavailable;
+        }
+    }
+}
+DateDistancePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DateDistancePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+DateDistancePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DateDistancePipe, name: "dateDistance", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DateDistancePipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'dateDistance', pure: false }]
+        }] });
+
+class DbNgxDatePipeModule {
+}
+DbNgxDatePipeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxDatePipeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DbNgxDatePipeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxDatePipeModule, declarations: [DateFromToTimePipe,
+        DateFormatDistancePipe,
+        MinutesStringPipe,
+        TimeDistanceCountdownPipe,
+        TimeDistancePipe,
+        DateDistancePipe,
+        ToJsDatePipe,
+        ToMinutesPipe], exports: [DateFromToTimePipe,
+        DateFormatDistancePipe,
+        MinutesStringPipe,
+        TimeDistanceCountdownPipe,
+        TimeDistancePipe,
+        DateDistancePipe,
+        ToJsDatePipe,
+        ToMinutesPipe] });
+DbNgxDatePipeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxDatePipeModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxDatePipeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [
+                        DateFromToTimePipe,
+                        DateFormatDistancePipe,
+                        MinutesStringPipe,
+                        TimeDistanceCountdownPipe,
+                        TimeDistancePipe,
+                        DateDistancePipe,
+                        ToJsDatePipe,
+                        ToMinutesPipe
+                    ],
+                    declarations: [
+                        DateFromToTimePipe,
+                        DateFormatDistancePipe,
+                        MinutesStringPipe,
+                        TimeDistanceCountdownPipe,
+                        TimeDistancePipe,
+                        DateDistancePipe,
+                        ToJsDatePipe,
+                        ToMinutesPipe
+                    ]
+                }]
+        }] });
+
+/**
+ * Instance used by components to inject content based on the configuration into the view.
+ */
+class DbNgxInjectedComponentInstance {
+    constructor() {
+        this._subscriptionObject = new SubscriptionObject();
+        this._config = new BehaviorSubject(undefined);
+        this._template = new BehaviorSubject(undefined);
+        this._content = new BehaviorSubject(undefined);
+        this._componentRef = new BehaviorSubject(undefined);
+        this.config$ = this._config.pipe(distinctUntilChanged());
+        this.template$ = this._template.pipe(distinctUntilChanged());
+        this.content$ = this._content.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));
+    }
+    get config() {
+        return this._config.value;
+    }
+    set config(config) {
+        this._config.next(config);
+    }
+    get template() {
+        return this._template.value;
+    }
+    set template(template) {
+        this._template.next(template);
+    }
+    get content() {
+        return this._content.value;
+    }
+    set content(content) {
+        this._content.next(content);
+    }
+    get componentRef() {
+        return this._componentRef.value;
+    }
+    set componentRef(componentRef) {
+        this._componentRef.next(componentRef);
+    }
+    init() {
+        // Wait until the first of either of the two inputs comes in as not defined, and then emit.
+        // We filter the first maybe here between the two items.
+        const configTemplateObs = combineLatest([this.config$, this.template$]).pipe(map(([config, template]) => {
+            if (config || template) {
+                return {
+                    config,
+                    template
+                };
+            }
+            else {
+                return undefined;
+            }
+        }), skipFirstMaybe());
+        this._subscriptionObject.subscription = combineLatest([configTemplateObs, this.content$]).subscribe(([inputConfig, content]) => {
+            const { config, template } = inputConfig ?? {};
+            this._reset(content);
+            if (config) {
+                this._initComponent(config, content);
+            }
+            else if (template) {
+                this._initTemplate(template, content);
+            }
+        });
+    }
+    destroy() {
+        this._config.complete();
+        this._template.complete();
+        this._content.complete();
+        this._componentRef.complete();
+    }
+    _initComponent(config, content) {
+        content.clear();
+        const { init, injector, componentClass } = config;
+        const componentRef = content.createComponent(componentClass, { injector });
+        const instance = componentRef.instance;
+        if (init) {
+            init(instance);
+        }
+        this.componentRef = componentRef;
+    }
+    _initTemplate(config, content) {
+        content.clear();
+        const { templateRef, viewRef } = config;
+        if (templateRef) {
+            content.createEmbeddedView(templateRef);
+            // TODO: Figure out if these items need to be destroyed or not when this item is destroyed. If so, we need a reference to destroy.
+        }
+        else if (viewRef) {
+            content.insert(viewRef);
+        }
+    }
+    _reset(content) {
+        if (this.componentRef) {
+            content.clear();
+            this.componentRef = undefined;
+        }
+    }
+}
+
+/**
+ * Abstract directive that injects content based on the configuration into the view.
+ */
+class AbstractDbNgxInjectedDirective {
+    constructor() {
+        this._instance = new DbNgxInjectedComponentInstance();
+    }
+    ngOnInit() {
+        this._instance.init();
+    }
+    ngOnDestroy() {
+        this._instance.destroy();
+    }
+    setConfig(config) {
+        this._instance.config = config;
+    }
+    setTemplate(template) {
+        this._instance.template = template;
+    }
+    setContent(content) {
+        this._instance.content = content;
+    }
+}
+AbstractDbNgxInjectedDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractDbNgxInjectedDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+AbstractDbNgxInjectedDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.0", type: AbstractDbNgxInjectedDirective, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AbstractDbNgxInjectedDirective, decorators: [{
+            type: Directive
+        }] });
+
+/**
+ * Component that injects content based on the configuration into the view.
+ */
+class DbNgxInjectedComponent extends AbstractDbNgxInjectedDirective {
+    set config(config) {
+        this.setConfig(config);
+    }
+    set template(template) {
+        this.setTemplate(template);
+    }
+    set content(content) {
+        this.setContent(content);
+    }
+}
+DbNgxInjectedComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxInjectedComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+DbNgxInjectedComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.0", type: DbNgxInjectedComponent, selector: "dbx-injected-content, [dbx-injected-content]", inputs: { config: "config", template: "template" }, viewQueries: [{ propertyName: "content", first: true, predicate: ["content"], descendants: true, read: ViewContainerRef, static: true }], usesInheritance: true, ngImport: i0, template: `<ng-template #content></ng-template>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxInjectedComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-injected-content, [dbx-injected-content]',
+                    template: `<ng-template #content></ng-template>`
+                }]
+        }], propDecorators: { config: [{
+                type: Input
+            }], template: [{
+                type: Input
+            }], content: [{
+                type: ViewChild,
+                args: ['content', { static: true, read: ViewContainerRef }]
+            }] } });
+
+class DbNgxInjectedComponentModule {
+}
+DbNgxInjectedComponentModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxInjectedComponentModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DbNgxInjectedComponentModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxInjectedComponentModule, declarations: [DbNgxInjectedComponent], imports: [CommonModule], exports: [DbNgxInjectedComponent] });
+DbNgxInjectedComponentModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxInjectedComponentModule, imports: [[
+            CommonModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: DbNgxInjectedComponentModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule
+                    ],
+                    declarations: [
+                        DbNgxInjectedComponent
+                    ],
+                    exports: [
+                        DbNgxInjectedComponent
+                    ],
+                }]
+        }] });
+
+class StringifySimpleStorageAccessorConverter {
+    stringifyValue(value) {
+        return JSON.stringify(value);
+    }
+    parseValue(data) {
+        return JSON.parse(data);
+    }
+}
+class WrapperSimpleStorageAccessorDelegate {
+    constructor(_delegate, _converter) {
+        this._delegate = _delegate;
+        this._converter = _converter;
+    }
+    get(key) {
+        return this._delegate.get(key);
+    }
+    set(key, value) {
+        return this._delegate.set(key, value);
+    }
+    remove(key) {
+        return this._delegate.remove(key);
+    }
+    clear() {
+        return this._delegate.clear();
+    }
+    all(prefix) {
+        return this._delegate.all(prefix);
+    }
+    allKeys(prefix) {
+        return this._delegate.allKeys(prefix);
+    }
+    stringifyValue(value) {
+        return this._converter.stringifyValue(value);
+    }
+    parseValue(data) {
+        return this._converter.parseValue(data);
+    }
+}
+/**
+ * LimitedStorageAccessor implementation that uses a Delegate
+ */
+class SimpleStorageAccessor {
+    constructor(_delegate, config) {
+        this._delegate = _delegate;
+        const prefix = config.prefix;
+        const prefixSplitter = config.prefixSplitter ?? SimpleStorageAccessor.PREFIX_SPLITTER;
+        this.assertValidStorageKeyPrefix(prefix, prefixSplitter);
+        const fullPrefix = `${prefix}${prefixSplitter}`;
+        this._config = {
+            ...config,
+            prefixSplitter,
+            fullPrefix
+        };
+    }
+    // MARK: LimitedStorageAccessor
+    get(inputKey) {
+        const storeKey = this.makeStorageKey(inputKey);
+        return this._delegate.get(storeKey).pipe(map((storedData) => {
+            if (storedData) {
+                const readStoredData = this.readStoredData(storedData);
+                if (!readStoredData.expired) {
+                    return readStoredData.convertedData;
+                }
+                else {
+                    throw new DataIsExpiredError(readStoredData);
+                }
+            }
+            else {
+                throw new DataDoesNotExistError();
+            }
+        }));
+    }
+    set(inputKey, inputValue) {
+        const storeKey = this.makeStorageKey(inputKey);
+        const storeData = this.buildStoredData(inputValue);
+        const data = JSON.stringify(storeData);
+        return this._delegate.set(storeKey, data);
+    }
+    remove(key) {
+        const storeKey = this.makeStorageKey(key);
+        return this._delegate.remove(storeKey);
+    }
+    all() {
+        return this._delegate.all(this._config.fullPrefix).pipe(map((allStoredData) => {
+            return allStoredData.map((storedData) => {
+                const readStoredData = this.readStoredData(storedData);
+                if (!readStoredData.expired) {
+                    return readStoredData.convertedData;
+                }
+                else {
+                    return null;
+                }
+            }).filter(filterMaybeValuesFn);
+        }));
+    }
+    allKeys() {
+        return this._delegate.allKeys(this._config.fullPrefix).pipe(map((keys) => keys.map(x => this.decodeStorageKey(x))));
+    }
+    clear() {
+        return this._delegate.clear();
+    }
+    // MARK: Stored Values
+    readStoredData(storedDataString) {
+        const storedData = JSON.parse(storedDataString);
+        const expired = this.isExpiredStoredData(storedData);
+        const convertedData = this._delegate.parseValue(storedData.data);
+        return {
+            ...storedData,
+            expired,
+            convertedData
+        };
+    }
+    buildStoredData(value) {
+        return {
+            storedAt: unixTimeNumberForNow(),
+            data: this.stringifyValue(value)
+        };
+    }
+    isExpiredStoredData(storeData) {
+        const expiresIn = this._config.expiresIn;
+        if (expiresIn) {
+            if (storeData.storedAt) {
+                return timeNumberHasExpired(storeData.storedAt, expiresIn);
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    // MARK: Internal
+    assertValidStorageKeyPrefix(prefix, prefixSplitter) {
+        if (!prefixSplitter) {
+            throw new Error('Invalid storage key prefix splitter. Must be defined and not empty.');
+        }
+        if (!this.isValidStorageKeyPrefix(prefix, prefixSplitter)) {
+            throw new Error('Invalid storage key prefix.');
+        }
+    }
+    isValidStorageKeyPrefix(prefix, prefixSpltter) {
+        return Boolean(prefix && prefix.indexOf(prefixSpltter) === -1);
+    }
+    makeStorageKey(key) {
+        return `${this._config.prefix}${this._config.prefixSplitter}${String(key)}`;
+    }
+    isKeyOfAccessor(storageKey) {
+        return storageKey.startsWith(this._config.fullPrefix);
+    }
+    decodeStorageKey(storageKey) {
+        const split = storageKey.split(this._config.prefixSplitter, 2);
+        return split[1];
+    }
+    stringifyValue(value) {
+        return this._delegate.stringifyValue(value);
+    }
+}
+SimpleStorageAccessor.PREFIX_SPLITTER = '::';
+
+/**
+ * Simple StorageAccessor implementation that wraps a FullStorageObject.
+ */
+class StringStorageAccessor {
+    constructor(_storage) {
+        this._storage = _storage;
+    }
+    get(key) {
+        return new Observable((x) => {
+            const value = this._storage.getItem(key);
+            x.next(value);
+            x.complete();
+        });
+    }
+    set(key, value) {
+        return new Observable((x) => {
+            this._storage.setItem(key, value);
+            x.next();
+            x.complete();
+        });
+    }
+    remove(key) {
+        return new Observable((x) => {
+            this._storage.removeItem(key);
+            x.next();
+            x.complete();
+        });
+    }
+    clear() {
+        const removed = this._storage.removeAll();
+        return new Observable((x) => {
+            x.next(removed);
+            x.complete();
+        });
+    }
+    all() {
+        return this.allKeys().pipe(map(x => x.map(y => this._storage.getItem(y))), shareReplay(1));
+    }
+    allKeys() {
+        return new Observable((x) => {
+            const result = StorageObjectUtility.allKeysFromStorageObject(this._storage);
+            x.next(result);
+            x.complete();
+        });
+    }
+}
+
+const DEFAULT_STORAGE_OBJECT_TOKEN = new InjectionToken('DEFAULT_STORAGE_OBJECT');
+const DEFAULT_STORAGE_ACCESSOR_FACTORY_TOKEN = new InjectionToken('DEFAULT_STORAGE_ACCESSOR_FACTORY');
+
+/**
+ * Used for building SimpleStorageAccessor instances from SimpleStorageAccessorConfig.
+ */
+class SimpleStorageAccessorFactory {
+    constructor(storageObject) {
+        this.storageObject = storageObject;
+    }
+    createStorageAccessor(config) {
+        const storage = config.storage ?? new StringStorageAccessor(this.storageObject);
+        const converter = config.converter ?? new StringifySimpleStorageAccessorConverter();
+        const delegate = new WrapperSimpleStorageAccessorDelegate(storage, converter);
+        const accessorConfig = {
+            prefix: config.prefix
+        };
+        return new SimpleStorageAccessor(delegate, accessorConfig);
+    }
+}
+SimpleStorageAccessorFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: SimpleStorageAccessorFactory, deps: [{ token: DEFAULT_STORAGE_OBJECT_TOKEN }], target: i0.ɵɵFactoryTarget.Injectable });
+SimpleStorageAccessorFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: SimpleStorageAccessorFactory });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: SimpleStorageAccessorFactory, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1$3.FullStorageObject, decorators: [{
+                    type: Inject,
+                    args: [DEFAULT_STORAGE_OBJECT_TOKEN]
+                }] }]; } });
+
+/**
+ * Stored object accessor that can get/set/remove via a key, or be cleared entirely.
+ */
+class LimitedStorageAccessor {
+}
+/**
+ * LimitedStorageAccessor extension that has knowledge of all stored keys.
+ */
+class StorageAccessor extends LimitedStorageAccessor {
+}
+/**
+ * StorageAccessor-like object that has immediate/synchronous functionality for get/set.
+ */
+class InstantStorageAccessor {
+}
+
+/**
+ * StorageObject using LocalStorage.
+ */
+class FullLocalStorageObject {
+    constructor(_localStorage) {
+        this._localStorage = _localStorage;
+    }
+    get isPersistant() {
+        return true;
+    }
+    get isAvailable() {
+        const test = '_T_E_S_T_';
+        try {
+            // Tests setting and removing an item. These will throw an
+            // exception if the localstorage is not available
+            this._localStorage.setItem(test, test);
+            this._localStorage.removeItem(test);
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    get length() {
+        return this._localStorage.length;
+    }
+    getItem(key) {
+        return this._localStorage.getItem(key);
+    }
+    setItem(key, item) {
+        this._localStorage.setItem(key, item);
+    }
+    removeItem(key) {
+        this._localStorage.removeItem(key);
+    }
+    key(index) {
+        return this._localStorage.key(index);
+    }
+    removeAll() {
+        const keys = StorageObjectUtility.allKeysFromStorageObject(this);
+        keys.forEach(x => this.removeItem(x));
+        return keys;
+    }
+}
+
+/**
+ * FullStorageObject implementation that uses a localstorage that entirely resides in memory.
+ */
+class MemoryStorageObject extends FullLocalStorageObject {
+    get isLastingStorage() {
+        return false;
+    }
+    get isAvailable() {
+        return true;
+    }
+    constructor() {
+        super(SHARED_MEMORY_STORAGE);
+    }
+}
+
+function defaultStorageObjectFactory() {
+    let storageObject = new FullLocalStorageObject(localStorage);
+    if (!storageObject.isAvailable) {
+        storageObject = new MemoryStorageObject();
+    }
+    return storageObject;
+}
+class AppStorageModule {
+    static forRoot() {
+        return {
+            ngModule: AppStorageModule,
+            providers: [{
+                    provide: DEFAULT_STORAGE_OBJECT_TOKEN,
+                    useFactory: defaultStorageObjectFactory
+                }, {
+                    provide: DEFAULT_STORAGE_ACCESSOR_FACTORY_TOKEN,
+                    useClass: SimpleStorageAccessorFactory
+                }, {
+                    provide: SimpleStorageAccessorFactory,
+                    useExisting: DEFAULT_STORAGE_ACCESSOR_FACTORY_TOKEN
+                }]
+        };
+    }
+}
+AppStorageModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AppStorageModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AppStorageModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AppStorageModule });
+AppStorageModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AppStorageModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.0", ngImport: i0, type: AppStorageModule, decorators: [{
+            type: NgModule
+        }] });
+
+/**
+ * Triggers a detection change on the input view as long as the view has not been destroyed.
+ *
+ * @param cdRef
+ */
+function safeDetectChanges(cdRef) {
+    if (!cdRef.destroyed) {
+        cdRef.detectChanges();
+    }
+}
+/**
+ * Used to check an injected ElementRef that wraps an ng-content injection point whether or not any content was injected,
+ * or more specifically if the parent component passed any target content to the child. This will still return true if
+ * passed content is empty.
+ *
+ * TS:
+ * @ViewChild('customLoading', { static: false }) customCustom: ElementRef;
+ *
+ * HTML:
+ * <div #customContent>
+ *  <ng-content select="[content]"></ng-content>
+ * </div>
+ */
+function checkNgContentWrapperHasContent(ref) {
+    // https://github.com/angular/angular/issues/26083
+    let hasContent = false;
+    if (ref != null) {
+        const childNodes = ref.nativeElement.childNodes;
+        const hasChildNodes = childNodes && childNodes.length > 0;
+        hasContent = Boolean(hasChildNodes);
+    }
+    return hasContent;
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { APP_ACTION_DISABLED_DIRECTIVE_KEY, APP_ACTION_DISABLED_UNTIL_MODIFIED_DIRECTIVE_KEY, AbstractDbNgxAnchorDirective, AbstractDbNgxButtonDirective, AbstractDbNgxInjectedDirective, AbstractLockSetSubscriptionDirective, AbstractSubscriptionDirective, AbstractTransitionWatcherDirective, ActionContextBaseSource, ActionContextMachine, ActionContextStore, ActionContextStoreSource, ActionContextStoreSourceInstance, ActionContextStoreSourceMap, ActionSnackbarDefaultType, ActionSnackbarEventType, ActionState, AnchorType, AppStorageModule, DEFAULT_ACTION_DISABLED_KEY, DEFAULT_ACTION_MAP_WORKING_DISABLED_KEY, DEFAULT_SNACKBAR_DIRECTIVE_DURATION, DEFAULT_SNACKBAR_UNDO_DIRECTIVE_DURATION, DEFAULT_STORAGE_ACCESSOR_FACTORY_TOKEN, DEFAULT_STORAGE_OBJECT_TOKEN, DateDistancePipe, DateFormatDistancePipe, DateFromToTimePipe, DbNgxActionAutoModifyDirective, DbNgxActionAutoTriggerDirective, DbNgxActionAutoTriggerValueDirective, DbNgxActionButtonDirective, DbNgxActionButtonTriggerDirective, DbNgxActionComponent, DbNgxActionContextDirective, DbNgxActionContextLoggerDirective, DbNgxActionContextMapDirective, DbNgxActionContextMapDirectiveSourceInstance, DbNgxActionDisabledDirective, DbNgxActionDisabledUntilModifiedDirective, DbNgxActionFromMapDirective, DbNgxActionHandlerDirective, DbNgxActionMapSourceDirective, DbNgxActionMapWorkingDisableDirective, DbNgxActionSourceDirective, DbNgxActionSuccessComponent, DbNgxActionSuccessDirective, DbNgxActionValueDirective, DbNgxActionWorkingComponent, DbNgxAnchor, DbNgxAngularRouterService, DbNgxButton, DbNgxButtonDirective, DbNgxButtonSegueDirective, DbNgxCoreActionModule, DbNgxCoreAngularRouterSegueModule, DbNgxCoreButtonModule, DbNgxCoreUIRouterSegueModule, DbNgxDatePipeModule, DbNgxInjectedComponent, DbNgxInjectedComponentInstance, DbNgxInjectedComponentModule, DbNgxLoadingButtonDirective, DbNgxRouterService, DbNgxRouterTransitionEventType, DbNgxRouterTransitionService, DbNgxUIRouterService, FullLocalStorageObject, InstantStorageAccessor, LimitedStorageAccessor, MemoryStorageObject, MinutesStringPipe, ProvideActionStoreSource, ProvideDbNgxAnchor, ProvideDbNgxButton, ProvideSecondaryActionStoreSource, SecondaryActionContextStoreSource, SimpleStorageAccessor, SimpleStorageAccessorFactory, StorageAccessor, StringStorageAccessor, StringifySimpleStorageAccessorConverter, TimeDistanceCountdownPipe, TimeDistancePipe, ToJsDatePipe, ToMinutesPipe, WorkHandlerContext, WorkHandlerContextSourceDelegate, WrapperSimpleStorageAccessorDelegate, actionContextHasNoErrorAndIsModifiedAndCanTrigger, actionContextIsModifiedAndCanTrigger, actionContextStoreSourceInstanceFactory, actionContextStoreSourcePipe, anchorTypeForAnchor, canReadyValue, canTriggerAction, canTriggerActionState, checkNgContentWrapperHasContent, defaultStorageObjectFactory, handleWorkValueReadyFn, handleWorkValueReadyWithConfigFn, isActionContextDisabled, isActionContextEnabled, isDisabledActionContextState, isIdleActionState, isWorkingActionState, mapRefStringObsToSegueRefObs, pipeActionStore, refStringToSegueRef, safeDetectChanges, useActionStore };
+//# sourceMappingURL=dereekb-dbx-core.mjs.map