@dereekb/dbx-core 0.0.1

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

@@ -0,0 +1,149 @@
+import { first, switchMap } from 'rxjs/operators';
+import { Directive, forwardRef } from '@angular/core';
+import { LockSet, filterMaybe } from '@dereekb/rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Source that provides a ActionContextStore observable.
+ */
+export class ActionContextStoreSource {
+}
+/**
+ * Secondary source. Used by DbNgxActionContextComponent to find secondary sources.
+ */
+export class SecondaryActionContextStoreSource extends ActionContextStoreSource {
+}
+export function actionContextStoreSourcePipe(obs) {
+    return obs.pipe(filterMaybe());
+}
+export function pipeActionStore(source, pipeFn) {
+    return source.store$.pipe(switchMap(pipeFn));
+}
+/**
+ * Convenience function for subscribing to the input source once and using the provided store.
+ */
+export function useActionStore(source, useFn) {
+    return source.store$.pipe(first()).subscribe(useFn);
+}
+// tslint:disable-next-line: directive-class-suffix
+export 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 }]; } });
+export const actionContextStoreSourceInstanceFactory = (source) => {
+    return new ActionContextStoreSourceInstance(source);
+};
+/**
+ * Provides an ActionContextStoreSource, as well as an ActionContextStoreSourceInstance.
+ */
+export function ProvideActionStoreSource(sourceType) {
+    return [{
+            provide: ActionContextStoreSource,
+            useExisting: forwardRef(() => sourceType)
+        },
+        {
+            provide: ActionContextStoreSourceInstance,
+            useFactory: actionContextStoreSourceInstanceFactory,
+            deps: [ActionContextStoreSource]
+        }];
+}
+export function ProvideSecondaryActionStoreSource(sourceType) {
+    return [{
+            provide: SecondaryActionContextStoreSource,
+            useExisting: forwardRef(() => sourceType)
+        },
+        ...ProvideActionStoreSource(sourceType)
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action.store.source.js","sourceRoot":"","sources":["../../../../../../packages/dbx-core/src/lib/action/action.store.source.ts"],"names":[],"mappings":"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","sourcesContent":["import { first, switchMap } from 'rxjs/operators';\nimport { Observable, Subscription } from 'rxjs';\nimport { Directive, forwardRef, Provider, Type } from '@angular/core';\nimport { LockSet, filterMaybe } from '@dereekb/rxjs';\nimport { OnDestroy } from '@angular/core';\nimport { Maybe, ReadableError } from '@dereekb/util';\nimport { ActionContextState, ActionContextStore } from './action.store';\nimport { ActionDisabledKey, ActionState } from './action';\n\n/**\n * Source that provides a ActionContextStore observable.\n */\nexport abstract class ActionContextStoreSource<T = any, O = any> {\n  /**\n   * Observable referencing the ActionContextStore.\n   *\n   * This observable by design is pre-filtered to not return null values.\n   */\n  abstract readonly store$: Observable<ActionContextStore<T, O>>;\n}\n\n/**\n * Secondary source. Used by DbNgxActionContextComponent to find secondary sources.\n */\nexport abstract class SecondaryActionContextStoreSource<T = any, O = any> extends ActionContextStoreSource<T, O> { }\n\nexport function actionContextStoreSourcePipe<T, O>(obs: Observable<Maybe<ActionContextStore<T, O>>>): Observable<ActionContextStore<T, O>> {\n  return obs.pipe(filterMaybe());\n}\n\nexport type PipeActionStoreFunction<R, T, O> = (store: ActionContextStore<T, O>) => Observable<R>;\n\nexport function pipeActionStore<R = any, T = any, O = any>(source: ActionContextStoreSource<T, O>, pipeFn: PipeActionStoreFunction<R, T, O>): Observable<R> {\n  return source.store$.pipe(\n    switchMap(pipeFn)\n  );\n}\n\nexport type UseActionStoreFunction<T, O> = (store: ActionContextStore<T, O>) => void;\n\n/**\n * Convenience function for subscribing to the input source once and using the provided store.\n */\nexport function useActionStore<T = any, O = any>(source: ActionContextStoreSource<T, O>, useFn: UseActionStoreFunction<T, O>): Subscription {\n  return source.store$.pipe(first()).subscribe(useFn);\n}\n\n@Directive()\n// tslint:disable-next-line: directive-class-suffix\nexport class ActionContextStoreSourceInstance<T = any, O = any> implements OnDestroy {\n\n  readonly lockSet = new LockSet();\n\n  constructor(readonly source: ActionContextStoreSource<T, O>) {\n    if (!source) {\n      throw new Error('Source is required.');\n    }\n  }\n\n  public ngOnDestroy(): void {\n    this.lockSet.destroyOnNextUnlock();\n  }\n\n  // MARK: Store\n  get store$(): Observable<ActionContextStore<T, O>> {\n    return this.source.store$;\n  }\n\n  pipeStore<R>(pipeFn: PipeActionStoreFunction<R, T, O>): Observable<R> {\n    return pipeActionStore(this.source, pipeFn);\n  }\n\n  useStore(useFn: UseActionStoreFunction<T, O>): Subscription {\n    return useActionStore(this.source, useFn);\n  }\n\n  get state$(): Observable<ActionContextState<T, O>> {\n    return this.pipeStore(x => x.state$);\n  }\n\n  get triggered$(): Observable<boolean> {\n    return this.pipeStore(x => x.triggered$);\n  }\n\n  get valueReady$(): Observable<T> {\n    return this.pipeStore(x => x.valueReady$);\n  }\n\n  get success$(): Observable<O> {\n    return this.pipeStore(x => x.success$);\n  }\n\n  get error$(): Observable<Maybe<ReadableError>> {\n    return this.pipeStore(x => x.error$);\n  }\n\n  get rejected$(): Observable<Maybe<ReadableError>> {\n    return this.pipeStore(x => x.rejected$);\n  }\n\n  get isModified$(): Observable<boolean> {\n    return this.pipeStore(x => x.isModified$);\n  }\n\n  get isModifiedAndCanTriggerUpdates$(): Observable<boolean> {\n    return this.pipeStore(x => x.isModifiedAndCanTriggerUpdates$);\n  }\n\n  get isModifiedAndCanTrigger$(): Observable<boolean> {\n    return this.pipeStore(x => x.isModifiedAndCanTrigger$);\n  }\n\n  get actionState$(): Observable<ActionState> {\n    return this.pipeStore(x => x.actionState$);\n  }\n\n  get isWorking$(): Observable<boolean> {\n    return this.pipeStore(x => x.isWorking$);\n  }\n\n  get isSuccess$(): Observable<boolean> {\n    return this.pipeStore(x => x.isSuccess$);\n  }\n\n  get isDisabled$(): Observable<boolean> {\n    return this.pipeStore(x => x.isDisabled$);\n  }\n\n  get errorCountSinceLastSuccess$(): Observable<number> {\n    return this.pipeStore(x => x.errorCountSinceLastSuccess$);\n  }\n\n  public enable(key?: ActionDisabledKey, enable = true): void {\n    this.disable(key, !enable);\n  }\n\n  public disable(key?: ActionDisabledKey, disable = true): void {\n    this.useStore((x) => (disable) ? x.disable(key) : x.enable(key));\n  }\n\n  public setIsModified(isModified?: boolean | Observable<boolean> | Observable<void>): void {\n    this.useStore((x) => x.setIsModified(isModified));\n  }\n\n  public trigger(): void {\n    this.useStore((x) => x.trigger());\n  }\n\n  public readyValue(value: Maybe<T | Observable<T>>): void {\n    this.useStore((x) => x.readyValue(value));\n  }\n\n  public startWorking(): void {\n    this.useStore((x) => x.startWorking());\n  }\n\n  public reject(error: Maybe<ReadableError | Observable<ReadableError>>): void {\n    this.useStore((x) => x.reject(error));\n  }\n\n  public success(value: O | Observable<O>): void {\n    this.useStore((x) => x.success(value));\n  }\n\n  public reset(): void {\n    this.useStore((x) => x.reset());\n  }\n\n}\n\nexport const actionContextStoreSourceInstanceFactory = (source: ActionContextStoreSource) => {\n  return new ActionContextStoreSourceInstance(source);\n};\n\n/**\n * Provides an ActionContextStoreSource, as well as an ActionContextStoreSourceInstance.\n */\nexport function ProvideActionStoreSource<S>(sourceType: Type<S>): Provider[] {\n  return [{\n    provide: ActionContextStoreSource,\n    useExisting: forwardRef(() => sourceType)\n  },\n  {\n    provide: ActionContextStoreSourceInstance,\n    useFactory: actionContextStoreSourceInstanceFactory,\n    deps: [ActionContextStoreSource]\n  }];\n}\n\nexport function ProvideSecondaryActionStoreSource<S>(sourceType: Type<S>): Provider[] {\n  return [{\n    provide: SecondaryActionContextStoreSource,\n    useExisting: forwardRef(() => sourceType)\n  },\n  ...ProvideActionStoreSource(sourceType)\n  ];\n}\n"]}

package/esm2020/lib/action/directive/auto/action.automodify.directive.mjs

@@ -0,0 +1,53 @@
+import { Directive, Input } from '@angular/core';
+import { AbstractSubscriptionDirective } from '../../../subscription';
+import { distinctUntilChanged, filter } from 'rxjs/operators';
+import { combineLatest } from 'rxjs';
+import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { Host } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../action.store.source";
+export 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: i1.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: i1.ActionContextStoreSourceInstance, decorators: [{
+                    type: Host
+                }] }]; }, propDecorators: { autoModifyEnabled: [{
+                type: Input,
+                args: ['dbxActionAutoModify']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/action/directive/auto/action.autotrigger.directive.mjs

@@ -0,0 +1,131 @@
+import { Directive, Input } from '@angular/core';
+import { AbstractSubscriptionDirective } from '../../../subscription';
+import { debounce, distinctUntilChanged, exhaustMap, filter, first, map, mergeMap, shareReplay, switchMap, throttle } from 'rxjs/operators';
+import { EMPTY, interval, Subject, combineLatest } from 'rxjs';
+import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { Host } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../action.store.source";
+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.
+ */
+export 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: i1.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: i1.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
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action.autotrigger.directive.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-core/src/lib/action/directive/auto/action.autotrigger.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Input, OnInit, OnDestroy } from '@angular/core';\nimport { AbstractSubscriptionDirective } from '../../../subscription';\nimport { debounce, distinctUntilChanged, exhaustMap, filter, first, map, mergeMap, shareReplay, switchMap, throttle } from 'rxjs/operators';\nimport { EMPTY, interval, Subject, combineLatest } from 'rxjs';\nimport { Observable } from 'rxjs';\nimport { ActionContextStoreSourceInstance } from '../../action.store.source';\nimport { Host } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\nimport { Maybe } from '@dereekb/util';\n\nconst DEFAULT_DEBOUNCE_MS = 2 * 1000;\n\nconst DEFAULT_THROTTLE_MS = 10 * 1000;\n\nconst DEFAULT_ERROR_THROTTLE_MS = 3 * 1000;\n\nconst MAX_ERRORS_TO_THROTTLE_ON = 6;\n\n/**\n * Extension of DbNgxActionTransitionSafetyDirective that automatically triggers the action periodically when it is in a modified state.\n */\n@Directive({\n  selector: '[dbxActionAutoTrigger]',\n})\nexport class DbNgxActionAutoTriggerDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {\n\n  private _triggerEnabled = new BehaviorSubject<boolean>(true);\n\n  /**\n   * How much to throttle the auto-triggering.\n   */\n  @Input('dbxActionAutoTrigger')\n  get triggerEnabled(): boolean {\n    return this._triggerEnabled.value;\n  }\n\n  set triggerEnabled(triggerEnabled: boolean) {\n    triggerEnabled = triggerEnabled !== false;  // Default to true\n\n    if (this.triggerEnabled !== triggerEnabled) {\n      this._triggerEnabled.next(triggerEnabled);\n    }\n  }\n\n  @Input()\n  triggerDebounce = DEFAULT_DEBOUNCE_MS;\n\n  @Input()\n  triggerThrottle = DEFAULT_THROTTLE_MS;\n\n  @Input()\n  triggerErrorThrottle = DEFAULT_ERROR_THROTTLE_MS;\n\n  maxErrorsForThrottle = MAX_ERRORS_TO_THROTTLE_ON;\n\n  /**\n   * Optional input to override both triggerDebounce and triggerThrottle.\n   *\n   * Used in forms that are simple.\n   */\n  @Input()\n  set fastTrigger(fastTrigger: boolean) {\n    if (fastTrigger) {\n      this.triggerDebounce = 200;\n      this.triggerThrottle = 500;\n    }\n  }\n\n  /**\n   * Optional input to override both triggerDebounce and triggerThrottle to be 0.\n   *\n   * Used in forms that generally return a single value.\n   */\n  @Input()\n  set instantTrigger(instantTrigger: boolean) {\n    if (instantTrigger) {\n      this.triggerDebounce = 10;\n      this.triggerThrottle = 0;\n    }\n  }\n\n  @Input()\n  get triggerLimit(): Maybe<number> {\n    return this._triggerLimit.value;\n  }\n\n  set triggerLimit(triggerLimit: Maybe<number>) {\n    triggerLimit = triggerLimit || 0;\n    this._triggerLimit.next(triggerLimit);\n  }\n\n  private readonly _triggerLimit = new BehaviorSubject<number | undefined>(undefined);\n  private readonly _trigger = new Subject<number>();\n  private _triggerCount = 0;\n\n  readonly _errorCount$ = this.source.errorCountSinceLastSuccess$;\n\n  readonly _triggerCount$ = this.source.isModifiedAndCanTriggerUpdates$.pipe(\n    filter(() => this.isEnabled),\n    filter((x) => x),\n    debounce(() => interval(this.triggerDebounce)),\n    throttle(() => this._errorCount$.pipe(\n      first(),\n      exhaustMap((count) => interval(this.triggerThrottle + (Math.min(count, this.maxErrorsForThrottle) * this.triggerErrorThrottle)))\n    ), { leading: true, trailing: true }),\n    // Check again for the \"trailing\" piece.\n    filter(() => this.isEnabled),\n    mergeMap(() => this.source.isModifiedAndCanTrigger$.pipe(first())),\n    filter((x) => x),\n    map(() => this._triggerCount += 1),\n    shareReplay(1)\n  );\n\n  /**\n   * Observable for the trigger mechanism.\n   */\n  readonly triggerCount$ = this._triggerEnabled.pipe(\n    switchMap((enabled) => {\n      if (enabled) {\n        return this._triggerCount$;\n      } else {\n        return EMPTY;\n      }\n    })\n  );\n\n  private readonly _isTriggerLimited$: Observable<[number, boolean]> =\n    combineLatest([this.triggerCount$, this._triggerLimit]).pipe(\n      map(([triggerCount, limit]) => [triggerCount, ((limit) ? (triggerCount > limit) : false)] as [number, boolean]),\n      shareReplay(1)\n    );\n\n  readonly isTriggerLimited$ = this._isTriggerLimited$.pipe(map(x => x[1]));\n  readonly trigger$: Observable<void> = this._isTriggerLimited$.pipe(\n    filter(x => !x[1]),\n    distinctUntilChanged((a, b) => a[0] === b[0]),    // Only trigger when the count changes.\n    map(() => undefined as void)\n  );\n\n  constructor(@Host() public readonly source: ActionContextStoreSourceInstance<T, O>) {\n    super();\n  }\n\n  get isEnabled(): boolean {\n    return this.triggerEnabled !== false;\n  }\n\n  ngOnInit(): void {\n    this.sub = this.trigger$.subscribe(() => {\n      this.source.trigger();\n    });\n  }\n\n  override ngOnDestroy(): void {\n    this.source.lockSet.onNextUnlock(() => {\n      super.ngOnDestroy();\n      this._trigger.complete();\n      this._triggerLimit.complete();\n    });\n  }\n\n}\n"]}

package/esm2020/lib/action/directive/auto/action.autotrigger.value.directive.mjs

@@ -0,0 +1,79 @@
+import { ActionContextStoreSourceInstance } from '../../action.store.source';
+import { switchMap, mergeMap, map, withLatestFrom, shareReplay } from 'rxjs/operators';
+import { Directive, Host, Input } from '@angular/core';
+import { BehaviorSubject, Observable, of, EMPTY } from 'rxjs';
+import { hasValueOrNotEmpty } from '@dereekb/util';
+import { SubscriptionObject } from '@dereekb/rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../action.store.source";
+/**
+ * Directive that watches an observable for changes and sets the new value and modified states as necessary.
+ */
+export 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: i1.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: i1.ActionContextStoreSourceInstance, decorators: [{
+                    type: Host
+                }] }]; }, propDecorators: { dbxActionAutoTriggerValue: [{
+                type: Input,
+                args: ['dbxActionAutoTriggerValue']
+            }], dbxActionAutoTriggerModifiedNonEmptyValue: [{
+                type: Input
+            }], dbxActionAutoTriggerModified: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/action/directive/auto/index.mjs

@@ -0,0 +1,4 @@
+export * from './action.automodify.directive';
+export * from './action.autotrigger.directive';
+export * from './action.autotrigger.value.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtY29yZS9zcmMvbGliL2FjdGlvbi9kaXJlY3RpdmUvYXV0by9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxzQ0FBc0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYWN0aW9uLmF1dG9tb2RpZnkuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vYWN0aW9uLmF1dG90cmlnZ2VyLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2FjdGlvbi5hdXRvdHJpZ2dlci52YWx1ZS5kaXJlY3RpdmUnO1xuIl19

package/esm2020/lib/action/directive/context/action.component.mjs

@@ -0,0 +1,18 @@
+import { Component } from '@angular/core';
+import { ProvideActionStoreSource } from '../../action.store.source';
+import { DbNgxActionContextDirective } from './action.directive';
+import * as i0 from "@angular/core";
+export 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)
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9uLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2RieC1jb3JlL3NyYy9saWIvYWN0aW9uL2RpcmVjdGl2ZS9jb250ZXh0L2FjdGlvbi5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMxQyxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNyRSxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQzs7QUFTakUsTUFBTSxPQUFPLG9CQUF1QyxTQUFRLDJCQUFpQzs7aUhBQWhGLG9CQUFvQjtxR0FBcEIsb0JBQW9CLHFDQUZwQix3QkFBd0IsQ0FBQyxvQkFBb0IsQ0FBQyx1RUFGL0MsMkJBQTJCOzJGQUkxQixvQkFBb0I7a0JBUGhDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLFlBQVk7b0JBQ3RCLFFBQVEsRUFBRSxRQUFRO29CQUNsQixRQUFRLEVBQUUsMkJBQTJCO29CQUVyQyxTQUFTLEVBQUUsd0JBQXdCLHNCQUFzQjtpQkFDMUQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFByb3ZpZGVBY3Rpb25TdG9yZVNvdXJjZSB9IGZyb20gJy4uLy4uL2FjdGlvbi5zdG9yZS5zb3VyY2UnO1xuaW1wb3J0IHsgRGJOZ3hBY3Rpb25Db250ZXh0RGlyZWN0aXZlIH0gZnJvbSAnLi9hY3Rpb24uZGlyZWN0aXZlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnZGJ4LWFjdGlvbicsXG4gIGV4cG9ydEFzOiAnYWN0aW9uJyxcbiAgdGVtcGxhdGU6ICc8bmctY29udGVudD48L25nLWNvbnRlbnQ+JyxcbiAgXG4gIHByb3ZpZGVyczogUHJvdmlkZUFjdGlvblN0b3JlU291cmNlKERiTmd4QWN0aW9uQ29tcG9uZW50KVxufSlcbmV4cG9ydCBjbGFzcyBEYk5neEFjdGlvbkNvbXBvbmVudDxUID0gYW55LCBPID0gYW55PiBleHRlbmRzIERiTmd4QWN0aW9uQ29udGV4dERpcmVjdGl2ZTxULCBPPiAgeyB9XG4iXX0=

package/esm2020/lib/action/directive/context/action.directive.mjs

@@ -0,0 +1,33 @@
+import { Directive, Optional, Host } from '@angular/core';
+import { ProvideActionStoreSource, SecondaryActionContextStoreSource } from '../../action.store.source';
+import { ActionContextBaseSource } from '../../action.holder';
+import * as i0 from "@angular/core";
+import * as i1 from "../../action.store.source";
+/**
+ * Provides an DbNgxActionContext.
+ */
+export 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: i1.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: i1.SecondaryActionContextStoreSource, decorators: [{
+                    type: Optional
+                }, {
+                    type: Host
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/action/directive/context/action.source.directive.mjs

@@ -0,0 +1,40 @@
+import { filterMaybe } from '@dereekb/rxjs';
+import { Directive, Input } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+import { ProvideSecondaryActionStoreSource, actionContextStoreSourcePipe } from '../../action.store.source';
+import * as i0 from "@angular/core";
+/**
+ * Directive that provides a DbNgxActionSourceDirective that is passed in.
+ */
+export 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']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/action/directive/context/index.mjs

@@ -0,0 +1,4 @@
+export * from './action.component';
+export * from './action.directive';
+export * from './action.source.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtY29yZS9zcmMvbGliL2FjdGlvbi9kaXJlY3RpdmUvY29udGV4dC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYWN0aW9uLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2FjdGlvbi5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9hY3Rpb24uc291cmNlLmRpcmVjdGl2ZSc7XG4iXX0=