@dereekb/dbx-web 0.0.1

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

@@ -0,0 +1,23 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { AbstractPromptConfirmDirective } from '../interaction/prompt/prompt.confirm.directive';
+import { DbNgxPromptConfirmConfig } from '../interaction/prompt/prompt.confirm.component';
+import { ActionContextStoreSourceInstance } from '@dereekb/dbx-core';
+import * as i0 from "@angular/core";
+/**
+ * Directive that when triggered shows a dialog to accept or reject.
+ *
+ * This only works to pass a ready value or reject through, not to work with a button.
+ * For button usage, use an appPromptConfirmButton directive.
+ */
+export declare class DbNgxActionConfirmDirective<T, O> extends AbstractPromptConfirmDirective implements OnInit, OnDestroy {
+    readonly source: ActionContextStoreSourceInstance<T, O>;
+    config?: DbNgxPromptConfirmConfig;
+    private _sourceSubscription;
+    constructor(source: ActionContextStoreSourceInstance<T, O>, dialog: MatDialog);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected _handleDialogResult(result: boolean): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionConfirmDirective<any, any>, [{ host: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionConfirmDirective<any, any>, "[dbxActionConfirm]", never, { "config": "dbxActionConfirm"; }, {}, never>;
+}

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

@@ -0,0 +1,16 @@
+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";
+export declare class DbNgxActionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbNgxActionModule, [typeof i1.DbNgxActionKeyTriggerDirective, typeof i2.DbNgxActionSnackbarComponent, typeof i3.DbNgxActionConfirmDirective], [typeof i4.CommonModule, typeof i5.DbNgxCoreActionModule, typeof i6.DbNgxButtonModule, typeof i7.MatSnackBarModule, typeof i8.MatDialogModule, typeof i9.MatButtonModule, typeof i10.DbNgxPromptModule], [typeof i5.DbNgxCoreActionModule, typeof i1.DbNgxActionKeyTriggerDirective, typeof i2.DbNgxActionSnackbarComponent, typeof i3.DbNgxActionConfirmDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbNgxActionModule>;
+}

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

@@ -0,0 +1,22 @@
+import { Observable } from 'rxjs';
+import { MatSnackBarRef } from '@angular/material/snack-bar';
+import { Maybe } from '@dereekb/util';
+import { ActionContextStoreSourceInstance, DbNgxActionSnackbarComponentConfig } from '@dereekb/dbx-core';
+import * as i0 from "@angular/core";
+/**
+ * Component for a snackbar that contains an action.
+ */
+export declare class DbNgxActionSnackbarComponent {
+    readonly snackbar: MatSnackBarRef<DbNgxActionSnackbarComponent>;
+    readonly data: DbNgxActionSnackbarComponentConfig;
+    constructor(snackbar: MatSnackBarRef<DbNgxActionSnackbarComponent>, data: DbNgxActionSnackbarComponentConfig);
+    readonly complete$: Observable<boolean>;
+    readonly snackbarStatusClass$: Observable<string>;
+    get message(): Maybe<string>;
+    get action(): string;
+    get actionSourceInstance(): ActionContextStoreSourceInstance;
+    dismissEarly: () => void;
+    dismiss: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionSnackbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbNgxActionSnackbarComponent, "ng-component", never, {}, {}, never, never>;
+}

package/lib/action/index.d.ts

@@ -0,0 +1,5 @@
+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

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

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

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./transition.safety.directive";
+import * as i2 from "./transition.safety.dialog.component";
+import * as i3 from "@angular/common";
+import * as i4 from "@dereekb/dbx-core";
+import * as i5 from "../../interaction/prompt/prompt.module";
+import * as i6 from "../../button/button.module";
+import * as i7 from "../../error/error.module";
+/**
+ * Provides the DbNgxActionUIRouterTransitionSafetyDirective.
+ *
+ * NOTE: Only works with UIRouter
+ */
+export declare class DbNgxActionUIRouterTransitionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionUIRouterTransitionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbNgxActionUIRouterTransitionModule, [typeof i1.DbNgxActionTransitionSafetyDirective, typeof i2.DbNgxActionUIRouterTransitionSafetyDialogComponent], [typeof i3.CommonModule, typeof i4.DbNgxCoreActionModule, typeof i5.DbNgxPromptModule, typeof i6.DbNgxButtonModule, typeof i7.DbNgxReadableErrorModule], [typeof i1.DbNgxActionTransitionSafetyDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbNgxActionUIRouterTransitionModule>;
+}

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

@@ -0,0 +1,3 @@
+export * from './action.transition.module';
+export * from './transition.safety.dialog.component';
+export * from './transition.safety.directive';

package/lib/action/transition/transition.safety.dialog.component.d.ts

@@ -0,0 +1,19 @@
+import { OnInit } from '@angular/core';
+import { DbNgxPromptConfirmConfig, AbstractDialogDirective } from '../../interaction';
+import * as i0 from "@angular/core";
+export declare enum DbNgxActionTransitionSafetyDialogResult {
+    SUCCESS = 0,
+    STAY = 1,
+    DISCARD = 2,
+    NONE = 3
+}
+/**
+ * Dialog that is shown/triggered as part of the DbNgxActionTransitionSafety
+ */
+export declare class DbNgxActionUIRouterTransitionSafetyDialogComponent extends AbstractDialogDirective implements OnInit {
+    config: DbNgxPromptConfirmConfig;
+    confirm(): void;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionUIRouterTransitionSafetyDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbNgxActionUIRouterTransitionSafetyDialogComponent, "ng-component", never, {}, {}, never, never>;
+}

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

@@ -0,0 +1,52 @@
+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 * as i0 from "@angular/core";
+export declare enum DbNgxActionTransitionSafetyType {
+    /**
+     * Nothing occurs.
+     */
+    NONE = "none",
+    /**
+     * Always show a dialog and act based on the result.
+     */
+    DIALOG = "dialog",
+    /**
+     * Try to auto-trigger if in a triggerable state.
+     *
+     * If it is modified but in a non-triggerable state show a dialog.
+     *
+     * Should be used in conjuction with the auto-saver.
+     */
+    AUTO_TRIGGER = "auto"
+}
+/**
+ * Context used for preventing a transition from occuring if the action is not complete or is in a modified state.
+ *
+ * This can be configured to auto-trigger and wait, or show a dialog and wait for the user's feedback before doing anything.
+ *
+ * NOTE: This dialog only works for uirouter.
+ */
+export declare class DbNgxActionTransitionSafetyDirective<T, O> implements OnInit, OnDestroy {
+    readonly source: ActionContextStoreSourceInstance<T, O>;
+    protected readonly transitionService: TransitionService;
+    protected readonly viewContainerRef: ViewContainerRef;
+    protected readonly dialog: MatDialog;
+    inputSafetyType?: DbNgxActionTransitionSafetyType;
+    private _dialogRef?;
+    private stopWatchingTransition?;
+    constructor(source: ActionContextStoreSourceInstance<T, O>, transitionService: TransitionService, viewContainerRef: ViewContainerRef, dialog: MatDialog);
+    get safetyType(): DbNgxActionTransitionSafetyType;
+    private get _destroyed();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected _handleOnBeforeTransition(transition: Transition): HookResult;
+    protected _handleIsModifiedState(transition: Transition): Observable<HookResult>;
+    private _autoTrigger;
+    private _showDialog;
+    private _closeDialog;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionTransitionSafetyDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionTransitionSafetyDirective<any, any>, "[dbxActionTransitionSafety]", never, { "inputSafetyType": "dbxActionTransitionSafety"; }, {}, never>;
+}

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

@@ -0,0 +1,25 @@
+import { ThemePalette } from '@angular/material/core';
+import { AbstractDbNgxButtonDirective } from '@dereekb/dbx-core';
+import { MatProgressButtonOptions } from 'mat-progress-buttons';
+import * as i0 from "@angular/core";
+export declare enum DbNgxButtonDisplayType {
+    RAISED = 0,
+    STROKED = 1,
+    FLAT = 2
+}
+/**
+ * Complex button that supports loading states.
+ */
+export declare class DbNgxButtonComponent extends AbstractDbNgxButtonDirective {
+    type?: DbNgxButtonDisplayType;
+    get raised(): boolean;
+    set raised(raised: boolean);
+    get stroked(): boolean;
+    set stroked(stroked: boolean);
+    get flat(): boolean;
+    set flat(flat: boolean);
+    color: ThemePalette;
+    get btnOptions(): MatProgressButtonOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbNgxButtonComponent, "dbx-button", never, { "type": "type"; "raised": "raised"; "stroked": "stroked"; "flat": "flat"; "color": "color"; }, {}, never, never>;
+}

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

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./button.component";
+import * as i2 from "./button.spacer.component";
+import * as i3 from "@angular/platform-browser";
+import * as i4 from "@angular/material/icon";
+import * as i5 from "@angular/material/button";
+import * as i6 from "mat-progress-buttons";
+export declare class DbNgxButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbNgxButtonModule, [typeof i1.DbNgxButtonComponent, typeof i2.DbNgxButtonSpacerComponent], [typeof i3.BrowserModule, typeof i4.MatIconModule, typeof i5.MatButtonModule, typeof i6.MatProgressButtonsModule], [typeof i1.DbNgxButtonComponent, typeof i2.DbNgxButtonSpacerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbNgxButtonModule>;
+}

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

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

package/lib/button/index.d.ts

@@ -0,0 +1,3 @@
+export * from './button.component';
+export * from './button.spacer.component';
+export * from './button.module';

package/lib/dbx-web.module.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./button/button.module";
+import * as i2 from "./action/action.module";
+import * as i3 from "./loading/loading.module";
+import * as i4 from "@angular/platform-browser";
+import * as i5 from "mat-progress-buttons";
+export declare class DbNgxWebModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxWebModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbNgxWebModule, never, never, [typeof i1.DbNgxButtonModule, typeof i2.DbNgxActionModule, typeof i3.DbNgxLoadingModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbNgxWebModule>;
+}
+export declare class DbNgxSharedWebModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxSharedWebModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbNgxSharedWebModule, never, [typeof i4.BrowserModule, typeof DbNgxWebModule, typeof i5.MatProgressButtonsModule], [typeof DbNgxWebModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbNgxSharedWebModule>;
+}

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

@@ -0,0 +1,15 @@
+import { OnInit } from '@angular/core';
+import { ActionContextStoreSourceInstance, AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import { DbNgxReadableErrorComponent } from './error.component';
+import * as i0 from "@angular/core";
+/**
+ * Context used for linking an ReadableErrorComponent to an ActionContext.
+ */
+export declare class DbNgxActionErrorDirective extends AbstractSubscriptionDirective implements OnInit {
+    readonly error: DbNgxReadableErrorComponent;
+    readonly source: ActionContextStoreSourceInstance;
+    constructor(error: DbNgxReadableErrorComponent, source: ActionContextStoreSourceInstance);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxActionErrorDirective, [{ host: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxActionErrorDirective, "[dbxActionError]", never, {}, {}, never>;
+}

package/lib/error/error.api.d.ts

@@ -0,0 +1,13 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { ServerError, ServerErrorResponse } from '@dereekb/util';
+/**
+ * Converts the error response to a POJO.
+ */
+export declare function convertToPOJOServerErrorResponse(httpError: HttpErrorResponse | any): ServerError;
+/**
+ * Converts an HTTP Error Response to a ServerErrorResponse type.
+ *
+ * @param error
+ * @returns
+ */
+export declare function convertToServerErrorResponse(error: HttpErrorResponse | any): ServerErrorResponse | undefined;

package/lib/error/error.component.d.ts

@@ -0,0 +1,14 @@
+import { Maybe } from '@dereekb/util';
+import { ErrorInput, ReadableError } from '@dereekb/util';
+import * as i0 from "@angular/core";
+/**
+ * Basic error component.
+ */
+export declare class DbNgxReadableErrorComponent {
+    private _error?;
+    get error(): Maybe<ReadableError>;
+    set error(error: Maybe<ErrorInput | ReadableError>);
+    get message(): Maybe<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxReadableErrorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbNgxReadableErrorComponent, "dbx-error", never, { "error": "error"; }, {}, never, never>;
+}

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

@@ -0,0 +1,19 @@
+import { LoadingContext } from '@dereekb/rxjs';
+import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import { DbNgxReadableErrorComponent } from './error.component';
+import * as i0 from "@angular/core";
+/**
+ * Context used for linking an ReadableErrorComponent to a LoadingContext.
+ *
+ * The error from the context is given to the app error when available.
+ */
+export declare class DbNgxLoadingErrorDirective extends AbstractSubscriptionDirective {
+    readonly error: DbNgxReadableErrorComponent;
+    constructor(error: DbNgxReadableErrorComponent);
+    /**
+     * Sets a LoadingContext that is watched for the loading state.
+     */
+    set context(context: LoadingContext);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxLoadingErrorDirective, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxLoadingErrorDirective, "[dbxLoadingError]", never, { "context": "dbxLoadingError"; }, {}, never>;
+}

package/lib/error/error.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./error.component";
+import * as i2 from "./error.loading.directive";
+import * as i3 from "./error.action.directive";
+import * as i4 from "@angular/common";
+export declare class DbNgxReadableErrorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxReadableErrorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbNgxReadableErrorModule, [typeof i1.DbNgxReadableErrorComponent, typeof i2.DbNgxLoadingErrorDirective, typeof i3.DbNgxActionErrorDirective], [typeof i4.CommonModule], [typeof i1.DbNgxReadableErrorComponent, typeof i2.DbNgxLoadingErrorDirective, typeof i3.DbNgxActionErrorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbNgxReadableErrorModule>;
+}

package/lib/error/index.d.ts

@@ -0,0 +1,6 @@
+export * from './error.action.directive';
+export * from './error.api';
+export * from './error.component';
+export * from './error.loading.directive';
+export * from './error.module';
+export * from './state';

package/lib/error/state.d.ts

@@ -0,0 +1,15 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { OperatorFunction } from 'rxjs';
+import { ActionCreator, TypedAction } from '@ngrx/store/src/models';
+import { ServerError } from '@dereekb/util';
+export interface ServerErrorParams {
+    error: ServerError;
+}
+/**
+ * Converts the error response to ServerErrorParams.
+ */
+export declare function convertServerErrorParams(httpError: HttpErrorResponse | any): ServerErrorParams;
+/**
+ * Catches error server params and feeds them to an action that takes ServerErrorParams as a prop.
+ */
+export declare function catchErrorServerParams<E extends ServerErrorParams, T extends string>(action: ActionCreator<T, (props: E) => E & TypedAction<T>>, mapError?: (error: ServerErrorParams) => E): OperatorFunction<HttpErrorResponse | any, E & TypedAction<T>>;

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+export * from './action';
+export * from './button';
+export * from './error';
+export * from './interaction';
+export * from './keypress';
+export * from './loading';
+export * from './layout';
+export * from './router';
+export * from './text';

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

@@ -0,0 +1,14 @@
+import { NgZone } from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import { AbstractTransitionWatcherDirective, DbNgxRouterTransitionService } from '@dereekb/dbx-core';
+import * as i0 from "@angular/core";
+/**
+ * Abstract dialog component that closes when a transition is successful.
+ */
+export declare abstract class AbstractDialogDirective<T = any, R = any> extends AbstractTransitionWatcherDirective {
+    readonly dialogRef: MatDialogRef<T, R>;
+    constructor(dialogRef: MatDialogRef<T, R>, dbNgxRouterTransitionService: DbNgxRouterTransitionService, ngZone: NgZone);
+    protected updateForSuccessfulTransition(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractDialogDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractDialogDirective<any, any>, never, never, {}, {}, never>;
+}

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

@@ -0,0 +1 @@
+export * from './abstract.dialog.directive';

package/lib/interaction/index.d.ts

@@ -0,0 +1,4 @@
+export * from './dialog';
+export * from './popover';
+export * from './popup';
+export * from './prompt';

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

@@ -0,0 +1,13 @@
+import { DbNgxPopoverComponent } from './popover.component';
+import * as i0 from "@angular/core";
+/**
+ * Abstract popover directive.
+ */
+export declare abstract class AbstractPopoverDirective<I = any, O = any, T = any> {
+    readonly popover: DbNgxPopoverComponent<I, O, T>;
+    constructor(popover: DbNgxPopoverComponent<I, O, T>);
+    closePopover(): void;
+    returnAndClosePopover(value: O): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractPopoverDirective<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractPopoverDirective<any, any, any>, never, never, {}, {}, never>;
+}

package/lib/interaction/popover/abstract.popover.ref.directive.d.ts

@@ -0,0 +1,30 @@
+import { OnDestroy } from '@angular/core';
+import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import { EventEmitter } from '@angular/core';
+import { NgPopoverCloseEvent, NgPopoverRef } from 'ng-overlay-container';
+import * as i0 from "@angular/core";
+/**
+ * Abstract class for showing and handling a popover ref.
+ */
+export declare abstract class AbstractPopoverRefDirective<T = any, R = any> extends AbstractSubscriptionDirective {
+    private _popoverRef?;
+    showPopover(): void;
+    private _showPopoverRef;
+    protected abstract _makePopoverRef(): NgPopoverRef<T, R>;
+    protected _afterOpened(popoverRef: NgPopoverRef<T, R>): void;
+    protected _afterClosed(value: NgPopoverCloseEvent<R>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractPopoverRefDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractPopoverRefDirective<any, any>, never, never, {}, {}, never>;
+}
+/**
+ * {@link AbstractPopoverRefDirective} extension that includes open/closed events.
+ */
+export declare abstract class AbstractPopoverRefWithEventsDirective<T = any, R = any> extends AbstractPopoverRefDirective<T, R> implements OnDestroy {
+    readonly popoverOpened: EventEmitter<NgPopoverRef<T, R>>;
+    readonly popoverClosed: EventEmitter<NgPopoverCloseEvent<R>>;
+    ngOnDestroy(): void;
+    protected _afterOpened(popoverRef: NgPopoverRef<T, R>): void;
+    protected _afterClosed(event: NgPopoverCloseEvent<R>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AbstractPopoverRefWithEventsDirective<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AbstractPopoverRefWithEventsDirective<any, any>, never, never, {}, { "popoverOpened": "popoverOpened"; "popoverClosed": "popoverClosed"; }, never>;
+}

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

@@ -0,0 +1,14 @@
+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';
+export * from './popover.controls.component';
+export * from './popover.coordinator.component';
+export * from './popover.coordinator.service';
+export * from './popover.header.component';
+export * from './popover.module';
+export * from './popover.position.strategy';
+export * from './popover.scroll.content.component';
+export * from './popover.service';

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

@@ -0,0 +1,14 @@
+import { NgZone } from '@angular/core';
+import { DbNgxButtonDirective, DbNgxActionButtonDirective, ActionContextStoreSourceInstance } from '@dereekb/dbx-core';
+import { DbNgxPopoverActionDirective } from './popover.action.directive';
+import * as i0 from "@angular/core";
+/**
+ * Action directive that is used to link an DbNgxButton to an DbNgxPopoverActionDirective.
+ */
+export declare class DbNgxPopoverActionButtonDirective extends DbNgxActionButtonDirective {
+    readonly appPopoverActionDirective: DbNgxPopoverActionDirective;
+    constructor(button: DbNgxButtonDirective, source: ActionContextStoreSourceInstance, ngZone: NgZone, appPopoverActionDirective: DbNgxPopoverActionDirective);
+    protected _buttonClicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxPopoverActionButtonDirective, [{ host: true; }, null, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxPopoverActionButtonDirective, "[dbxPopoverActionButton]", never, {}, {}, never>;
+}

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

@@ -0,0 +1,33 @@
+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 * as i0 from "@angular/core";
+export interface DbNgxPopoverActionFnParam {
+    origin: ElementRef;
+}
+export declare type DbNgxPopoverActionFn<T = object> = (params: DbNgxPopoverActionFnParam) => NgPopoverRef<any, T>;
+export declare type DbNgxPopoverActionModifiedFn<T = any> = (value: T) => Observable<boolean>;
+/**
+ * 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
+ */
+export declare class DbNgxPopoverActionDirective<T = object> extends AbstractPopoverRefWithEventsDirective<any, T> implements OnInit, OnDestroy {
+    readonly elementRef: ElementRef;
+    readonly source: ActionContextStoreSourceInstance<T, any>;
+    fn?: DbNgxPopoverActionFn<T>;
+    appPopoverActionModified?: DbNgxPopoverActionModifiedFn<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<DbNgxPopoverActionDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbNgxPopoverActionDirective<any>, "[dbxPopoverAction]", ["popoverAction"], { "fn": "dbxPopoverAction"; "appPopoverActionModified": "appPopoverActionModified"; }, {}, never>;
+}

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

@@ -0,0 +1,75 @@
+import { ComponentFactoryResolver, NgZone, Type, OnInit, OnDestroy, ElementRef } from '@angular/core';
+import { NgOverlayContainerConfiguration, NgPopoverRef } from 'ng-overlay-container';
+import { AbstractTransitionWatcherDirective, DbNgxRouterTransitionService } from '@dereekb/dbx-core';
+import { LockSet } from '@dereekb/rxjs';
+import { CompactContextStore } from '../../layout';
+import { Maybe } from '@dereekb/util';
+import { DbNgxPopoverController, DbNgxPopoverKey } from './popover';
+import * as i0 from "@angular/core";
+export declare abstract class DbNgxPopoverComponentController<I, O> extends DbNgxPopoverController<I, O> {
+    getClosingValueFn?: (value?: I) => Promise<O>;
+}
+export interface DbNgxPopoverComponentConfig<I, O, T> {
+    /**
+     * Key used for uniquely identifying a limited instance.
+     *
+     * Only one popover should exist at a time given a certain key.
+     */
+    key: DbNgxPopoverKey;
+    /**
+     * Origin element to position on.
+     */
+    origin: ElementRef;
+    /**
+     * Whether or not to close if a transition occurs.
+     */
+    closeOnTransition?: boolean;
+    /**
+     * Whether or not to dismiss when the escape button is pressed.
+     *
+     * False by default.
+     */
+    closeOnEscape?: boolean;
+    /**
+     * Component to inject into the popover.
+     */
+    componentClass: Type<T>;
+    /**
+     * Data available to the popover.
+     */
+    data?: Maybe<I>;
+    init?: (component: T, controller: DbNgxPopoverController<I, O>) => void;
+}
+export interface FullDbNgxPopoverComponentConfig<I, O, T> extends DbNgxPopoverComponentConfig<I, O, T> {
+    configuration: NgOverlayContainerConfiguration;
+}
+/**
+ * Popover component.
+ */
+export declare class DbNgxPopoverComponent<I = any, O = any, T = any> extends AbstractTransitionWatcherDirective implements DbNgxPopoverController<I, O>, OnInit, OnDestroy {
+    private popoverRef;
+    private compactContextState;
+    private resolver;
+    readonly lockSet: LockSet;
+    private _content;
+    private _componentRef?;
+    private _startedClosing;
+    private readonly _closing;
+    private _triggerCloseKeys;
+    readonly isClosing$: import("rxjs").Observable<boolean>;
+    readonly closing$: import("rxjs").Observable<boolean>;
+    getClosingValueFn?: (value?: I) => Promise<O>;
+    constructor(popoverRef: NgPopoverRef<FullDbNgxPopoverComponentConfig<I, O, T>, O>, compactContextState: CompactContextStore, resolver: ComponentFactoryResolver, dbNgxRouterTransitionService: DbNgxRouterTransitionService, ngZone: NgZone);
+    get config(): FullDbNgxPopoverComponentConfig<I, O, T>;
+    get key(): DbNgxPopoverKey;
+    get data(): Maybe<I>;
+    get triggerCloseKeys(): string[];
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected updateForSuccessfulTransition(): void;
+    close(): void;
+    return(value?: O): void;
+    handleKeydown(key: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxPopoverComponent<any, any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbNgxPopoverComponent<any, any, any>, "ng-component", never, {}, {}, never, never>;
+}

package/lib/interaction/popover/popover.content.component.d.ts

@@ -0,0 +1,17 @@
+import { OnDestroy } from '@angular/core';
+import { ResizedEvent } from 'angular-resize-event';
+import * as i0 from "@angular/core";
+/**
+ * Popover content wrapper component.
+ */
+export declare class DbNgxPopoverContentComponent implements OnDestroy {
+    private readonly _height;
+    readonly height$: import("rxjs").Observable<string>;
+    scrollable: boolean;
+    hasControls: boolean;
+    hasHeader: boolean;
+    onResized(event: ResizedEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxPopoverContentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbNgxPopoverContentComponent, "dbx-popover-content", never, { "scrollable": "scrollable"; "hasControls": "hasControls"; "hasHeader": "hasHeader"; }, {}, never, ["[controls]", "*"]>;
+}

package/lib/interaction/popover/popover.controls.component.d.ts

@@ -0,0 +1,10 @@
+import { DbNgxPopoverContentComponent } from './popover.content.component';
+import * as i0 from "@angular/core";
+/**
+ * Popover Controls
+ */
+export declare class DbNgxPopoverControlsComponent {
+    constructor(appPopoverContentComponent: DbNgxPopoverContentComponent);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbNgxPopoverControlsComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbNgxPopoverControlsComponent, "dbx-popover-controls", never, {}, {}, never, ["*"]>;
+}