@dereekb/dbx-web 1.1.0 → 2.1.0

package/lib/action/_action.scss

@@ -1,40 +1,13 @@
-@use '../style/theming';
+@use './snackbar/snackbar';
 
-// MARK: Variables
-
-
-// MARK: Mixin
-@mixin core() {}
-
-@mixin color($theme-config) {}
-
-@mixin typography($typography-config) {}
-
-@mixin theme($theme-config) {
-  @include theming.private-check-duplicate-theme-styles($theme-config, 'dbx-action') {
-    $color: theming.get-color-config($theme-config);
-    $typography: theming.get-typography-config($theme-config);
-
-    @if $color !=null {
-      @include color($theme-config);
-    }
-
-    @if $typography !=null {
-      @include typography($typography);
-    }
-  }
+@mixin all-action-core() {
+  @include snackbar.core();
 }
 
-// TODO:
-.dbx-action-snackbar {
-  display: flex;
-  align-items: center;
-
-  &.dbx-action-snackbar-success {
-    // background: $success-color;
-  }
+@mixin all-action-typography($typography-config) {
+  @include snackbar.typography($typography-config);
+}
 
-  &.dbx-action-snackbar-error {
-    // background: red;
-  }
+@mixin all-action-theme($theme-config) {
+  @include snackbar.theme($theme-config);
 }

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

@@ -2,8 +2,17 @@ import { OnDestroy, OnInit } from '@angular/core';
 import { MatDialog } from '@angular/material/dialog';
 import { AbstractPromptConfirmDirective } from '../interaction/prompt/prompt.confirm.directive';
 import { DbxPromptConfirmConfig } from '../interaction/prompt/prompt.confirm.component';
-import { ActionContextStoreSourceInstance } from '@dereekb/dbx-core';
+import { DbxActionContextStoreSourceInstance } from '@dereekb/dbx-core';
 import * as i0 from "@angular/core";
+/**
+ * DbxActionConfirmDirective configuration.
+ */
+export interface DbxActionConfirmConfig<T> extends DbxPromptConfirmConfig {
+    /**
+     * Optionally set the readyValue passed to the instance.
+     */
+    readyValue?: T;
+}
 /**
  * Directive that when triggered shows a dialog to accept or reject.
  *
@@ -11,10 +20,10 @@ import * as i0 from "@angular/core";
  * For button usage, use an appPromptConfirmButton directive.
  */
 export declare class DbxActionConfirmDirective<T, O> extends AbstractPromptConfirmDirective implements OnInit, OnDestroy {
-    readonly source: ActionContextStoreSourceInstance<T, O>;
-    config?: DbxPromptConfirmConfig;
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
+    config?: DbxActionConfirmConfig<T>;
     private _sourceSubscription;
-    constructor(source: ActionContextStoreSourceInstance<T, O>, dialog: MatDialog);
+    constructor(source: DbxActionContextStoreSourceInstance<T, O>, dialog: MatDialog);
     ngOnInit(): void;
     ngOnDestroy(): void;
     protected _handleDialogResult(result: boolean): boolean;

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

@@ -1,16 +1,15 @@
 import * as i0 from "@angular/core";
 import * as i1 from "./key.trigger.directive";
-import * as i2 from "./action.snackbar.component";
-import * as i3 from "./action.confirm.directive";
-import * as i4 from "@angular/common";
-import * as i5 from "@dereekb/dbx-core";
-import * as i6 from "../button/button.module";
-import * as i7 from "@angular/material/snack-bar";
-import * as i8 from "@angular/material/dialog";
-import * as i9 from "@angular/material/button";
-import * as i10 from "../interaction/prompt/prompt.module";
+import * as i2 from "./action.confirm.directive";
+import * as i3 from "@angular/common";
+import * as i4 from "@dereekb/dbx-core";
+import * as i5 from "../button/button.module";
+import * as i6 from "@angular/material/snack-bar";
+import * as i7 from "@angular/material/dialog";
+import * as i8 from "@angular/material/button";
+import * as i9 from "../interaction/prompt/prompt.module";
 export declare class DbxActionModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxActionModule, [typeof i1.DbxActionKeyTriggerDirective, typeof i2.DbxActionSnackbarComponent, typeof i3.DbxActionConfirmDirective], [typeof i4.CommonModule, typeof i5.DbxCoreActionModule, typeof i6.DbxButtonModule, typeof i7.MatSnackBarModule, typeof i8.MatDialogModule, typeof i9.MatButtonModule, typeof i10.DbxPromptModule], [typeof i5.DbxCoreActionModule, typeof i1.DbxActionKeyTriggerDirective, typeof i2.DbxActionSnackbarComponent, typeof i3.DbxActionConfirmDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxActionModule, [typeof i1.DbxActionKeyTriggerDirective, typeof i2.DbxActionConfirmDirective], [typeof i3.CommonModule, typeof i4.DbxCoreActionModule, typeof i5.DbxButtonModule, typeof i6.MatSnackBarModule, typeof i7.MatDialogModule, typeof i8.MatButtonModule, typeof i9.DbxPromptModule], [typeof i4.DbxCoreActionModule, typeof i1.DbxActionKeyTriggerDirective, typeof i2.DbxActionConfirmDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DbxActionModule>;
 }

package/lib/action/index.d.ts

@@ -1,5 +1,5 @@
+export * from './snackbar';
 export * from './transition';
 export * from './action.confirm.directive';
 export * from './action.module';
-export * from './action.snackbar.component';
 export * from './key.trigger.directive';

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

@@ -1,5 +1,5 @@
 import { Maybe } from '@dereekb/util';
-import { ActionContextStoreSourceInstance } from '@dereekb/dbx-core';
+import { DbxActionContextStoreSourceInstance } from '@dereekb/dbx-core';
 import * as i0 from "@angular/core";
 /**
  * Directive that triggers the action on a specific key up event.
@@ -7,9 +7,9 @@ import * as i0 from "@angular/core";
  * Events/Keys to respond to should be lowercase.
  */
 export declare class DbxActionKeyTriggerDirective<T = any, O = any> {
-    readonly source: ActionContextStoreSourceInstance<T, O>;
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
     inputKey: Maybe<string>;
-    constructor(source: ActionContextStoreSourceInstance<T, O>);
+    constructor(source: DbxActionContextStoreSourceInstance<T, O>);
     get key(): string;
     onKeyupHandler(event: KeyboardEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionKeyTriggerDirective<any, any>, [{ host: true; }]>;

package/lib/action/snackbar/_snackbar.scss

@@ -0,0 +1,33 @@
+@use '../../style/theming';
+
+// MARK: Variables
+
+
+// MARK: Mixin
+@mixin core() {
+
+  .dbx-action-snackbar {
+    display: flex;
+    align-items: center;
+  }
+
+}
+
+@mixin color($theme-config) {}
+
+@mixin typography($typography-config) {}
+
+@mixin theme($theme-config) {
+  @include theming.private-check-duplicate-theme-styles($theme-config, 'dbx-action-snackbar') {
+    $color: theming.get-color-config($theme-config);
+    $typography: theming.get-typography-config($theme-config);
+
+    @if $color !=null {
+      @include color($theme-config);
+    }
+
+    @if $typography !=null {
+      @include typography($typography);
+    }
+  }
+}

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

@@ -0,0 +1,36 @@
+import { OnInit } from '@angular/core';
+import { LoadingStateType } from '@dereekb/rxjs';
+import { Observable } from 'rxjs';
+import { OnDestroy, AfterViewInit } from '@angular/core';
+import { MatSnackBarRef } from '@angular/material/snack-bar';
+import { Maybe } from '@dereekb/util';
+import { DbxActionSnackbarDisplayConfig, DbxActionSnackbarActionConfig } from './action.snackbar';
+import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import * as i0 from "@angular/core";
+/**
+ * Component for a snackbar that contains an action.
+ */
+export declare class DbxActionSnackbarComponent extends AbstractSubscriptionDirective implements OnInit, AfterViewInit, OnDestroy {
+    readonly snackbar: MatSnackBarRef<DbxActionSnackbarComponent>;
+    readonly data: DbxActionSnackbarDisplayConfig;
+    private _durationTimeout;
+    private _actionRef;
+    readonly value$: Observable<number>;
+    readonly sourceInstance$: Observable<import("@dereekb/dbx-core").DbxActionContextStoreSourceInstance<any, any>>;
+    readonly complete$: Observable<boolean>;
+    readonly loadingStateType$: Observable<LoadingStateType>;
+    readonly snackbarStatusClass$: Observable<string>;
+    readonly button: Maybe<string>;
+    get action(): DbxActionSnackbarActionConfig | undefined;
+    get hasAction(): boolean;
+    get message(): Maybe<string>;
+    get actionConfig(): Maybe<DbxActionSnackbarActionConfig>;
+    constructor(snackbar: MatSnackBarRef<DbxActionSnackbarComponent>, data: DbxActionSnackbarDisplayConfig);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    dismissAfterActionCompletes: () => void;
+    dismiss: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionSnackbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxActionSnackbarComponent, "ng-component", never, {}, {}, never, never>;
+}

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

@@ -0,0 +1,52 @@
+import { MatSnackBarConfig } from "@angular/material/snack-bar";
+import { DbxActionContextSourceReference } from "@dereekb/dbx-core";
+import { LoadingState, LoadingStateType } from "@dereekb/rxjs";
+import { Maybe } from "@dereekb/util";
+export declare type DbxActionSnackbarType = string;
+export declare type DbxActionSnackbarKnownType = 'none' | 'create' | 'save' | 'delete' | 'merge' | 'send' | 'cancel' | 'restore' | 'refresh' | 'read' | 'unread';
+/**
+ * ActionSnackbar event. Depending on the type, a value or error is also available.
+ */
+export interface DbxActionSnackbarEvent<O = any> extends Omit<LoadingState<O>, 'loading'> {
+    type: LoadingStateType;
+}
+/**
+ * Configuration for the actual snackbar popup.
+ */
+export interface DbxActionSnackbarDisplayConfig {
+    /**
+     * Text to be shown on the close button. If action is defined, this is ignored and the action text is used.
+     */
+    button?: string;
+    /**
+     * Message to show in the snackbar.
+     */
+    message?: Maybe<string>;
+    /**
+     * Additional action that can occur.
+     */
+    action?: DbxActionSnackbarActionConfig;
+    /**
+     * MatSnackBar configuration
+     */
+    snackbar?: MatSnackBarConfig;
+}
+/**
+ * Used for configuring an action on the snackbar component.
+ */
+export interface DbxActionSnackbarActionConfig {
+    /**
+     * Action label to display on the button.
+     */
+    button: string;
+    /**
+     * Action reference to use.
+     *
+     * The referred to action is used for triggering and lifecycle.
+     */
+    reference: DbxActionContextSourceReference;
+    /**
+     * Duration to show the action.
+     */
+    duration?: number;
+}

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

@@ -0,0 +1,2 @@
+import { DbxActionSnackbarEventMakeConfig } from './action.snackbar.service';
+export declare const DBX_ACTION_SNACKBAR_DEFAULTS: DbxActionSnackbarEventMakeConfig;

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

@@ -0,0 +1,25 @@
+import { OnInit } from '@angular/core';
+import { AbstractSubscriptionDirective, DbxActionContextStoreSourceInstance } from '@dereekb/dbx-core';
+import { Maybe } from '@dereekb/util';
+import { DbxActionSnackbarDisplayConfig, DbxActionSnackbarEvent, DbxActionSnackbarType } from './action.snackbar';
+import { DbxActionSnackbarService } from './action.snackbar.service';
+import { DbxActionSnackbarDisplayConfigGeneratorFunction, DbxActionSnackbarGeneratorUndoInput } from './action.snackbar.generator';
+import * as i0 from "@angular/core";
+/**
+ * Action directive that displays a snackbar when the action context hits a certain state.
+ */
+export declare class DbxActionSnackbarDirective<T = any, O = any> extends AbstractSubscriptionDirective implements OnInit {
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
+    readonly dbxActionSnackbarService: DbxActionSnackbarService;
+    private _snackbarFunction?;
+    get snackbarFunction(): Maybe<DbxActionSnackbarDisplayConfigGeneratorFunction<O>>;
+    set snackbarFunction(snackbarFunction: Maybe<'' | DbxActionSnackbarDisplayConfigGeneratorFunction<O>>);
+    dbxActionSnackbarDefault?: Maybe<DbxActionSnackbarType>;
+    dbxActionSnackbarUndo?: DbxActionSnackbarGeneratorUndoInput;
+    constructor(source: DbxActionContextStoreSourceInstance<T, O>, dbxActionSnackbarService: DbxActionSnackbarService);
+    ngOnInit(): void;
+    protected buildConfigurationForEvent(event: DbxActionSnackbarEvent): Maybe<DbxActionSnackbarDisplayConfig>;
+    protected showSnackbarForConfiguration(config: DbxActionSnackbarDisplayConfig, event: DbxActionSnackbarEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionSnackbarDirective<any, any>, [{ host: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionSnackbarDirective<any, any>, "[dbxActionSnackbar]", never, { "snackbarFunction": "dbxActionSnackbar"; "dbxActionSnackbarDefault": "dbxActionSnackbarDefault"; "dbxActionSnackbarUndo": "dbxActionSnackbarUndo"; }, {}, never>;
+}

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

@@ -0,0 +1,32 @@
+import { DbxActionContextSourceReference } from "@dereekb/dbx-core";
+import { Milliseconds, Maybe, ObjectOrGetter, Getter } from "@dereekb/util";
+import { DbxActionSnackbarDisplayConfig, DbxActionSnackbarEvent } from "./action.snackbar";
+export interface DbxActionSnackbarGeneratorInput<O = any> {
+    event: DbxActionSnackbarEvent<O>;
+    undo?: Maybe<DbxActionSnackbarGeneratorUndoInput>;
+}
+export declare type DbxActionSnackbarGeneratorUndoInput = DbxActionSnackbarGeneratorUndoInputConfig | Getter<DbxActionContextSourceReference>;
+export interface DbxActionSnackbarGeneratorUndoInputConfig {
+    duration?: Milliseconds;
+    getUndoAction: Getter<DbxActionContextSourceReference>;
+}
+export declare type DbxActionSnackbarDisplayConfigGeneratorFunction<O = any> = (input: DbxActionSnackbarGeneratorInput<O>) => Maybe<DbxActionSnackbarDisplayConfig>;
+export interface DbxMakeActionSnackbarGeneratorConfiguration {
+    idle?: ObjectOrGetter<DbxMakeActionSnackbarGeneratorEventConfiguration>;
+    loading?: ObjectOrGetter<DbxMakeActionSnackbarGeneratorEventConfiguration>;
+    success?: ObjectOrGetter<DbxMakeActionSnackbarGeneratorEventConfiguration>;
+    error?: ObjectOrGetter<DbxMakeActionSnackbarGeneratorEventConfiguration>;
+}
+export interface DbxMakeActionSnackbarGeneratorEventConfiguration extends Omit<DbxActionSnackbarDisplayConfig, 'action'> {
+    /**
+     * Sets the undo action text. If undefined, will default to 'undo'
+     */
+    undoButtonText?: string;
+}
+/**
+ * Creates a DbxActionSnackbarDisplayConfigGeneratorFunction from the input config.
+ *
+ * @param config
+ * @returns
+ */
+export declare function makeDbxActionSnackbarDisplayConfigGeneratorFunction<O = any>(config: DbxMakeActionSnackbarGeneratorConfiguration): DbxActionSnackbarDisplayConfigGeneratorFunction<O>;

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

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./action.snackbar.component";
+import * as i2 from "./action.snackbar.directive";
+import * as i3 from "@angular/common";
+import * as i4 from "../../layout/style/style.layout.module";
+import * as i5 from "@dereekb/dbx-core";
+import * as i6 from "../../interaction/prompt/prompt.module";
+import * as i7 from "../../button/button.module";
+import * as i8 from "../../error/error.module";
+export declare class DbxActionSnackbarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionSnackbarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxActionSnackbarModule, [typeof i1.DbxActionSnackbarComponent, typeof i2.DbxActionSnackbarDirective], [typeof i3.CommonModule, typeof i4.DbxStyleLayoutModule, typeof i5.DbxCoreActionModule, typeof i6.DbxPromptModule, typeof i7.DbxButtonModule, typeof i8.DbxReadableErrorModule], [typeof i1.DbxActionSnackbarComponent, typeof i2.DbxActionSnackbarDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxActionSnackbarModule>;
+}

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

@@ -0,0 +1,39 @@
+import { DbxActionSnackbarComponent } from './action.snackbar.component';
+import { InjectionToken, Type } from "@angular/core";
+import { MatSnackBar, MatSnackBarConfig, MatSnackBarRef } from "@angular/material/snack-bar";
+import { Milliseconds, Maybe } from "@dereekb/util";
+import { DbxActionSnackbarDisplayConfig, DbxActionSnackbarType } from "./action.snackbar";
+import { DbxActionSnackbarGeneratorInput, DbxMakeActionSnackbarGeneratorConfiguration } from "./action.snackbar.generator";
+import * as i0 from "@angular/core";
+export declare const DBX_ACTION_SNACKBAR_SERVICE_CONFIG: InjectionToken<unknown>;
+export declare const DEFAULT_SNACKBAR_DIRECTIVE_DURATION: number;
+export interface DbxActionSnackbarEventMakeConfig {
+    [key: string]: DbxMakeActionSnackbarGeneratorConfiguration;
+}
+export interface DbxActionSnackbarServiceConfig<C = any> {
+    readonly componentClass: Type<C>;
+    readonly snackbar?: Pick<MatSnackBarConfig, 'horizontalPosition' | 'verticalPosition'>;
+    readonly defaultDuration?: Milliseconds;
+    readonly defaultUndoDuration?: Milliseconds;
+    readonly eventTypeConfigs: DbxActionSnackbarEventMakeConfig;
+}
+/**
+ * Used for managing/configuring the snackbar default values and pushing snackbar events.
+ */
+export declare class DbxActionSnackbarService<C = DbxActionSnackbarComponent> {
+    readonly matSnackBar: MatSnackBar;
+    readonly config: DbxActionSnackbarServiceConfig<C>;
+    get componentClass(): Type<C>;
+    get eventTypeConfigs(): DbxActionSnackbarEventMakeConfig;
+    constructor(matSnackBar: MatSnackBar, inputConfig: Partial<DbxActionSnackbarServiceConfig<C>>);
+    /**
+     * Opens a new snackbar given the input configuration.
+     *
+     * @param config
+     * @returns
+     */
+    openSnackbar(config: DbxActionSnackbarDisplayConfig): MatSnackBarRef<C>;
+    generateDisplayConfig(type: Maybe<DbxActionSnackbarType>, input: DbxActionSnackbarGeneratorInput): Maybe<DbxActionSnackbarDisplayConfig>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionSnackbarService<any>, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxActionSnackbarService<any>>;
+}

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

@@ -0,0 +1,7 @@
+export * from './action.snackbar.component';
+export * from './action.snackbar.default';
+export * from './action.snackbar.directive';
+export * from './action.snackbar.generator';
+export * from './action.snackbar.module';
+export * from './action.snackbar.service';
+export * from './action.snackbar';

package/lib/action/transition/transition.safety.directive.d.ts

@@ -2,7 +2,7 @@ import { OnInit, OnDestroy, ViewContainerRef } from '@angular/core';
 import { MatDialog } from '@angular/material/dialog';
 import { HookResult, Transition, TransitionService } from '@uirouter/core';
 import { Observable } from 'rxjs';
-import { ActionContextStoreSourceInstance } from '@dereekb/dbx-core';
+import { DbxActionContextStoreSourceInstance } from '@dereekb/dbx-core';
 import * as i0 from "@angular/core";
 /**
  * How to handle transitions.
@@ -21,14 +21,14 @@ export declare type DbxActionTransitionSafetyType = 'none' | 'dialog' | 'auto';
  * NOTE: This dialog only works for uirouter.
  */
 export declare class DbxActionTransitionSafetyDirective<T, O> implements OnInit, OnDestroy {
-    readonly source: ActionContextStoreSourceInstance<T, O>;
+    readonly source: DbxActionContextStoreSourceInstance<T, O>;
     protected readonly transitionService: TransitionService;
     protected readonly viewContainerRef: ViewContainerRef;
     protected readonly dialog: MatDialog;
     inputSafetyType?: DbxActionTransitionSafetyType;
     private _dialogRef?;
     private stopWatchingTransition?;
-    constructor(source: ActionContextStoreSourceInstance<T, O>, transitionService: TransitionService, viewContainerRef: ViewContainerRef, dialog: MatDialog);
+    constructor(source: DbxActionContextStoreSourceInstance<T, O>, transitionService: TransitionService, viewContainerRef: ViewContainerRef, dialog: MatDialog);
     get safetyType(): DbxActionTransitionSafetyType;
     private get _destroyed();
     ngOnInit(): void;

package/lib/button/button.module.d.ts

@@ -3,8 +3,9 @@ import * as i1 from "./button.component";
 import * as i2 from "./button.spacer.component";
 import * as i3 from "@angular/common";
 import * as i4 from "mat-progress-buttons";
+import * as i5 from "@dereekb/dbx-core";
 export declare class DbxButtonModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxButtonModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxButtonModule, [typeof i1.DbxButtonComponent, typeof i2.DbxButtonSpacerComponent], [typeof i3.CommonModule, typeof i4.MatProgressButtonsModule], [typeof i4.MatProgressButtonsModule, typeof i1.DbxButtonComponent, typeof i2.DbxButtonSpacerComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxButtonModule, [typeof i1.DbxButtonComponent, typeof i2.DbxButtonSpacerDirective], [typeof i3.CommonModule, typeof i4.MatProgressButtonsModule], [typeof i5.DbxCoreButtonModule, typeof i4.MatProgressButtonsModule, typeof i1.DbxButtonComponent, typeof i2.DbxButtonSpacerDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DbxButtonModule>;
 }

package/lib/button/button.spacer.component.d.ts

@@ -1,8 +1,8 @@
 import * as i0 from "@angular/core";
 /**
- * Button spacer component.
+ * Button spacer directive.
  */
-export declare class DbxButtonSpacerComponent {
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxButtonSpacerComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<DbxButtonSpacerComponent, "dbx-button-spacer", never, {}, {}, never, never>;
+export declare class DbxButtonSpacerDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxButtonSpacerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxButtonSpacerDirective, "dbx-button-spacer,dbxButtonSpacer", never, {}, {}, never>;
 }

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

@@ -1,5 +1,5 @@
 import { OnInit } from '@angular/core';
-import { ActionContextStoreSourceInstance, AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import { DbxActionContextStoreSourceInstance, AbstractSubscriptionDirective } from '@dereekb/dbx-core';
 import { DbxReadableErrorComponent } from './error.component';
 import * as i0 from "@angular/core";
 /**
@@ -7,8 +7,8 @@ import * as i0 from "@angular/core";
  */
 export declare class DbxActionErrorDirective extends AbstractSubscriptionDirective implements OnInit {
     readonly error: DbxReadableErrorComponent;
-    readonly source: ActionContextStoreSourceInstance;
-    constructor(error: DbxReadableErrorComponent, source: ActionContextStoreSourceInstance);
+    readonly source: DbxActionContextStoreSourceInstance;
+    constructor(error: DbxReadableErrorComponent, source: DbxActionContextStoreSourceInstance);
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionErrorDirective, [{ host: true; }, null]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionErrorDirective, "[dbxActionError]", never, {}, {}, never>;

package/lib/interaction/dialog/abstract.dialog.directive.d.ts

@@ -10,6 +10,7 @@ export declare abstract class AbstractDialogDirective<R = any, D = any, T = any>
     readonly dialogRef: MatDialogRef<T, R>;
     constructor(data: D, dialogRef: MatDialogRef<T, R>, dbNgxRouterTransitionService: DbxRouterTransitionService, ngZone: NgZone);
     protected updateForSuccessfulTransition(): void;
+    returnValue(value?: R): void;
     close(value?: R): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDialogDirective<any, any, any>, [{ optional: true; }, null, null, null]>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDialogDirective<any, any, any>, never, never, {}, {}, never>;

package/lib/interaction/dialog/dialog.action.directive.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from 'rxjs';
+import { OnInit, OnDestroy, ElementRef } from '@angular/core';
+import { DbxActionContextStoreSourceInstance, AbstractDbxActionValueOnTriggerDirective } from '@dereekb/dbx-core';
+import { IsModifiedFunction } from '@dereekb/rxjs';
+import { Maybe } from '@dereekb/util';
+import { MatDialogRef } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+export declare type DbxActionDialogFunction<T = any> = () => MatDialogRef<any, Maybe<T>>;
+/**
+ * Action directive that is used to trigger/display a dialog, then watches that dialog for a value.
+ */
+export declare class DbxActionDialogDirective<T = any> extends AbstractDbxActionValueOnTriggerDirective<T> implements OnInit, OnDestroy {
+    readonly elementRef: ElementRef;
+    fn?: DbxActionDialogFunction<T>;
+    set dbxActionDialogModified(isModifiedFunction: Maybe<IsModifiedFunction>);
+    constructor(elementRef: ElementRef, source: DbxActionContextStoreSourceInstance<T, any>);
+    protected _getDataFromDialog(): Observable<Maybe<T>>;
+    protected _makeDialogRef(): MatDialogRef<any, Maybe<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionDialogDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionDialogDirective<any>, "[dbxActionDialog]", ["dbxActionDialog"], { "fn": "dbxActionDialog"; "dbxActionDialogModified": "dbxActionDialogModified"; }, {}, never>;
+}

package/lib/interaction/dialog/dialog.module.d.ts

@@ -1,12 +1,13 @@
 import * as i0 from "@angular/core";
 import * as i1 from "./dialog.content.component";
-import * as i2 from "@angular/common";
-import * as i3 from "../../layout/style/style.layout.module";
+import * as i2 from "./dialog.action.directive";
+import * as i3 from "@angular/common";
+import * as i4 from "../../layout/style/style.layout.module";
 /**
  * Module for block components.
  */
 export declare class DbxDialogInteractionModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DbxDialogInteractionModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxDialogInteractionModule, [typeof i1.DbxDialogContentDirective], [typeof i2.CommonModule, typeof i3.DbxStyleLayoutModule], [typeof i1.DbxDialogContentDirective]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxDialogInteractionModule, [typeof i1.DbxDialogContentDirective, typeof i2.DbxActionDialogDirective], [typeof i3.CommonModule, typeof i4.DbxStyleLayoutModule], [typeof i1.DbxDialogContentDirective, typeof i2.DbxActionDialogDirective]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DbxDialogInteractionModule>;
 }

package/lib/interaction/dialog/index.d.ts

@@ -1,3 +1,4 @@
 export * from './abstract.dialog.directive';
 export * from './dialog.content.component';
+export * from './dialog.action.directive';
 export * from './dialog.module';

package/lib/interaction/popover/index.d.ts

@@ -1,6 +1,5 @@
 export * from './abstract.popover.directive';
 export * from './abstract.popover.ref.directive';
-export * from './popover.action.button.directive';
 export * from './popover.action.directive';
 export * from './popover.component';
 export * from './popover.content.component';

package/lib/interaction/popover/popover.action.directive.d.ts

@@ -1,33 +1,24 @@
 import { Observable } from 'rxjs';
 import { OnInit, OnDestroy, ElementRef } from '@angular/core';
-import { NgPopoverCloseEvent, NgPopoverRef } from 'ng-overlay-container';
-import { AbstractPopoverRefWithEventsDirective } from './abstract.popover.ref.directive';
-import { ActionContextStoreSourceInstance } from '@dereekb/dbx-core';
+import { NgPopoverRef } from 'ng-overlay-container';
+import { DbxActionContextStoreSourceInstance, AbstractDbxActionValueOnTriggerDirective } from '@dereekb/dbx-core';
+import { IsModifiedFunction } from '@dereekb/rxjs';
+import { Maybe } from '@dereekb/util';
 import * as i0 from "@angular/core";
-export interface DbxPopoverActionFnParam {
+export interface DbxActionPopoverFunctionParams {
     origin: ElementRef;
 }
-export declare type DbxPopoverActionFn<T = object> = (params: DbxPopoverActionFnParam) => NgPopoverRef<any, T>;
-export declare type DbxPopoverActionModifiedFn<T = any> = (value: T) => Observable<boolean>;
+export declare type DbxActionPopoverFunction<T = any> = (params: DbxActionPopoverFunctionParams) => NgPopoverRef<any, Maybe<T>>;
 /**
- * Action directive that is used to trigger/display a popover,
- * then watches that popover for a value.
- *
- * The value is passed to the isModified function (ifProvided), and if that returns true it will
+ * Action directive that is used to trigger/display a popover, then watches that popover for a value.
  */
-export declare class DbxPopoverActionDirective<T = object> extends AbstractPopoverRefWithEventsDirective<any, T> implements OnInit, OnDestroy {
+export declare class DbxActionPopoverDirective<T = any> extends AbstractDbxActionValueOnTriggerDirective<T> implements OnInit, OnDestroy {
     readonly elementRef: ElementRef;
-    readonly source: ActionContextStoreSourceInstance<T, any>;
-    fn?: DbxPopoverActionFn<T>;
-    appPopoverActionModified?: DbxPopoverActionModifiedFn<T>;
-    private _popoverValue;
-    private _triggeredSub;
-    private _isModifiedSub;
-    constructor(elementRef: ElementRef, source: ActionContextStoreSourceInstance<T, any>);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    protected _makePopoverRef(): NgPopoverRef<any, T>;
-    protected _afterClosed(event: NgPopoverCloseEvent<T>): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DbxPopoverActionDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxPopoverActionDirective<any>, "[dbxPopoverAction]", ["popoverAction"], { "fn": "dbxPopoverAction"; "appPopoverActionModified": "appPopoverActionModified"; }, {}, never>;
+    fn?: DbxActionPopoverFunction<T>;
+    set dbxActionPopoverModified(isModifiedFunction: Maybe<IsModifiedFunction>);
+    constructor(elementRef: ElementRef, source: DbxActionContextStoreSourceInstance<T, any>);
+    protected _getDataFromPopover(): Observable<Maybe<T>>;
+    protected _makePopoverRef(): NgPopoverRef<any, Maybe<T>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxActionPopoverDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxActionPopoverDirective<any>, "[dbxActionPopover]", ["dbxActionPopover"], { "fn": "dbxActionPopover"; "dbxActionPopoverModified": "dbxActionPopoverModified"; }, {}, never>;
 }