@dereekb/dbx-core 0.0.1 → 1.2.0

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

@@ -17,7 +17,7 @@ export declare class WorkHandlerContextSourceDelegate<T = any, O = any> implemen
     reject(error: any): void;
 }
 /**
- * Used by DbNgxActionHandlerDirective when handling a function.
+ * Used by DbxActionHandlerDirective when handling a function.
  */
 export declare class WorkHandlerContext<T = any, O = any> implements Destroyable {
     readonly value: T;

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

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

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

@@ -18,7 +18,7 @@ export declare abstract class ActionContextStoreSource<T = any, O = any> {
     abstract readonly store$: Observable<ActionContextStore<T, O>>;
 }
 /**
- * Secondary source. Used by DbNgxActionContextComponent to find secondary sources.
+ * Secondary source. Used by DbxActionContextComponent to find secondary sources.
  */
 export declare abstract class SecondaryActionContextStoreSource<T = any, O = any> extends ActionContextStoreSource<T, O> {
 }

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

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

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

@@ -5,16 +5,16 @@ import { ActionContextStoreSourceInstance } from '../../action.store.source';
 import { Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
 /**
- * Extension of DbNgxActionTransitionSafetyDirective that automatically triggers the action periodically when it is in a modified state.
+ * Extension of DbxActionTransitionSafetyDirective that automatically triggers the action periodically when it is in a modified state.
  */
-export declare class DbNgxActionAutoTriggerDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxActionAutoTriggerDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
     readonly source: ActionContextStoreSourceInstance<T, O>;
     private _triggerEnabled;
     /**
      * How much to throttle the auto-triggering.
      */
     get triggerEnabled(): boolean;
-    set triggerEnabled(triggerEnabled: boolean);
+    set triggerEnabled(triggerEnabled: Maybe<boolean> | any);
     triggerDebounce: number;
     triggerThrottle: number;
     triggerErrorThrottle: number;
@@ -49,6 +49,6 @@ export declare class DbNgxActionAutoTriggerDirective<T, O> extends AbstractSubsc
     get isEnabled(): boolean;
     ngOnInit(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionAutoTriggerDirective<any, any>, [{ host: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionAutoTriggerDirective<any, any>, "[dbxActionAutoTrigger]", never, { "triggerEnabled": "dbxActionAutoTrigger"; "triggerDebounce": "triggerDebounce"; "triggerThrottle": "triggerThrottle"; "triggerErrorThrottle": "triggerErrorThrottle"; "fastTrigger": "fastTrigger"; "instantTrigger": "instantTrigger"; "triggerLimit": "triggerLimit"; }, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionAutoTriggerDirective<any, any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionAutoTriggerDirective<any, any>, "dbxActionAutoTrigger, [dbxActionAutoTrigger]", never, { "triggerEnabled": "dbxActionAutoTrigger"; "triggerDebounce": "triggerDebounce"; "triggerThrottle": "triggerThrottle"; "triggerErrorThrottle": "triggerErrorThrottle"; "fastTrigger": "fastTrigger"; "instantTrigger": "instantTrigger"; "triggerLimit": "triggerLimit"; }, {}, never>;
 }

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

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

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

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

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

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

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

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

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

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

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

@@ -9,7 +9,7 @@ import * as i0 from "@angular/core";
  *
  * This is useful for passing action contexts around via the providers instead of explicit injection.
  */
-export declare class DbNgxActionContextMapDirective implements ActionContextStoreSourceMap, OnDestroy {
+export declare class DbxActionContextMapDirective implements ActionContextStoreSourceMap, OnDestroy {
     private readonly _map;
     readonly map$: Observable<Map<string, ActionContextStoreSource<any, any>>>;
     readonly areAnyWorking$: Observable<boolean>;
@@ -22,14 +22,14 @@ export declare class DbNgxActionContextMapDirective implements ActionContextStor
     checkAnyAre(mapFn: (input: ActionContextStore) => Observable<boolean>, emptyArrayValue?: boolean): Observable<boolean>;
     reduceFromAllSources<O, R>(mapFn: (input: ActionContextStore) => Observable<O>, reduceFn: (values: O[]) => R): Observable<R>;
     fromAllSources<O>(mapFn: (input: ActionContextStore) => Observable<O>): Observable<O[]>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionContextMapDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionContextMapDirective, "[dbxActionContextMap]", ["actionMap"], {}, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionContextMapDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionContextMapDirective, "[dbxActionContextMap]", ["actionMap"], {}, {}, never>;
 }
-export declare class DbNgxActionContextMapDirectiveSourceInstance implements ActionContextStoreSource {
+export declare class DbxActionContextMapDirectiveSourceInstance implements ActionContextStoreSource {
     private readonly parent;
     readonly key: ActionKey;
     readonly _source$: Observable<ActionContextStoreSource<any, any> | undefined>;
     readonly _store$: Observable<ActionContextStore<any, any> | undefined>;
     readonly store$: Observable<ActionContextStore<any, any>>;
-    constructor(parent: DbNgxActionContextMapDirective, key: ActionKey);
+    constructor(parent: DbxActionContextMapDirective, key: ActionKey);
 }

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

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

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

@@ -1,20 +1,20 @@
 import { OnDestroy } from '@angular/core';
 import { ActionContextStoreSource } from '../../action.store.source';
-import { DbNgxActionContextMapDirective } from './action.map.directive';
+import { DbxActionContextMapDirective } from './action.map.directive';
 import { ActionKey } from './action.map';
 import * as i0 from "@angular/core";
 /**
  * Used to communicate with an dbxActionMap and set the ActionContextStore to the store based on the key.
  */
-export declare class DbNgxActionMapSourceDirective implements OnDestroy {
+export declare class DbxActionMapSourceDirective implements OnDestroy {
     readonly source: ActionContextStoreSource;
     private readonly _map;
     private _key;
-    constructor(source: ActionContextStoreSource, _map: DbNgxActionContextMapDirective);
+    constructor(source: ActionContextStoreSource, _map: DbxActionContextMapDirective);
     ngOnDestroy(): void;
     set key(key: ActionKey);
     private _addToStore;
     private _removeFromToStore;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionMapSourceDirective, [{ host: true; }, null]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionMapSourceDirective, "[dbxActionMapSource]", never, { "key": "dbxActionMapSource"; }, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionMapSourceDirective, [{ host: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionMapSourceDirective, "[dbxActionMapSource]", never, { "key": "dbxActionMapSource"; }, {}, never>;
 }

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

@@ -2,20 +2,20 @@ import { OnInit, OnDestroy } from '@angular/core';
 import { Maybe } from '@dereekb/util';
 import { AbstractSubscriptionDirective } from '../../../subscription';
 import { ActionContextStoreSourceInstance } from '../../action.store.source';
-import { DbNgxActionContextMapDirective } from './action.map.directive';
+import { DbxActionContextMapDirective } from './action.map.directive';
 import { ActionDisabledKey } from '../../action';
 import * as i0 from "@angular/core";
-export declare const DEFAULT_ACTION_MAP_WORKING_DISABLED_KEY = "";
+export declare const DEFAULT_ACTION_MAP_WORKING_DISABLED_KEY = "__disabled";
 /**
  * Used to communicate with an dbxActionMap and set the ActionContextStore to be disabled if any other element in the map is working.
  */
-export declare class DbNgxActionMapWorkingDisableDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxActionMapWorkingDisableDirective extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
     readonly source: ActionContextStoreSourceInstance;
     private readonly _map;
     disabledKey: Maybe<ActionDisabledKey>;
-    constructor(source: ActionContextStoreSourceInstance, _map: DbNgxActionContextMapDirective);
+    constructor(source: ActionContextStoreSourceInstance, _map: DbxActionContextMapDirective);
     ngOnInit(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionMapWorkingDisableDirective, [{ host: true; }, null]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionMapWorkingDisableDirective, "[dbxActionMapWorkingDisable]", never, { "disabledKey": "dbxActionMapWorkingDisable"; }, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionMapWorkingDisableDirective, [{ host: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionMapWorkingDisableDirective, "[dbxActionMapWorkingDisable]", never, { "disabledKey": "dbxActionMapWorkingDisable"; }, {}, never>;
 }

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

@@ -6,7 +6,7 @@ export declare const APP_ACTION_DISABLED_DIRECTIVE_KEY = "dbx_action_disabled";
 /**
  * Directive that allows disabling an action using the inputs.
  */
-export declare class DbNgxActionDisabledDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxActionDisabledDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
     readonly source: ActionContextStoreSourceInstance<T, O>;
     private _disabled;
     readonly disabled$: import("rxjs").Observable<boolean>;
@@ -15,6 +15,6 @@ export declare class DbNgxActionDisabledDirective<T, O> extends AbstractSubscrip
     ngOnDestroy(): void;
     get disabled(): boolean;
     set disabled(disabled: boolean);
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionDisabledDirective<any, any>, [{ host: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionDisabledDirective<any, any>, "[dbxActionDisabled]", never, { "disabled": "dbxActionDisabled"; }, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDisabledDirective<any, any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledDirective<any, any>, "[dbxActionDisabled]", never, { "disabled": "dbxActionDisabled"; }, {}, never>;
 }

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

@@ -6,11 +6,11 @@ export declare const APP_ACTION_DISABLED_UNTIL_MODIFIED_DIRECTIVE_KEY = "dbx_act
 /**
  * Directive that sets the disabled state based on the current isModified state.
  */
-export declare class DbNgxActionDisabledUntilModifiedDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxActionDisabledUntilModifiedDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
     readonly source: ActionContextStoreSourceInstance<T, O>;
     constructor(source: ActionContextStoreSourceInstance<T, O>);
     ngOnInit(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionDisabledUntilModifiedDirective<any, any>, [{ host: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionDisabledUntilModifiedDirective<any, any>, "[dbxActionDisabledUntilModified]", never, {}, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDisabledUntilModifiedDirective<any, any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDisabledUntilModifiedDirective<any, any>, "[dbxActionDisabledUntilModified]", never, {}, {}, never>;
 }

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

@@ -7,7 +7,7 @@ import * as i0 from "@angular/core";
 /**
  * Context used for defining a function that performs an action using the input function on ValueReady.
  */
-export declare class DbNgxActionHandlerDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxActionHandlerDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
     readonly source: ActionContextStoreSourceInstance<T, O>;
     private _handlerFunction;
     readonly handlerFunction$: import("rxjs").Observable<HandleActionFunction<T, O>>;
@@ -17,6 +17,6 @@ export declare class DbNgxActionHandlerDirective<T, O> extends AbstractSubscript
     constructor(source: ActionContextStoreSourceInstance<T, O>);
     ngOnInit(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionHandlerDirective<any, any>, [{ host: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionHandlerDirective<any, any>, "[dbxActionHandler]", never, { "handlerFunction": "dbxActionHandler"; }, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionHandlerDirective<any, any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionHandlerDirective<any, any>, "[dbxActionHandler]", never, { "handlerFunction": "dbxActionHandler"; }, {}, never>;
 }

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

@@ -5,11 +5,11 @@ import * as i0 from "@angular/core";
  *
  * Can be configured to show for a limited time afterwards, etc.
  */
-export declare class DbNgxActionSuccessComponent {
+export declare class DbxActionSuccessComponent {
     readonly source: ActionContextStoreSourceInstance;
     hideAfter?: number;
     readonly show$: import("rxjs").Observable<boolean>;
     constructor(source: ActionContextStoreSourceInstance);
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionSuccessComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbNgxActionSuccessComponent, "dbx-action-success", never, { "hideAfter": "hideAfter"; }, {}, never, ["*"]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionSuccessComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxActionSuccessComponent, "dbx-action-success", never, { "hideAfter": "hideAfter"; }, {}, never, ["*"]>;
 }

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

@@ -10,7 +10,7 @@ export declare type SuccessActionFunction<O> = (value: O) => void;
 /**
  * Directive that executes a function on ActionContextStore Success.
  */
-export declare class DbNgxActionSuccessDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
+export declare class DbxActionSuccessDirective<T, O> extends AbstractSubscriptionDirective implements OnInit, OnDestroy {
     readonly source: ActionContextStoreSourceInstance;
     private _successFunction;
     readonly successFunction$: import("rxjs").Observable<SuccessActionFunction<O>>;
@@ -19,6 +19,6 @@ export declare class DbNgxActionSuccessDirective<T, O> extends AbstractSubscript
     constructor(source: ActionContextStoreSourceInstance);
     ngOnInit(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionSuccessDirective<any, any>, [{ host: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionSuccessDirective<any, any>, "[dbxActionSuccess]", never, { "successFunction": "dbxActionSuccess"; }, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionSuccessDirective<any, any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionSuccessDirective<any, any>, "[dbxActionSuccess]", never, { "successFunction": "dbxActionSuccess"; }, {}, never>;
 }

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

@@ -8,7 +8,7 @@ import * as i0 from "@angular/core";
  *
  * No value is required, allowing the directive to automatically call readyValue with undefined.
  */
-export declare class DbNgxActionValueDirective<T, O> extends AbstractSubscriptionDirective implements OnInit {
+export declare class DbxActionValueDirective<T, O> extends AbstractSubscriptionDirective implements OnInit {
     readonly source: ActionContextStoreSourceInstance<T, O>;
     private _valueOrFunction;
     readonly valueOrFunction$: import("rxjs").Observable<ObjectOrGetter<T>>;
@@ -17,6 +17,6 @@ export declare class DbNgxActionValueDirective<T, O> extends AbstractSubscriptio
     constructor(source: ActionContextStoreSourceInstance<T, O>);
     ngOnInit(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionValueDirective<any, any>, [{ host: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionValueDirective<any, any>, "[dbxActionValue]", never, { "valueOrFunction": "dbxActionValue"; }, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionValueDirective<any, any>, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionValueDirective<any, any>, "[dbxActionValue]", never, { "valueOrFunction": "dbxActionValue"; }, {}, never>;
 }

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

@@ -3,10 +3,10 @@ import * as i0 from "@angular/core";
 /**
  * Displays the input content when working is set.
  */
-export declare class DbNgxActionWorkingComponent {
+export declare class DbxActionWorkingComponent {
     readonly source: ActionContextStoreSourceInstance;
     readonly show$: import("rxjs").Observable<boolean>;
     constructor(source: ActionContextStoreSourceInstance);
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionWorkingComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbNgxActionWorkingComponent, "dbx-action-working", never, {}, {}, never, ["*"]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionWorkingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxActionWorkingComponent, "dbx-action-working", never, {}, {}, never, ["*"]>;
 }

package/lib/action/snackbar/snackbar.d.ts

@@ -39,11 +39,11 @@ export interface ActionSnackbarPopupConfig<C = any> {
  * Performs the action on success.
  */
 export declare type ActionSnackbarFunction<O = any, C = any> = (event: ActionSnackbarEvent<O>) => ActionSnackbarPopupConfig<C>;
-export interface DbNgxActionSnackbarGetUndoConfig extends Omit<DbNgxActionSnackbarComponentConfig, 'message' | 'action'>, Partial<Pick<DbNgxActionSnackbarComponentConfig, 'message' | 'action'>> {
+export interface DbxActionSnackbarGetUndoConfig extends Omit<DbxActionSnackbarComponentConfig, 'message' | 'action'>, Partial<Pick<DbxActionSnackbarComponentConfig, 'message' | 'action'>> {
     duration?: number;
 }
-export declare type ActionSnackbarGetUndoConfigFunction = () => Maybe<DbNgxActionSnackbarGetUndoConfig>;
-export interface DbNgxActionSnackbarComponentConfig {
+export declare type ActionSnackbarGetUndoConfigFunction = () => Maybe<DbxActionSnackbarGetUndoConfig>;
+export interface DbxActionSnackbarComponentConfig {
     action: string;
     message?: Maybe<string>;
     actionSource: ActionContextStoreSourceInstance;

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

@@ -1,18 +1,18 @@
 import { OnInit, OnDestroy, NgZone } from '@angular/core';
-import { DbNgxButton } from '../button';
+import { DbxButton } from '../button';
 import { ActionContextStoreSourceInstance } from '../../action/action.store.source';
-import { DbNgxActionButtonTriggerDirective } from './action.button.trigger.directive';
+import { DbxActionButtonTriggerDirective } from './action.button.trigger.directive';
 import * as i0 from "@angular/core";
 /**
  * Context used for linking a button to an ActionContext.
  */
-export declare class DbNgxActionButtonDirective extends DbNgxActionButtonTriggerDirective implements OnInit, OnDestroy {
+export declare class DbxActionButtonDirective extends DbxActionButtonTriggerDirective implements OnInit, OnDestroy {
     private readonly ngZone;
     private _workingSub;
     private _disabledSub;
-    constructor(button: DbNgxButton, source: ActionContextStoreSourceInstance, ngZone: NgZone);
+    constructor(button: DbxButton, source: ActionContextStoreSourceInstance, ngZone: NgZone);
     ngOnInit(): void;
     ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionButtonDirective, [{ host: true; }, null, null]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionButtonDirective, "[dbxActionButton]", never, {}, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionButtonDirective, [{ host: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionButtonDirective, "[dbxActionButton]", never, {}, {}, never>;
 }

package/lib/button/action/action.button.trigger.directive.d.ts

@@ -1,17 +1,17 @@
 import { OnInit } from '@angular/core';
 import { AbstractSubscriptionDirective } from '../../subscription';
-import { DbNgxButton } from '../button';
+import { DbxButton } from '../button';
 import { ActionContextStoreSourceInstance } from '../../action/action.store.source';
 import * as i0 from "@angular/core";
 /**
  * Context used for linking a button to an ActionContext and only look for triggers.
  */
-export declare class DbNgxActionButtonTriggerDirective extends AbstractSubscriptionDirective implements OnInit {
-    readonly button: DbNgxButton;
+export declare class DbxActionButtonTriggerDirective extends AbstractSubscriptionDirective implements OnInit {
+    readonly button: DbxButton;
     readonly source: ActionContextStoreSourceInstance;
-    constructor(button: DbNgxButton, source: ActionContextStoreSourceInstance);
+    constructor(button: DbxButton, source: ActionContextStoreSourceInstance);
     ngOnInit(): void;
     protected _buttonClicked(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionButtonTriggerDirective, [{ host: true; }, null]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionButtonTriggerDirective, "[dbxActionButtonTrigger]", never, {}, {}, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionButtonTriggerDirective, [{ host: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionButtonTriggerDirective, "[dbxActionButtonTrigger]", never, {}, {}, never>;
 }

package/lib/button/button.d.ts

@@ -6,13 +6,13 @@ import { Observable } from 'rxjs';
  *
  * Can be used to delay/modify trigger/click behaviors.
  */
-export interface DbNgxButtonInterceptor {
+export interface DbxButtonInterceptor {
     /**
      * Handles a button click event. Returns an observable that will say whether or not to continue the click event.
      */
     interceptButtonClick: () => Observable<boolean>;
 }
-export declare abstract class DbNgxButton {
+export declare abstract class DbxButton {
     abstract disabled$: Observable<boolean>;
     abstract working$: Observable<boolean>;
     abstract disabled: Maybe<boolean>;
@@ -20,7 +20,7 @@ export declare abstract class DbNgxButton {
     abstract icon?: string;
     abstract text?: string;
     abstract clicked$: Observable<any>;
-    abstract setButtonInterceptor(interceptor: DbNgxButtonInterceptor): void;
+    abstract setButtonInterceptor(interceptor: DbxButtonInterceptor): void;
     abstract clickButton(): void;
 }
-export declare function ProvideDbNgxButton<S extends DbNgxButton>(sourceType: Type<S>): Provider[];
+export declare function ProvideDbxButton<S extends DbxButton>(sourceType: Type<S>): Provider[];

package/lib/button/button.directive.d.ts

@@ -2,12 +2,12 @@ import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
 import { Maybe } from '@dereekb/util';
 import { BehaviorSubject, Subject } from 'rxjs';
 import { AbstractSubscriptionDirective } from '../subscription';
-import { DbNgxButton, DbNgxButtonInterceptor } from './button';
+import { DbxButton, DbxButtonInterceptor } from './button';
 import * as i0 from "@angular/core";
 /**
  * Abstract button component.
  */
-export declare abstract class AbstractDbNgxButtonDirective extends AbstractSubscriptionDirective implements DbNgxButton, OnInit, OnDestroy {
+export declare abstract class AbstractDbxButtonDirective extends AbstractSubscriptionDirective implements DbxButton, OnInit, OnDestroy {
     private _disabled;
     private _working;
     readonly disabled$: import("rxjs").Observable<boolean>;
@@ -25,13 +25,13 @@ export declare abstract class AbstractDbNgxButtonDirective extends AbstractSubsc
      * Pre-interceptor button click.
      */
     protected _buttonClick: Subject<void>;
-    protected _buttonInterceptor: BehaviorSubject<Maybe<DbNgxButtonInterceptor>>;
+    protected _buttonInterceptor: BehaviorSubject<Maybe<DbxButtonInterceptor>>;
     ngOnInit(): void;
     ngOnDestroy(): void;
     /**
      * Sets the button interceptor. If any interceptor is already set, it is replaced.
      */
-    setButtonInterceptor(interceptor: DbNgxButtonInterceptor): void;
+    setButtonInterceptor(interceptor: DbxButtonInterceptor): void;
     /**
      * Main function to use for handling clicks on the button.
      */
@@ -40,13 +40,13 @@ export declare abstract class AbstractDbNgxButtonDirective extends AbstractSubsc
      * Forces a button click. Skips the interceptors if any are configured.
      */
     protected _forceButtonClicked(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbNgxButtonDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbNgxButtonDirective, never, never, { "disabled": "disabled"; "working": "working"; "icon": "icon"; "text": "text"; }, { "buttonClick": "buttonClick"; }, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDbxButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDbxButtonDirective, never, never, { "disabled": "disabled"; "working": "working"; "icon": "icon"; "text": "text"; }, { "buttonClick": "buttonClick"; }, never>;
 }
 /**
- * Provides an DbNgxButton directive.
+ * Provides an DbxButton directive.
  */
-export declare class DbNgxButtonDirective extends AbstractDbNgxButtonDirective {
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxButtonDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxButtonDirective, "[dbxButton]", ["dbxButton"], {}, {}, never>;
+export declare class DbxButtonDirective extends AbstractDbxButtonDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxButtonDirective, "[dbxButton]", ["dbxButton"], {}, {}, never>;
 }