@theseam/ui-common 0.3.10 → 0.4.0-beta.0

package/esm2020/modal/modal-header/modal-header.component.mjs

@@ -0,0 +1,30 @@
+import { Component, ContentChild, HostBinding, Input } from '@angular/core';
+import { ModalCloseDirective } from '../directives/modal-close.directive';
+import { ModalTitleDirective } from '../directives/modal-title.directive';
+import * as i0 from "@angular/core";
+export class ModalHeaderComponent {
+    constructor() {
+        this._modalHeaderCss = true;
+        this.hasCloseBtn = true;
+    }
+    ngOnInit() {
+    }
+}
+ModalHeaderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: ModalHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ModalHeaderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.3", type: ModalHeaderComponent, selector: "seam-modal-header", inputs: { hasCloseBtn: "hasCloseBtn" }, host: { properties: { "class.modal-header": "this._modalHeaderCss" } }, queries: [{ propertyName: "_titleDirective", first: true, predicate: ModalTitleDirective, descendants: true, static: true }, { propertyName: "_closeDirective", first: true, predicate: ModalCloseDirective, descendants: true, static: true }], ngImport: i0, template: "<ng-content></ng-content>\n\n<!-- <button seamModalClose>\n  <span aria-hidden=\"true\">&times;</span>\n</button> -->\n\n<!-- seam-modal-header-close -->\n", styles: [""] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: ModalHeaderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-modal-header', template: "<ng-content></ng-content>\n\n<!-- <button seamModalClose>\n  <span aria-hidden=\"true\">&times;</span>\n</button> -->\n\n<!-- seam-modal-header-close -->\n" }]
+        }], ctorParameters: function () { return []; }, propDecorators: { _modalHeaderCss: [{
+                type: HostBinding,
+                args: ['class.modal-header']
+            }], hasCloseBtn: [{
+                type: Input
+            }], _titleDirective: [{
+                type: ContentChild,
+                args: [ModalTitleDirective, { static: true }]
+            }], _closeDirective: [{
+                type: ContentChild,
+                args: [ModalCloseDirective, { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/modal/modal.models.mjs

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const THESEAM_MODAL_CONTAINER = new InjectionToken('seamModalContainer');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwubW9kZWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvdWktY29tbW9uL21vZGFsL21vZGFsLm1vZGVscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQWdCLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQWdDNUQsTUFBTSxDQUFDLE1BQU0sdUJBQXVCLEdBQUcsSUFBSSxjQUFjLENBQWtCLG9CQUFvQixDQUFDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPdmVybGF5UmVmIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL292ZXJsYXknXG5pbXBvcnQgeyBFdmVudEVtaXR0ZXIsIEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSdcbmltcG9ydCB7IFVudHlwZWRGb3JtR3JvdXAgfSBmcm9tICdAYW5ndWxhci9mb3JtcydcblxuZXhwb3J0IGludGVyZmFjZSBJTW9kYWxDb250YWluZXIge1xuXG4gIC8qKlxuICAgKiBNb2RhbCB3aWxsIGNsb3NlIGlmIGEga2V5IGlzIHByZXNzZWQgd2l0aCBhbnkgb2YgdGhlc2Uga2V5IGNvZGVzLlxuICAgKlxuICAgKiBkZWZhdWx0OiBbIDI3IF0gLy8gMjcgPSBFU0NBUEVcbiAgICovXG4gIGNsb3NlT25LZXlQcmVzc2VkOiBudW1iZXJbXVxuXG4gIC8qKiBFbWl0cyB3aGVuIHRoZSBtb2RhbCBoYXMgY2xvc2VkLiAqL1xuICBtb2RhbENsb3NlZDogRXZlbnRFbWl0dGVyPHZvaWQ+XG5cbiAgLyoqIFJlZmVyZW5jZSB0byB0aGUgY2RrIE92ZXJsYXlSZWYuICovXG4gIF9vdmVybGF5UmVmPzogT3ZlcmxheVJlZlxuXG4gIC8qKiBNYWtlcyB0aGUgbW9kYWwgY29udGFpbmVyIGEgZm9ybSB3aXRoIHRoaXMgZm9ybUdyb3VwLiAqL1xuICBmb3JtOiBVbnR5cGVkRm9ybUdyb3VwIHwgdW5kZWZpbmVkIHwgbnVsbFxuXG4gIC8qKiBFbWl0IHRoZSBgKG5nU3VibWl0KWAgZXZlbnQuIE5PVEU6IE9ubHkgaWYgYGZvcm1gIGlzIGRlZmluZWQuICovXG4gIGZvcm1TdWJtaXQ6IEV2ZW50RW1pdHRlcjx2b2lkPlxuXG4gIC8qKiBPcGVucyB0aGUgbW9kYWwuICovXG4gIG9wZW4oKTogdm9pZFxuXG4gIC8qKiBDbG9zZXMgdGhlIG1vZGFsLiAqL1xuICBjbG9zZSgpOiB2b2lkXG5cbn1cblxuZXhwb3J0IGNvbnN0IFRIRVNFQU1fTU9EQUxfQ09OVEFJTkVSID0gbmV3IEluamVjdGlvblRva2VuPElNb2RhbENvbnRhaW5lcj4oJ3NlYW1Nb2RhbENvbnRhaW5lcicpXG4iXX0=

package/esm2020/modal/modal.module.mjs

@@ -0,0 +1,127 @@
+import { A11yModule } from '@angular/cdk/a11y';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { PortalModule } from '@angular/cdk/portal';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { RouterModule } from '@angular/router';
+import { FontAwesomeModule } from '@fortawesome/angular-fontawesome';
+import { ModalCloseDirective } from './directives/modal-close.directive';
+import { ModalFooterTplDirective } from './directives/modal-footer-tpl.directive';
+import { ModalHeaderIconTplDirective } from './directives/modal-header-icon-tpl.directive';
+import { ModalHeaderTitleTplDirective } from './directives/modal-header-title-tpl.directive';
+import { ModalTitleDirective } from './directives/modal-title.directive';
+import { ModalDirective } from './directives/modal.directive';
+import { ModalBodyComponent } from './modal-body/modal-body.component';
+import { ModalConfig } from './modal-config';
+import { ModalContainerComponent } from './modal-container/modal-container.component';
+import { ModalFooterComponent } from './modal-footer/modal-footer.component';
+import { ModalHeaderComponent } from './modal-header/modal-header.component';
+import { MODAL_CONFIG, MODAL_CONTAINER, MODAL_REF, THESEAM_MODAL_SCROLL_STRATEGY_PROVIDER } from './modal-injectors';
+import { ModalRef } from './modal-ref';
+import { Modal } from './modal.service';
+import { ModalComponent } from './modal/modal.component';
+import { RouteModalComponent } from './route-modal/route-modal.component';
+import * as i0 from "@angular/core";
+export class TheSeamModalModule {
+}
+TheSeamModalModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamModalModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TheSeamModalModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.3", ngImport: i0, type: TheSeamModalModule, declarations: [ModalComponent,
+        ModalFooterTplDirective,
+        ModalHeaderIconTplDirective,
+        ModalHeaderTitleTplDirective,
+        RouteModalComponent,
+        ModalDirective,
+        ModalContainerComponent,
+        ModalHeaderComponent,
+        ModalTitleDirective,
+        ModalBodyComponent,
+        ModalFooterComponent,
+        ModalCloseDirective], imports: [CommonModule,
+        OverlayModule,
+        FontAwesomeModule,
+        RouterModule,
+        ReactiveFormsModule,
+        PortalModule,
+        A11yModule], exports: [ModalComponent,
+        ModalFooterTplDirective,
+        ModalHeaderIconTplDirective,
+        ModalHeaderTitleTplDirective,
+        RouteModalComponent,
+        ModalDirective,
+        // Re-export the PortalModule so that people extending the `CdkDialogContainer`
+        // don't have to remember to import it or be faced with an unhelpful error.
+        PortalModule,
+        ModalHeaderComponent,
+        ModalTitleDirective,
+        ModalBodyComponent,
+        ModalFooterComponent,
+        ModalCloseDirective] });
+TheSeamModalModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamModalModule, providers: [
+        Modal,
+        THESEAM_MODAL_SCROLL_STRATEGY_PROVIDER,
+        { provide: MODAL_REF, useValue: ModalRef },
+        { provide: MODAL_CONTAINER, useValue: ModalContainerComponent },
+        { provide: MODAL_CONFIG, useValue: ModalConfig },
+    ], imports: [CommonModule,
+        OverlayModule,
+        FontAwesomeModule,
+        RouterModule,
+        ReactiveFormsModule,
+        PortalModule,
+        A11yModule, 
+        // Re-export the PortalModule so that people extending the `CdkDialogContainer`
+        // don't have to remember to import it or be faced with an unhelpful error.
+        PortalModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: TheSeamModalModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ModalComponent,
+                        ModalFooterTplDirective,
+                        ModalHeaderIconTplDirective,
+                        ModalHeaderTitleTplDirective,
+                        RouteModalComponent,
+                        ModalDirective,
+                        ModalContainerComponent,
+                        ModalHeaderComponent,
+                        ModalTitleDirective,
+                        ModalBodyComponent,
+                        ModalFooterComponent,
+                        ModalCloseDirective
+                    ],
+                    imports: [
+                        CommonModule,
+                        OverlayModule,
+                        FontAwesomeModule,
+                        RouterModule,
+                        ReactiveFormsModule,
+                        PortalModule,
+                        A11yModule,
+                    ],
+                    exports: [
+                        ModalComponent,
+                        ModalFooterTplDirective,
+                        ModalHeaderIconTplDirective,
+                        ModalHeaderTitleTplDirective,
+                        RouteModalComponent,
+                        ModalDirective,
+                        // Re-export the PortalModule so that people extending the `CdkDialogContainer`
+                        // don't have to remember to import it or be faced with an unhelpful error.
+                        PortalModule,
+                        ModalHeaderComponent,
+                        ModalTitleDirective,
+                        ModalBodyComponent,
+                        ModalFooterComponent,
+                        ModalCloseDirective
+                    ],
+                    providers: [
+                        Modal,
+                        THESEAM_MODAL_SCROLL_STRATEGY_PROVIDER,
+                        { provide: MODAL_REF, useValue: ModalRef },
+                        { provide: MODAL_CONTAINER, useValue: ModalContainerComponent },
+                        { provide: MODAL_CONFIG, useValue: ModalConfig },
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/modal/modal.service.mjs

@@ -0,0 +1,349 @@
+import { Directionality } from '@angular/cdk/bidi';
+import { OverlayConfig, } from '@angular/cdk/overlay';
+import { ComponentPortal, PortalInjector, TemplatePortal } from '@angular/cdk/portal';
+import { Inject, Injectable, Optional, SkipSelf } from '@angular/core';
+import { defer, of, of as observableOf, Subject } from 'rxjs';
+import { startWith, switchMap } from 'rxjs/operators';
+import { ModalConfig } from './modal-config';
+import { MODAL_CONFIG, MODAL_CONTAINER, MODAL_DATA, MODAL_REF, MODAL_SCROLL_STRATEGY, } from './modal-injectors';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/common";
+import * as i3 from "@theseam/ui-common/scrollbar";
+import * as i4 from "@theseam/ui-common/dynamic-component-loader";
+/**
+ * Service to open modal dialogs.
+ */
+export class Modal {
+    constructor(overlay, injector, dialogRefConstructor, scrollStrategy, _parentDialog, location, _scrollbars, _dynamicComponentLoaderModule) {
+        this.overlay = overlay;
+        this.injector = injector;
+        this.dialogRefConstructor = dialogRefConstructor;
+        this._parentDialog = _parentDialog;
+        this._scrollbars = _scrollbars;
+        this._dynamicComponentLoaderModule = _dynamicComponentLoaderModule;
+        this._afterAllClosedBase = new Subject();
+        this.afterAllClosed = defer(() => this.openDialogs.length ?
+            this._afterAllClosed : this._afterAllClosed.pipe(startWith(undefined)));
+        this._afterOpened = new Subject();
+        this._openDialogs = [];
+        // Close all of the dialogs when the user goes forwards/backwards in history or when the
+        // location hash changes. Note that this usually doesn't include clicking on links (unless
+        // the user is using the `HashLocationStrategy`).
+        if (!_parentDialog && location) {
+            location.subscribe(() => this.closeAll());
+        }
+        this._scrollStrategy = scrollStrategy;
+    }
+    /** Stream that emits when all dialogs are closed. */
+    get _afterAllClosed() {
+        return this._parentDialog ? this._parentDialog.afterAllClosed : this._afterAllClosedBase;
+    }
+    /** Stream that emits when a dialog is opened. */
+    get afterOpened() {
+        return this._parentDialog ? this._parentDialog.afterOpened : this._afterOpened;
+    }
+    /** Stream that emits when a dialog is opened. */
+    get openDialogs() {
+        return this._parentDialog ? this._parentDialog.openDialogs : this._openDialogs;
+    }
+    /** Gets an open dialog by id. */
+    getById(id) {
+        return this._openDialogs.find(ref => ref.id === id);
+    }
+    /** Closes all open dialogs. */
+    closeAll() {
+        this.openDialogs.forEach(ref => ref.close());
+    }
+    /** Opens a dialog from a component. */
+    openFromComponent(component, config, 
+    // NOTE: Should only be needed with the current implementation of `TheSeamDynamicComponentLoader`.
+    componentFactoryResolver) {
+        config = this._applyConfigDefaults(config);
+        if (config.id && this.getById(config.id)) {
+            throw Error(`Modal with id "${config.id}" exists already. The modal id must be unique.`);
+        }
+        const overlayRef = this._createOverlay(config);
+        const dialogContainer = this._attachDialogContainer(overlayRef, config);
+        const dialogRef = this._attachDialogContentForComponent(component, dialogContainer, overlayRef, config, componentFactoryResolver);
+        this.registerDialogRef(dialogRef);
+        return dialogRef;
+    }
+    /** Opens a dialog from a template. */
+    openFromTemplate(template, config) {
+        config = this._applyConfigDefaults(config);
+        if (config.id && this.getById(config.id)) {
+            throw Error(`Modal with id "${config.id}" exists already. The modal id must be unique.`);
+        }
+        const overlayRef = this._createOverlay(config);
+        const dialogContainer = this._attachDialogContainer(overlayRef, config);
+        const dialogRef = this._attachDialogContentForTemplate(template, dialogContainer, overlayRef, config);
+        this.registerDialogRef(dialogRef);
+        return dialogRef;
+    }
+    /** Opens a dialog from a lazy-loaded component. */
+    openFromLazyComponent(componentId, config) {
+        config = this._applyConfigDefaults(config);
+        if (config.id && this.getById(config.id)) {
+            throw Error(`Modal with id "${config.id}" exists already. The modal id must be unique.`);
+        }
+        return this._dynamicComponentLoaderModule
+            .getComponentFactory(componentId)
+            .pipe(switchMap(componentFactory => {
+            const modalRef = this.openFromComponent(componentFactory.componentType, config, componentFactory.ngModule.componentFactoryResolver);
+            return of(modalRef);
+        }));
+    }
+    ngOnDestroy() {
+        // Only close all the dialogs at this level.
+        this._openDialogs.forEach(ref => ref.close());
+    }
+    /**
+     * Forwards emitting events for when dialogs are opened and all dialogs are closed.
+     */
+    registerDialogRef(dialogRef) {
+        this.openDialogs.push(dialogRef);
+        let cleanupScroll;
+        const dialogBeforeOpenSub = dialogRef.beforeOpened().subscribe(() => {
+            cleanupScroll = this._registerDialogRefScrollEvents(dialogRef);
+            dialogBeforeOpenSub.unsubscribe();
+        });
+        const dialogBeforeCloseSub = dialogRef.beforeClosed().subscribe(() => {
+            // TODO: Do I need to destroy the instance? I feel like I should, but the
+            // way I have this implemented currently causes the native scrollbar to
+            // appear before the element is removed from the DOM.
+            // this._scrollbars.destroyInstance(dialogRef._overlayRef.overlayElement)
+            if (cleanupScroll) {
+                cleanupScroll();
+            }
+            dialogBeforeCloseSub.unsubscribe();
+        });
+        const dialogOpenSub = dialogRef.afterOpened().subscribe(() => {
+            this.afterOpened.next(dialogRef);
+            dialogOpenSub.unsubscribe();
+        });
+        const dialogCloseSub = dialogRef.afterClosed().subscribe(() => {
+            // this._scrollbars.destroyInstance(dialogRef._overlayRef.overlayElement)
+            const dialogIndex = this._openDialogs.indexOf(dialogRef);
+            if (dialogIndex > -1) {
+                this._openDialogs.splice(dialogIndex, 1);
+            }
+            if (!this._openDialogs.length) {
+                this._afterAllClosedBase.next();
+                dialogCloseSub.unsubscribe();
+            }
+        });
+    }
+    // TODO: Cleanup. This was rushed together fast and became an unefficient mess.
+    _registerDialogRefScrollEvents(dialogRef) {
+        const _scrollbarMouseDownListener = () => {
+            if (dialogRef) {
+                dialogRef.disableClose = true;
+            }
+        };
+        const _scrollbarMouseUpListener = () => {
+            setTimeout(() => { if (dialogRef) {
+                dialogRef.disableClose = false;
+            } });
+        };
+        let verticalHandleElement;
+        let horizontalHandleElement;
+        this._scrollbars.initializeInstance(dialogRef._overlayRef.overlayElement, {
+            callbacks: {
+                onInitialized: () => {
+                    // console.log('onInitialized')
+                    setTimeout(() => {
+                        const instance = this._scrollbars.getInstance(dialogRef._overlayRef.overlayElement);
+                        if (instance) {
+                            verticalHandleElement = instance.getElements().scrollbarVertical.handle;
+                            if (verticalHandleElement) {
+                                verticalHandleElement.addEventListener('mousedown', _scrollbarMouseDownListener);
+                                verticalHandleElement.addEventListener('touchstart', _scrollbarMouseDownListener);
+                            }
+                            horizontalHandleElement = instance.getElements().scrollbarHorizontal.handle;
+                            if (horizontalHandleElement) {
+                                horizontalHandleElement.addEventListener('mousedown', _scrollbarMouseDownListener);
+                                horizontalHandleElement.addEventListener('touchstart', _scrollbarMouseDownListener);
+                            }
+                            if (verticalHandleElement || horizontalHandleElement) {
+                                document.addEventListener('mouseup', _scrollbarMouseUpListener);
+                                document.addEventListener('touchend', _scrollbarMouseUpListener);
+                                document.addEventListener('touchcancel', _scrollbarMouseUpListener);
+                            }
+                        }
+                    });
+                },
+                onDestroyed: () => {
+                    // console.log('onDestroyed')
+                    // // const instance = this._scrollbars.getInstance(dialogRef._overlayRef.overlayElement)
+                    // // const scrollElem = instance.getElements().scrollbarVertical.handle
+                    // if (verticalHandleElement) {
+                    //   verticalHandleElement.removeEventListener('mousedown', _scrollbarMouseDownListener)
+                    //   verticalHandleElement.removeEventListener('touchstart', _scrollbarMouseDownListener)
+                    // }
+                    // if (horizontalHandleElement) {
+                    //   horizontalHandleElement.removeEventListener('mousedown', _scrollbarMouseDownListener)
+                    //   horizontalHandleElement.removeEventListener('touchstart', _scrollbarMouseDownListener)
+                    // }
+                    // if (verticalHandleElement || horizontalHandleElement) {
+                    //   document.removeEventListener('mouseup', _scrollbarMouseUpListener)
+                    //   document.removeEventListener('touchend', _scrollbarMouseUpListener)
+                    //   document.removeEventListener('touchcancel', _scrollbarMouseUpListener)
+                    // }
+                }
+            }
+        });
+        // Cleans up the registered events.
+        return () => {
+            // console.log('scrollevents cleanup')
+            // const instance = this._scrollbars.getInstance(dialogRef._overlayRef.overlayElement)
+            // const scrollElem = instance.getElements().scrollbarVertical.handle
+            if (verticalHandleElement) {
+                verticalHandleElement.removeEventListener('mousedown', _scrollbarMouseDownListener);
+                verticalHandleElement.removeEventListener('touchstart', _scrollbarMouseDownListener);
+            }
+            if (horizontalHandleElement) {
+                horizontalHandleElement.removeEventListener('mousedown', _scrollbarMouseDownListener);
+                horizontalHandleElement.removeEventListener('touchstart', _scrollbarMouseDownListener);
+            }
+            if (verticalHandleElement || horizontalHandleElement) {
+                document.removeEventListener('mouseup', _scrollbarMouseUpListener);
+                document.removeEventListener('touchend', _scrollbarMouseUpListener);
+                document.removeEventListener('touchcancel', _scrollbarMouseUpListener);
+            }
+        };
+    }
+    /**
+     * Creates an overlay config from a dialog config.
+     * @param config The dialog configuration.
+     * @returns The overlay configuration.
+     */
+    _createOverlay(config) {
+        let panelClass = (config.panelClass || []);
+        if (typeof panelClass === 'string') {
+            panelClass = [panelClass];
+        }
+        panelClass = [...panelClass, 'modal', 'd-block', 'overflow-auto'];
+        const overlayConfig = new OverlayConfig({
+            positionStrategy: this.overlay.position().global(),
+            scrollStrategy: this._scrollStrategy(),
+            panelClass: panelClass,
+            hasBackdrop: config.hasBackdrop,
+            direction: config.direction,
+            minWidth: config.minWidth,
+            minHeight: config.minHeight,
+            maxWidth: config.maxWidth,
+            maxHeight: config.maxHeight
+        });
+        if (config.backdropClass) {
+            overlayConfig.backdropClass = config.backdropClass;
+        }
+        return this.overlay.create(overlayConfig);
+    }
+    /**
+     * Attaches an MatDialogContainer to a dialog's already-created overlay.
+     * @param overlay Reference to the dialog's underlying overlay.
+     * @param config The dialog configuration.
+     * @returns A promise resolving to a ComponentRef for the attached container.
+     */
+    _attachDialogContainer(overlay, config) {
+        const container = config.containerComponent || this.injector.get(MODAL_CONTAINER);
+        const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;
+        const injector = new PortalInjector(userInjector || this.injector, new WeakMap([
+            [ModalConfig, config]
+        ]));
+        const containerPortal = new ComponentPortal(container, config.viewContainerRef, injector);
+        const containerRef = overlay.attach(containerPortal);
+        containerRef.instance._config = config;
+        return containerRef.instance;
+    }
+    /**
+     * Attaches the user-provided component to the already-created MatDialogContainer.
+     * @param componentOrTemplateRef The type of component being loaded into the dialog,
+     *     or a TemplateRef to instantiate as the content.
+     * @param dialogContainer Reference to the wrapping MatDialogContainer.
+     * @param overlayRef Reference to the overlay in which the dialog resides.
+     * @param config The dialog configuration.
+     * @returns A promise resolving to the MatDialogRef that should be returned to the user.
+     */
+    _attachDialogContentForComponent(componentOrTemplateRef, dialogContainer, overlayRef, config, componentFactoryResolver) {
+        // Create a reference to the dialog we're creating in order to give the user a handle
+        // to modify and close it.
+        const dialogRef = new this.dialogRefConstructor(overlayRef, dialogContainer, config.id);
+        const injector = this._createInjector(config, dialogRef, dialogContainer);
+        const contentRef = dialogContainer.attachComponentPortal(new ComponentPortal(componentOrTemplateRef, undefined, injector, componentFactoryResolver));
+        dialogRef.componentInstance = contentRef.instance;
+        dialogRef.disableClose = config.disableClose;
+        dialogRef.updateSize({ width: config.width, height: config.height })
+            .updatePosition(config.position);
+        return dialogRef;
+    }
+    /**
+     * Attaches the user-provided component to the already-created MatDialogContainer.
+     * @param componentOrTemplateRef The type of component being loaded into the dialog,
+     *     or a TemplateRef to instantiate as the content.
+     * @param dialogContainer Reference to the wrapping MatDialogContainer.
+     * @param overlayRef Reference to the overlay in which the dialog resides.
+     * @param config The dialog configuration.
+     * @returns A promise resolving to the MatDialogRef that should be returned to the user.
+     */
+    _attachDialogContentForTemplate(componentOrTemplateRef, dialogContainer, overlayRef, config) {
+        // Create a reference to the dialog we're creating in order to give the user a handle
+        // to modify and close it.
+        const dialogRef = new this.dialogRefConstructor(overlayRef, dialogContainer, config.id);
+        dialogContainer.attachTemplatePortal(new TemplatePortal(componentOrTemplateRef, null, { $implicit: config.data, dialogRef }));
+        dialogRef.updateSize({ width: config.width, height: config.height })
+            .updatePosition(config.position);
+        return dialogRef;
+    }
+    /**
+     * Creates a custom injector to be used inside the dialog. This allows a component loaded inside
+     * of a dialog to close itself and, optionally, to return a value.
+     * @param config Config object that is used to construct the dialog.
+     * @param dialogRef Reference to the dialog.
+     * @param container Dialog container element that wraps all of the contents.
+     * @returns The custom injector that can be used inside the dialog.
+     */
+    _createInjector(config, dialogRef, dialogContainer) {
+        const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;
+        const injectionTokens = new WeakMap([
+            [this.injector.get(MODAL_REF), dialogRef],
+            [this.injector.get(MODAL_CONTAINER), dialogContainer],
+            [MODAL_DATA, config.data]
+        ]);
+        if (config.direction &&
+            (!userInjector || !userInjector.get(Directionality, null))) {
+            injectionTokens.set(Directionality, {
+                value: config.direction,
+                change: observableOf()
+            });
+        }
+        return new PortalInjector(userInjector || this.injector, injectionTokens);
+    }
+    /**
+     * Expands the provided configuration object to include the default values for properties which
+     * are undefined.
+     */
+    _applyConfigDefaults(config) {
+        const dialogConfig = this.injector.get(MODAL_CONFIG);
+        return { ...new dialogConfig(), ...config };
+    }
+}
+Modal.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: Modal, deps: [{ token: i1.Overlay }, { token: i0.Injector }, { token: MODAL_REF }, { token: MODAL_SCROLL_STRATEGY }, { token: Modal, optional: true, skipSelf: true }, { token: i2.Location, optional: true }, { token: i3.OverlayScrollbarsService }, { token: i4.TheSeamDynamicComponentLoader }], target: i0.ɵɵFactoryTarget.Injectable });
+Modal.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: Modal });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: Modal, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.Injector }, { type: i0.Type, decorators: [{
+                    type: Inject,
+                    args: [MODAL_REF]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MODAL_SCROLL_STRATEGY]
+                }] }, { type: Modal, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i2.Location, decorators: [{
+                    type: Optional
+                }] }, { type: i3.OverlayScrollbarsService }, { type: i4.TheSeamDynamicComponentLoader }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal.service.js","sourceRoot":"","sources":["../../../../projects/ui-common/modal/modal.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directionality } from '@angular/cdk/bidi'\nimport {\n  ComponentType,\n  Overlay,\n  OverlayConfig,\n  OverlayRef,\n  ScrollStrategy,\n} from '@angular/cdk/overlay'\nimport { ComponentPortal, PortalInjector, TemplatePortal } from '@angular/cdk/portal'\nimport { Location } from '@angular/common'\nimport {\n  ComponentFactoryResolver,\n  ComponentRef,\n  Inject,\n  Injectable,\n  Injector,\n  OnDestroy,\n  Optional,\n  SkipSelf,\n  TemplateRef,\n  Type\n} from '@angular/core'\nimport { defer, Observable, of, of as observableOf, Subject } from 'rxjs'\nimport { startWith, switchMap } from 'rxjs/operators'\n\nimport { TheSeamDynamicComponentLoader } from '@theseam/ui-common/dynamic-component-loader'\nimport { OverlayScrollbarsService } from '@theseam/ui-common/scrollbar'\n\nimport { ModalConfig } from './modal-config'\nimport { ModalContainerComponent } from './modal-container/modal-container.component'\nimport {\n  MODAL_CONFIG,\n  MODAL_CONTAINER,\n  MODAL_DATA,\n  MODAL_REF,\n  MODAL_SCROLL_STRATEGY,\n} from './modal-injectors'\nimport { ModalRef } from './modal-ref'\n\n\n/**\n * Service to open modal dialogs.\n */\n@Injectable()\nexport class Modal implements OnDestroy {\n  private _scrollStrategy: () => ScrollStrategy\n\n  /** Stream that emits when all dialogs are closed. */\n  get _afterAllClosed(): Observable<void> {\n    return this._parentDialog ? this._parentDialog.afterAllClosed : this._afterAllClosedBase\n  }\n  _afterAllClosedBase = new Subject<void>()\n\n  afterAllClosed: Observable<void> = defer(() => this.openDialogs.length ?\n      this._afterAllClosed : this._afterAllClosed.pipe(startWith(undefined)))\n\n  /** Stream that emits when a dialog is opened. */\n  get afterOpened(): Subject<ModalRef<any>> {\n    return this._parentDialog ? this._parentDialog.afterOpened : this._afterOpened\n  }\n  _afterOpened: Subject<ModalRef<any>> = new Subject()\n\n  /** Stream that emits when a dialog is opened. */\n  get openDialogs(): ModalRef<any>[] {\n    return this._parentDialog ? this._parentDialog.openDialogs : this._openDialogs\n  }\n  _openDialogs: ModalRef<any>[] = []\n\n  constructor(\n    private overlay: Overlay,\n    private injector: Injector,\n    @Inject(MODAL_REF) private dialogRefConstructor: Type<ModalRef<any>>,\n    @Inject(MODAL_SCROLL_STRATEGY) scrollStrategy: any,\n    @Optional() @SkipSelf() private _parentDialog: Modal,\n    @Optional() location: Location,\n    private _scrollbars: OverlayScrollbarsService,\n    private _dynamicComponentLoaderModule: TheSeamDynamicComponentLoader\n  ) {\n\n    // Close all of the dialogs when the user goes forwards/backwards in history or when the\n    // location hash changes. Note that this usually doesn't include clicking on links (unless\n    // the user is using the `HashLocationStrategy`).\n    if (!_parentDialog && location) {\n      location.subscribe(() => this.closeAll())\n    }\n\n    this._scrollStrategy = scrollStrategy\n  }\n\n  /** Gets an open dialog by id. */\n  getById(id: string): ModalRef<any> | undefined {\n    return this._openDialogs.find(ref  => ref.id === id)\n  }\n\n  /** Closes all open dialogs. */\n  closeAll(): void {\n    this.openDialogs.forEach(ref => ref.close())\n  }\n\n  /** Opens a dialog from a component. */\n  openFromComponent<T, D = any>(\n    component: ComponentType<T>,\n    config?: ModalConfig<D>,\n    // NOTE: Should only be needed with the current implementation of `TheSeamDynamicComponentLoader`.\n    componentFactoryResolver?: ComponentFactoryResolver | null | undefined\n  ): ModalRef<T, D> {\n    config = this._applyConfigDefaults(config)\n\n    if (config.id && this.getById(config.id)) {\n      throw Error(`Modal with id \"${config.id}\" exists already. The modal id must be unique.`)\n    }\n\n    const overlayRef = this._createOverlay(config)\n    const dialogContainer = this._attachDialogContainer(overlayRef, config)\n    const dialogRef = this._attachDialogContentForComponent(component, dialogContainer,\n      overlayRef, config, componentFactoryResolver)\n\n    this.registerDialogRef(dialogRef)\n    return dialogRef\n  }\n\n  /** Opens a dialog from a template. */\n  openFromTemplate<T>(template: TemplateRef<T>, config?: ModalConfig): ModalRef<any> {\n    config = this._applyConfigDefaults(config)\n\n    if (config.id && this.getById(config.id)) {\n      throw Error(`Modal with id \"${config.id}\" exists already. The modal id must be unique.`)\n    }\n\n    const overlayRef = this._createOverlay(config)\n    const dialogContainer = this._attachDialogContainer(overlayRef, config)\n    const dialogRef = this._attachDialogContentForTemplate(template, dialogContainer,\n      overlayRef, config)\n\n    this.registerDialogRef(dialogRef)\n    return dialogRef\n  }\n\n  /** Opens a dialog from a lazy-loaded component. */\n  openFromLazyComponent<T, D = any>(\n    componentId: string,\n    config?: ModalConfig<D>\n  ): Observable<ModalRef<T, D>> {\n    config = this._applyConfigDefaults(config)\n\n    if (config.id && this.getById(config.id)) {\n      throw Error(`Modal with id \"${config.id}\" exists already. The modal id must be unique.`)\n    }\n\n    return this._dynamicComponentLoaderModule\n      .getComponentFactory<{}>(componentId)\n      .pipe(\n        switchMap(componentFactory => {\n          const modalRef = this.openFromComponent(\n            componentFactory.componentType,\n            config,\n            (<any /* ComponentFactoryBoundToModule */>componentFactory).ngModule.componentFactoryResolver\n          )\n          return of(modalRef)\n        })\n      )\n  }\n\n  ngOnDestroy() {\n    // Only close all the dialogs at this level.\n    this._openDialogs.forEach(ref => ref.close())\n  }\n\n  /**\n   * Forwards emitting events for when dialogs are opened and all dialogs are closed.\n   */\n  private registerDialogRef(dialogRef: ModalRef<any>): void {\n    this.openDialogs.push(dialogRef)\n\n    let cleanupScroll: (() => void) | undefined\n    const dialogBeforeOpenSub = dialogRef.beforeOpened().subscribe(() => {\n      cleanupScroll = this._registerDialogRefScrollEvents(dialogRef)\n      dialogBeforeOpenSub.unsubscribe()\n    })\n\n    const dialogBeforeCloseSub = dialogRef.beforeClosed().subscribe(() => {\n      // TODO: Do I need to destroy the instance? I feel like I should, but the\n      // way I have this implemented currently causes the native scrollbar to\n      // appear before the element is removed from the DOM.\n      // this._scrollbars.destroyInstance(dialogRef._overlayRef.overlayElement)\n      if (cleanupScroll) {\n        cleanupScroll()\n      }\n\n      dialogBeforeCloseSub.unsubscribe()\n    })\n\n    const dialogOpenSub = dialogRef.afterOpened().subscribe(() => {\n      this.afterOpened.next(dialogRef)\n      dialogOpenSub.unsubscribe()\n    })\n\n    const dialogCloseSub = dialogRef.afterClosed().subscribe(() => {\n      // this._scrollbars.destroyInstance(dialogRef._overlayRef.overlayElement)\n      const dialogIndex = this._openDialogs.indexOf(dialogRef)\n\n      if (dialogIndex > -1) {\n        this._openDialogs.splice(dialogIndex, 1)\n      }\n\n      if (!this._openDialogs.length) {\n        this._afterAllClosedBase.next()\n        dialogCloseSub.unsubscribe()\n      }\n    })\n  }\n\n  // TODO: Cleanup. This was rushed together fast and became an unefficient mess.\n  private _registerDialogRefScrollEvents(dialogRef: ModalRef<any>): () => void {\n    const _scrollbarMouseDownListener = () => {\n      if (dialogRef) { dialogRef.disableClose = true }\n    }\n    const _scrollbarMouseUpListener = () => {\n      setTimeout(() => { if (dialogRef) { dialogRef.disableClose = false } })\n    }\n\n    let verticalHandleElement: HTMLElement | undefined\n    let horizontalHandleElement: HTMLElement | undefined\n    this._scrollbars.initializeInstance(dialogRef._overlayRef.overlayElement, {\n      callbacks: {\n        onInitialized: () => {\n          // console.log('onInitialized')\n          setTimeout(() => {\n            const instance = this._scrollbars.getInstance(dialogRef._overlayRef.overlayElement)\n            if (instance) {\n              verticalHandleElement = instance.getElements().scrollbarVertical.handle\n              if (verticalHandleElement) {\n                verticalHandleElement.addEventListener('mousedown', _scrollbarMouseDownListener)\n                verticalHandleElement.addEventListener('touchstart', _scrollbarMouseDownListener)\n              }\n              horizontalHandleElement = instance.getElements().scrollbarHorizontal.handle\n              if (horizontalHandleElement) {\n                horizontalHandleElement.addEventListener('mousedown', _scrollbarMouseDownListener)\n                horizontalHandleElement.addEventListener('touchstart', _scrollbarMouseDownListener)\n              }\n              if (verticalHandleElement || horizontalHandleElement) {\n                document.addEventListener('mouseup', _scrollbarMouseUpListener)\n                document.addEventListener('touchend', _scrollbarMouseUpListener)\n                document.addEventListener('touchcancel', _scrollbarMouseUpListener)\n              }\n            }\n          })\n        },\n        onDestroyed: () => {\n          // console.log('onDestroyed')\n          // // const instance = this._scrollbars.getInstance(dialogRef._overlayRef.overlayElement)\n          // // const scrollElem = instance.getElements().scrollbarVertical.handle\n          // if (verticalHandleElement) {\n          //   verticalHandleElement.removeEventListener('mousedown', _scrollbarMouseDownListener)\n          //   verticalHandleElement.removeEventListener('touchstart', _scrollbarMouseDownListener)\n          // }\n          // if (horizontalHandleElement) {\n          //   horizontalHandleElement.removeEventListener('mousedown', _scrollbarMouseDownListener)\n          //   horizontalHandleElement.removeEventListener('touchstart', _scrollbarMouseDownListener)\n          // }\n          // if (verticalHandleElement || horizontalHandleElement) {\n          //   document.removeEventListener('mouseup', _scrollbarMouseUpListener)\n          //   document.removeEventListener('touchend', _scrollbarMouseUpListener)\n          //   document.removeEventListener('touchcancel', _scrollbarMouseUpListener)\n          // }\n        }\n      }\n    })\n\n    // Cleans up the registered events.\n    return () => {\n      // console.log('scrollevents cleanup')\n      // const instance = this._scrollbars.getInstance(dialogRef._overlayRef.overlayElement)\n      // const scrollElem = instance.getElements().scrollbarVertical.handle\n      if (verticalHandleElement) {\n        verticalHandleElement.removeEventListener('mousedown', _scrollbarMouseDownListener)\n        verticalHandleElement.removeEventListener('touchstart', _scrollbarMouseDownListener)\n      }\n      if (horizontalHandleElement) {\n        horizontalHandleElement.removeEventListener('mousedown', _scrollbarMouseDownListener)\n        horizontalHandleElement.removeEventListener('touchstart', _scrollbarMouseDownListener)\n      }\n      if (verticalHandleElement || horizontalHandleElement) {\n        document.removeEventListener('mouseup', _scrollbarMouseUpListener)\n        document.removeEventListener('touchend', _scrollbarMouseUpListener)\n        document.removeEventListener('touchcancel', _scrollbarMouseUpListener)\n      }\n    }\n  }\n\n  /**\n   * Creates an overlay config from a dialog config.\n   * @param config The dialog configuration.\n   * @returns The overlay configuration.\n   */\n  protected _createOverlay(config: ModalConfig): OverlayRef {\n    let panelClass = (config.panelClass || [])\n    if (typeof panelClass === 'string') {\n      panelClass = [ panelClass ]\n    }\n    panelClass = [ ...panelClass, 'modal',  'd-block', 'overflow-auto' ]\n\n    const overlayConfig = new OverlayConfig({\n      positionStrategy: this.overlay.position().global(),\n      scrollStrategy: this._scrollStrategy(),\n      panelClass: panelClass,\n      hasBackdrop: config.hasBackdrop,\n      direction: config.direction,\n      minWidth: config.minWidth,\n      minHeight: config.minHeight,\n      maxWidth: config.maxWidth,\n      maxHeight: config.maxHeight\n    })\n\n    if (config.backdropClass) {\n      overlayConfig.backdropClass = config.backdropClass\n    }\n    return this.overlay.create(overlayConfig)\n  }\n\n  /**\n   * Attaches an MatDialogContainer to a dialog's already-created overlay.\n   * @param overlay Reference to the dialog's underlying overlay.\n   * @param config The dialog configuration.\n   * @returns A promise resolving to a ComponentRef for the attached container.\n   */\n  protected _attachDialogContainer(overlay: OverlayRef, config: ModalConfig): ModalContainerComponent {\n    const container = config.containerComponent || this.injector.get(MODAL_CONTAINER)\n    const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector\n    const injector = new PortalInjector(userInjector || this.injector, new WeakMap([\n      [ModalConfig, config]\n    ]))\n    const containerPortal = new ComponentPortal(container, config.viewContainerRef, injector)\n    const containerRef = <ComponentRef<ModalContainerComponent>>overlay.attach(containerPortal)\n    containerRef.instance._config = config\n\n    return containerRef.instance\n  }\n\n\n  /**\n   * Attaches the user-provided component to the already-created MatDialogContainer.\n   * @param componentOrTemplateRef The type of component being loaded into the dialog,\n   *     or a TemplateRef to instantiate as the content.\n   * @param dialogContainer Reference to the wrapping MatDialogContainer.\n   * @param overlayRef Reference to the overlay in which the dialog resides.\n   * @param config The dialog configuration.\n   * @returns A promise resolving to the MatDialogRef that should be returned to the user.\n   */\n  protected _attachDialogContentForComponent<T>(\n      componentOrTemplateRef: ComponentType<T>,\n      dialogContainer: ModalContainerComponent,\n      overlayRef: OverlayRef,\n      config: ModalConfig,\n      componentFactoryResolver?: ComponentFactoryResolver | null | undefined): ModalRef<any> {\n\n    // Create a reference to the dialog we're creating in order to give the user a handle\n    // to modify and close it.\n    const dialogRef = new this.dialogRefConstructor(overlayRef, dialogContainer, config.id)\n    const injector = this._createInjector<T>(config, dialogRef, dialogContainer)\n    const contentRef = dialogContainer.attachComponentPortal(\n        new ComponentPortal(componentOrTemplateRef, undefined, injector, componentFactoryResolver))\n\n    dialogRef.componentInstance = contentRef.instance\n    dialogRef.disableClose = config.disableClose\n\n    dialogRef.updateSize({width: config.width, height: config.height})\n             .updatePosition(config.position)\n\n    return dialogRef\n  }\n\n  /**\n   * Attaches the user-provided component to the already-created MatDialogContainer.\n   * @param componentOrTemplateRef The type of component being loaded into the dialog,\n   *     or a TemplateRef to instantiate as the content.\n   * @param dialogContainer Reference to the wrapping MatDialogContainer.\n   * @param overlayRef Reference to the overlay in which the dialog resides.\n   * @param config The dialog configuration.\n   * @returns A promise resolving to the MatDialogRef that should be returned to the user.\n   */\n  protected _attachDialogContentForTemplate<T>(\n      componentOrTemplateRef: TemplateRef<T>,\n      dialogContainer: ModalContainerComponent,\n      overlayRef: OverlayRef,\n      config: ModalConfig): ModalRef<any> {\n\n    // Create a reference to the dialog we're creating in order to give the user a handle\n    // to modify and close it.\n    const dialogRef = new this.dialogRefConstructor(overlayRef, dialogContainer, config.id)\n\n    dialogContainer.attachTemplatePortal(\n      new TemplatePortal<T>(componentOrTemplateRef, <any>null,\n        <any>{$implicit: config.data, dialogRef}))\n    dialogRef.updateSize({width: config.width, height: config.height})\n             .updatePosition(config.position)\n\n    return dialogRef\n  }\n\n\n  /**\n   * Creates a custom injector to be used inside the dialog. This allows a component loaded inside\n   * of a dialog to close itself and, optionally, to return a value.\n   * @param config Config object that is used to construct the dialog.\n   * @param dialogRef Reference to the dialog.\n   * @param container Dialog container element that wraps all of the contents.\n   * @returns The custom injector that can be used inside the dialog.\n   */\n  private _createInjector<T>(\n      config: ModalConfig,\n      dialogRef: ModalRef<T>,\n      dialogContainer: ModalContainerComponent): PortalInjector {\n\n    const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector\n    const injectionTokens = new WeakMap<any, any>([\n      [this.injector.get(MODAL_REF), dialogRef],\n      [this.injector.get(MODAL_CONTAINER), dialogContainer],\n      [MODAL_DATA, config.data]\n    ])\n\n    if (config.direction &&\n        (!userInjector || !userInjector.get<Directionality | null>(Directionality, null))) {\n      injectionTokens.set(Directionality, {\n        value: config.direction,\n        change: observableOf()\n      })\n    }\n\n    return new PortalInjector(userInjector || this.injector, injectionTokens)\n  }\n\n  /**\n   * Expands the provided configuration object to include the default values for properties which\n   * are undefined.\n   */\n  private _applyConfigDefaults(config?: ModalConfig): ModalConfig {\n    const dialogConfig = (<unknown>this.injector.get(MODAL_CONFIG)) as typeof ModalConfig\n    return {...new dialogConfig(), ...config}\n  }\n}\n"]}