@theseam/ui-common 0.3.15-beta.0 → 0.3.15-beta.1

package/esm2020/modal/modal.service.mjs

@@ -0,0 +1,352 @@
+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 {
+    /** 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;
+    }
+    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;
+    }
+    /** 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) {
+        const _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) {
+        const _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) {
+        const _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 /* ComponentFactoryBoundToModule */.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,
+            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.
+        // eslint-disable-next-line new-cap
+        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.
+        // eslint-disable-next-line new-cap
+        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);
+        // eslint-disable-next-line new-cap
+        return { ...new dialogConfig(), ...config };
+    }
+}
+Modal.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", 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.9", ngImport: i0, type: Modal });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", 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 * 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    // 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    const _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    const _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    const _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<unknown>(componentId)\n      .pipe(\n        switchMap(componentFactory => {\n          const modalRef = this.openFromComponent(\n            componentFactory.componentType,\n            _config,\n            (componentFactory as any /* ComponentFactoryBoundToModule */).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,\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 = overlay.attach(containerPortal) as ComponentRef<ModalContainerComponent>\n    containerRef.instance._config = config\n\n    return containerRef.instance\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    // Create a reference to the dialog we're creating in order to give the user a handle\n    // to modify and close it.\n    // eslint-disable-next-line new-cap\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    // Create a reference to the dialog we're creating in order to give the user a handle\n    // to modify and close it.\n    // eslint-disable-next-line new-cap\n    const dialogRef = new this.dialogRefConstructor(overlayRef, dialogContainer, config.id)\n\n    dialogContainer.attachTemplatePortal(\n      new TemplatePortal<T>(componentOrTemplateRef, null as any,\n        { $implicit: config.data, dialogRef } as any))\n    dialogRef.updateSize({ width: config.width, height: config.height })\n             .updatePosition(config.position)\n\n    return dialogRef\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    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 = (this.injector.get(MODAL_CONFIG) as unknown) as typeof ModalConfig\n    // eslint-disable-next-line new-cap\n    return { ...new dialogConfig(), ...config }\n  }\n}\n"]}

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

@@ -0,0 +1,62 @@
+import { Component } from '@angular/core';
+// import { ModalComponent } from '../modal/modal.component'
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../modal.service";
+export class RouteModalComponent {
+    // @ViewChild(ModalComponent, { static: true }) _modal: ModalComponent
+    constructor(_route, _router, _modal) {
+        this._route = _route;
+        this._router = _router;
+        this._modal = _modal;
+        this._ngUnsubscribe = new Subject();
+    }
+    ngOnInit() {
+        this._route.data
+            .pipe(takeUntil(this._ngUnsubscribe))
+            .subscribe(data => {
+            // console.log('data', data)
+            if (data.routeComponent) {
+                // console.log(this._route.snapshot)
+                const modalRef = this._modal.openFromComponent(data.routeComponent, {
+                    modalSize: 'lg',
+                    data
+                });
+                modalRef.afterClosed().subscribe(() => {
+                    const parent = this.getOutletParent();
+                    this._router.navigate([{ outlets: { modal: null, primary: ['.'] } }], 
+                    // { relativeTo: this._route.parent }
+                    { relativeTo: parent });
+                });
+            }
+        });
+    }
+    ngOnDestroy() {
+        this._ngUnsubscribe.next(undefined);
+        this._ngUnsubscribe.complete();
+    }
+    getOutletParent() {
+        let route = this._route;
+        while (route && route.outlet !== 'modal') {
+            route = route.parent;
+        }
+        return route ? route.parent : route;
+    }
+    _onDetached() {
+        if (this.isRouteModal()) {
+            this._router.navigate([{ outlets: { modal: null, primary: ['.'] } }], { relativeTo: this._route.parent });
+        }
+    }
+    isRouteModal() {
+        return this._route.outlet === 'modal';
+    }
+}
+RouteModalComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RouteModalComponent, deps: [{ token: i1.ActivatedRoute }, { token: i1.Router }, { token: i2.Modal }], target: i0.ɵɵFactoryTarget.Component });
+RouteModalComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: RouteModalComponent, selector: "seam-route-modal", ngImport: i0, template: "<!-- <seam-modal (overlayDetached)=\"_onDetached()\">\n  <router-outlet></router-outlet>\n</seam-modal> -->\n", styles: [""] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RouteModalComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-route-modal', template: "<!-- <seam-modal (overlayDetached)=\"_onDetached()\">\n  <router-outlet></router-outlet>\n</seam-modal> -->\n" }]
+        }], ctorParameters: function () { return [{ type: i1.ActivatedRoute }, { type: i1.Router }, { type: i2.Modal }]; } });
+//# sourceMappingURL=data:application/json;base64,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