@villedemontreal/angular-ui 2.2.1 → 3.1.1

package/esm2020/lib/modal/modal-directives.mjs

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2022 Ville de Montreal. All rights reserved.
+ * Licensed under the MIT license.
+ * See LICENSE file in the project root for full license information.
+ */
+import { Directive, Input, Optional } from '@angular/core';
+import { _closeModalVia } from './modal-ref';
+import * as i0 from "@angular/core";
+import * as i1 from "./modal-ref";
+import * as i2 from "./modal";
+/**
+ * Button that will close the current dialog.
+ */
+export class BaoModalClose {
+    constructor(modalRef, _elementRef, _dialog) {
+        this.modalRef = modalRef;
+        this._elementRef = _elementRef;
+        this._dialog = _dialog;
+        /** Default to "button" to prevents accidental form submits. */
+        this.type = 'button';
+    }
+    ngOnInit() {
+        if (!this.modalRef) {
+            // When this directive is included in a dialog via TemplateRef (rather than being
+            // in a Component), the modalRef isn't available via injection because embedded
+            // views cannot be given a custom injector. Instead, we look up the modalRef by
+            // ID. This must occur in `onInit`, as the ID binding for the dialog container won't
+            // be resolved at constructor time.
+            this.modalRef =
+                getClosestDialog(this._elementRef, this._dialog.openModals) || null;
+        }
+    }
+    ngOnChanges(changes) {
+        const proxiedChange = changes['_baoModalClose'] || changes['_baoModalCloseResult'];
+        if (proxiedChange) {
+            this.dialogResult = proxiedChange.currentValue;
+        }
+    }
+    _onButtonClick(event) {
+        // Determinate the focus origin using the click event, because using the FocusMonitor will
+        // result in incorrect origins. Most of the time, close buttons will be auto focused in the
+        // dialog, and therefore clicking the button won't result in a focus change. This means that
+        // the FocusMonitor won't detect any origin change, and will always output `program`.
+        _closeModalVia(this.modalRef, event.screenX === 0 && event.screenY === 0 ? 'keyboard' : 'mouse', this.dialogResult);
+    }
+}
+BaoModalClose.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: BaoModalClose, deps: [{ token: i1.BaoModalRef, optional: true }, { token: i0.ElementRef }, { token: i2.BaoModal }], target: i0.ɵɵFactoryTarget.Directive });
+BaoModalClose.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.1", type: BaoModalClose, selector: "[bao-modal-close], [baoModalClose]", inputs: { ariaLabel: ["aria-label", "ariaLabel"], type: "type", dialogResult: ["bao-modal-close", "dialogResult"], _baoModalClose: ["baoModalClose", "_baoModalClose"] }, host: { listeners: { "click": "_onButtonClick($event)" }, properties: { "attr.aria-label": "ariaLabel || null", "attr.type": "type" } }, exportAs: ["BaoModalClose"], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.1", ngImport: i0, type: BaoModalClose, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[bao-modal-close], [baoModalClose]',
+                    exportAs: 'BaoModalClose',
+                    host: {
+                        '(click)': '_onButtonClick($event)',
+                        '[attr.aria-label]': 'ariaLabel || null',
+                        '[attr.type]': 'type'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i1.BaoModalRef, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ElementRef }, { type: i2.BaoModal }]; }, propDecorators: { ariaLabel: [{
+                type: Input,
+                args: ['aria-label']
+            }], type: [{
+                type: Input
+            }], dialogResult: [{
+                type: Input,
+                args: ['bao-modal-close']
+            }], _baoModalClose: [{
+                type: Input,
+                args: ['baoModalClose']
+            }] } });
+/**
+ * Finds the closest BaoModalRef to an element by looking at the DOM.
+ */
+function getClosestDialog(element, openDialogs) {
+    let parent = element.nativeElement.parentElement;
+    while (parent && !parent.classList.contains('bao-modal-container')) {
+        parent = parent.parentElement;
+    }
+    return parent ? openDialogs.find(dialog => dialog.id === parent.id) : null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modal/modal-ref.mjs

@@ -0,0 +1,195 @@
+import { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';
+import { filter, Subject, take } from 'rxjs';
+// Counter for unique modal ids.
+let uniqueId = 0;
+/**
+ * Reference to a modal opened via the BaoModalService.
+ */
+export class BaoModalRef {
+    constructor(_overlayRef, _containerInstance, 
+    /** Id of the modal. */
+    id = `bao-modal-${uniqueId++}`) {
+        this._overlayRef = _overlayRef;
+        this._containerInstance = _containerInstance;
+        this.id = id;
+        /** Whether the user is allowed to close the modal. */
+        this.disableClose = this._containerInstance._config.disableClose;
+        /** Subject for notifying the user that the modal has finished opening. */
+        this._afterOpened = new Subject();
+        /** Subject for notifying the user that the modal has finished closing. */
+        this._afterClosed = new Subject();
+        /** Subject for notifying the user that the modal has started closing. */
+        this._beforeClosed = new Subject();
+        /** Current state of the modal. */
+        this._state = 0 /* OPEN */;
+        // Pass the id along to the container.
+        _containerInstance._id = id;
+        // Emit when opening animation completes
+        _containerInstance._animationStateChanged
+            .pipe(filter(event => event.state === 'opened'), take(1))
+            .subscribe(() => {
+            this._afterOpened.next();
+            this._afterOpened.complete();
+        });
+        // Dispose overlay when closing animation is complete
+        _containerInstance._animationStateChanged
+            .pipe(filter(event => event.state === 'closed'), take(1))
+            .subscribe(() => {
+            clearTimeout(this._closeFallbackTimeout);
+            this._finishModalClose();
+        });
+        _overlayRef.detachments().subscribe(() => {
+            this._beforeClosed.next(this._result);
+            this._beforeClosed.complete();
+            this._afterClosed.next(this._result);
+            this._afterClosed.complete();
+            this.componentInstance = null;
+            this._overlayRef.dispose();
+        });
+        _overlayRef
+            .keydownEvents()
+            .pipe(filter(event => {
+            return (event.keyCode === ESCAPE &&
+                !this.disableClose &&
+                !hasModifierKey(event));
+        }))
+            .subscribe(event => {
+            event.preventDefault();
+            _closeModalVia(this, 'keyboard');
+        });
+        _overlayRef.backdropClick().subscribe(async () => {
+            if (this.disableClose) {
+                await this._containerInstance._recaptureFocus();
+            }
+            else {
+                _closeModalVia(this, 'mouse');
+            }
+        });
+    }
+    /**
+     * Close the modal.
+     * @param modalResult Optional result to return to the modal opener.
+     */
+    close(modalResult) {
+        this._result = modalResult;
+        // Transition the backdrop in parallel to the modal.
+        this._containerInstance._animationStateChanged
+            .pipe(filter(event => event.state === 'closing'), take(1))
+            .subscribe(event => {
+            this._beforeClosed.next(modalResult);
+            this._beforeClosed.complete();
+            this._overlayRef.detachBackdrop();
+            // The logic that disposes of the overlay depends on the exit animation completing, however
+            // it isn't guaranteed if the parent view is destroyed while it's running. Add a fallback
+            // timeout which will clean everything up if the animation hasn't fired within the specified
+            // amount of time plus 100ms. We don't need to run this outside the NgZone, because for the
+            // vast majority of cases the timeout will have been cleared before it has the chance to fire.
+            this._closeFallbackTimeout = setTimeout(() => this._finishModalClose(), event.totalTime + 100);
+        });
+        this._state = 1 /* CLOSING */;
+        this._containerInstance._startExitAnimation();
+    }
+    /**
+     * Gets an observable that is notified when the modal is finished opening.
+     */
+    afterOpened() {
+        return this._afterOpened;
+    }
+    /**
+     * Gets an observable that is notified when the modal is finished closing.
+     */
+    afterClosed() {
+        return this._afterClosed;
+    }
+    /**
+     * Gets an observable that is notified when the modal has started closing.
+     */
+    beforeClosed() {
+        return this._beforeClosed;
+    }
+    /**
+     * Gets an observable that emits when the overlay's backdrop has been clicked.
+     */
+    backdropClick() {
+        return this._overlayRef.backdropClick();
+    }
+    /**
+     * Gets an observable that emits when keydown events are targeted on the overlay.
+     */
+    keydownEvents() {
+        return this._overlayRef.keydownEvents();
+    }
+    /**
+     * Updates the dialog's position.
+     */
+    updatePosition(position) {
+        const strategy = this._getPositionStrategy();
+        if (position && (position.left || position.right)) {
+            position.left
+                ? strategy.left(position.left)
+                : strategy.right(position.right);
+        }
+        else {
+            strategy.centerHorizontally();
+        }
+        if (position && (position.top || position.bottom)) {
+            position.top
+                ? strategy.top(position.top)
+                : strategy.bottom(position.bottom);
+        }
+        else {
+            strategy.centerVertically();
+        }
+        this._overlayRef.updatePosition();
+        return this;
+    }
+    /**
+     * Updates the modal's width and height.
+     */
+    updateSize(width = '', height = '') {
+        this._overlayRef.updateSize({ width, height });
+        this._overlayRef.updatePosition();
+        return this;
+    }
+    /** Add a CSS class or an array of classes to the overlay pane. */
+    addPanelClass(classes) {
+        this._overlayRef.addPanelClass(classes);
+        return this;
+    }
+    /** Remove a CSS class or an array of classes from the overlay pane. */
+    removePanelClass(classes) {
+        this._overlayRef.removePanelClass(classes);
+        return this;
+    }
+    /** Gets the current state of the modal's lifecycle. */
+    getState() {
+        return this._state;
+    }
+    /**
+     * Finishes the modal close by updating the state of the modal
+     * and disposing the overlay.
+     */
+    _finishModalClose() {
+        this._state = 2 /* CLOSED */;
+        this._overlayRef.dispose();
+    }
+    /** Fetches the position strategy object from the overlay ref. */
+    _getPositionStrategy() {
+        return this._overlayRef.getConfig()
+            .positionStrategy;
+    }
+}
+/**
+ * Closes the modal with the specified interaction type. This is currently not part of
+ * `BaoModalRef` as that would conflict with custom modal ref mocks provided in tests.
+ * More details. See: https://github.com/angular/components/pull/9257#issuecomment-651342226.
+ */
+export function _closeModalVia(ref, interactionType, result) {
+    // Some mock modal ref instances in tests do not have the `_containerInstance` property.
+    // For those, we keep the behavior as is and do not deal with the interaction type.
+    if (ref._containerInstance !== undefined) {
+        ref._containerInstance._closeInteractionType = interactionType;
+    }
+    return ref.close(result);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal-ref.js","sourceRoot":"","sources":["../../../../../projects/angular-ui/src/lib/modal/modal-ref.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,EAAE,MAAM,EAAc,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAIzD,gCAAgC;AAChC,IAAI,QAAQ,GAAG,CAAC,CAAC;AASjB;;GAEG;AACH,MAAM,OAAO,WAAW;IA0BtB,YACU,WAAuB,EACxB,kBAA0C;IACjD,uBAAuB;IACd,KAAa,aAAa,QAAQ,EAAE,EAAE;QAHvC,gBAAW,GAAX,WAAW,CAAY;QACxB,uBAAkB,GAAlB,kBAAkB,CAAwB;QAExC,OAAE,GAAF,EAAE,CAAoC;QA1BjD,sDAAsD;QAC/C,iBAAY,GACjB,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,YAAY,CAAC;QAE/C,0EAA0E;QACzD,iBAAY,GAAG,IAAI,OAAO,EAAQ,CAAC;QAEpD,0EAA0E;QACzD,iBAAY,GAAG,IAAI,OAAO,EAAiB,CAAC;QAE7D,yEAAyE;QACxD,kBAAa,GAAG,IAAI,OAAO,EAAiB,CAAC;QAQ9D,kCAAkC;QAC1B,WAAM,gBAAsB;QAQlC,sCAAsC;QACtC,kBAAkB,CAAC,GAAG,GAAG,EAAE,CAAC;QAE5B,wCAAwC;QACxC,kBAAkB,CAAC,sBAAsB;aACtC,IAAI,CACH,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,KAAK,QAAQ,CAAC,EACzC,IAAI,CAAC,CAAC,CAAC,CACR;aACA,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;YACzB,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;QAC/B,CAAC,CAAC,CAAC;QAEL,qDAAqD;QACrD,kBAAkB,CAAC,sBAAsB;aACtC,IAAI,CACH,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,KAAK,QAAQ,CAAC,EACzC,IAAI,CAAC,CAAC,CAAC,CACR;aACA,SAAS,CAAC,GAAG,EAAE;YACd,YAAY,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;YACzC,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC3B,CAAC,CAAC,CAAC;QAEL,WAAW,CAAC,WAAW,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE;YACvC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACtC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;YAC9B,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACrC,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;YAC7B,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC;YAC9B,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;QAC7B,CAAC,CAAC,CAAC;QAEH,WAAW;aACR,aAAa,EAAE;aACf,IAAI,CACH,MAAM,CAAC,KAAK,CAAC,EAAE;YACb,OAAO,CACL,KAAK,CAAC,OAAO,KAAK,MAAM;gBACxB,CAAC,IAAI,CAAC,YAAY;gBAClB,CAAC,cAAc,CAAC,KAAK,CAAC,CACvB,CAAC;QACJ,CAAC,CAAC,CACH;aACA,SAAS,CAAC,KAAK,CAAC,EAAE;YACjB,KAAK,CAAC,cAAc,EAAE,CAAC;YACvB,cAAc,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QAEL,WAAW,CAAC,aAAa,EAAE,CAAC,SAAS,CAAC,KAAK,IAAI,EAAE;YAC/C,IAAI,IAAI,CAAC,YAAY,EAAE;gBACrB,MAAM,IAAI,CAAC,kBAAkB,CAAC,eAAe,EAAE,CAAC;aACjD;iBAAM;gBACL,cAAc,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;aAC/B;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,WAAe;QAC1B,IAAI,CAAC,OAAO,GAAG,WAAW,CAAC;QAE3B,oDAAoD;QACpD,IAAI,CAAC,kBAAkB,CAAC,sBAAsB;aAC3C,IAAI,CACH,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,KAAK,SAAS,CAAC,EAC1C,IAAI,CAAC,CAAC,CAAC,CACR;aACA,SAAS,CAAC,KAAK,CAAC,EAAE;YACjB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YACrC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;YAC9B,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC;YAClC,2FAA2F;YAC3F,yFAAyF;YACzF,4FAA4F;YAC5F,2FAA2F;YAC3F,8FAA8F;YAC9F,IAAI,CAAC,qBAAqB,GAAG,UAAU,CACrC,GAAG,EAAE,CAAC,IAAI,CAAC,iBAAiB,EAAE,EAC7B,KAAK,CAAC,SAAoB,GAAG,GAAG,CAClC,CAAC;QACJ,CAAC,CAAC,CAAC;QAEL,IAAI,CAAC,MAAM,kBAAwB,CAAC;QACpC,IAAI,CAAC,kBAAkB,CAAC,mBAAmB,EAAE,CAAC;IAChD,CAAC;IAED;;OAEG;IACI,WAAW;QAChB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED;;OAEG;IACI,WAAW;QAChB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED;;OAEG;IACI,YAAY;QACjB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED;;OAEG;IACI,aAAa;QAClB,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,CAAC;IAC1C,CAAC;IAED;;OAEG;IACI,aAAa;QAClB,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,CAAC;IAC1C,CAAC;IAED;;OAEG;IACI,cAAc,CAAC,QAAwB;QAC5C,MAAM,QAAQ,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAE7C,IAAI,QAAQ,IAAI,CAAC,QAAQ,CAAC,IAAI,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE;YACjD,QAAQ,CAAC,IAAI;gBACX,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;gBAC9B,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;SACpC;aAAM;YACL,QAAQ,CAAC,kBAAkB,EAAE,CAAC;SAC/B;QAED,IAAI,QAAQ,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,QAAQ,CAAC,MAAM,CAAC,EAAE;YACjD,QAAQ,CAAC,GAAG;gBACV,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC;gBAC5B,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;SACtC;aAAM;YACL,QAAQ,CAAC,gBAAgB,EAAE,CAAC;SAC7B;QAED,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC;QAElC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,UAAU,CAAC,KAAK,GAAG,EAAE,EAAE,MAAM,GAAG,EAAE;QACvC,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,CAAC;QAC/C,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC;QAClC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kEAAkE;IAC3D,aAAa,CAAC,OAA0B;QAC7C,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QACxC,OAAO,IAAI,CAAC;IACd,CAAC;IAED,uEAAuE;IAChE,gBAAgB,CAAC,OAA0B;QAChD,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC;QAC3C,OAAO,IAAI,CAAC;IACd,CAAC;IAED,uDAAuD;IAChD,QAAQ;QACb,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;OAGG;IACK,iBAAiB;QACvB,IAAI,CAAC,MAAM,iBAAuB,CAAC;QACnC,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;IAED,iEAAiE;IACzD,oBAAoB;QAC1B,OAAO,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE;aAChC,gBAA0C,CAAC;IAChD,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAC5B,GAAmB,EACnB,eAA4B,EAC5B,MAAU;IAEV,wFAAwF;IACxF,mFAAmF;IACnF,IAAI,GAAG,CAAC,kBAAkB,KAAK,SAAS,EAAE;QACxC,GAAG,CAAC,kBAAkB,CAAC,qBAAqB,GAAG,eAAe,CAAC;KAChE;IACD,OAAO,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;AAC3B,CAAC","sourcesContent":["/*\n * Copyright (c) 2022 Ville de Montreal. All rights reserved.\n * Licensed under the MIT license.\n * See LICENSE file in the project root for full license information.\n */\nimport { FocusOrigin } from '@angular/cdk/a11y';\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';\nimport { GlobalPositionStrategy, OverlayRef } from '@angular/cdk/overlay';\nimport { filter, Observable, Subject, take } from 'rxjs';\nimport { ModalPosition } from './modal-config';\nimport { _BaoModalContainerBase } from './modal-container';\n\n// Counter for unique modal ids.\nlet uniqueId = 0;\n\n/** Possible states of the lifecycle of a modal. */\nexport const enum BaoModalState {\n  OPEN,\n  CLOSING,\n  CLOSED\n}\n\n/**\n * Reference to a modal opened via the BaoModalService.\n */\nexport class BaoModalRef<T, R = unknown> {\n  /** The instance of component opened into the modal. */\n  public componentInstance: T;\n\n  /** Whether the user is allowed to close the modal. */\n  public disableClose: boolean | undefined =\n    this._containerInstance._config.disableClose;\n\n  /** Subject for notifying the user that the modal has finished opening. */\n  private readonly _afterOpened = new Subject<void>();\n\n  /** Subject for notifying the user that the modal has finished closing. */\n  private readonly _afterClosed = new Subject<R | undefined>();\n\n  /** Subject for notifying the user that the modal has started closing. */\n  private readonly _beforeClosed = new Subject<R | undefined>();\n\n  /** Result to be passed to afterClosed. */\n  private _result: R | undefined;\n\n  /** Handle to the timeout that's running as a fallback in case the exit animation doesn't fire. */\n  private _closeFallbackTimeout: any;\n\n  /** Current state of the modal. */\n  private _state = BaoModalState.OPEN;\n\n  constructor(\n    private _overlayRef: OverlayRef,\n    public _containerInstance: _BaoModalContainerBase,\n    /** Id of the modal. */\n    readonly id: string = `bao-modal-${uniqueId++}`\n  ) {\n    // Pass the id along to the container.\n    _containerInstance._id = id;\n\n    // Emit when opening animation completes\n    _containerInstance._animationStateChanged\n      .pipe(\n        filter(event => event.state === 'opened'),\n        take(1)\n      )\n      .subscribe(() => {\n        this._afterOpened.next();\n        this._afterOpened.complete();\n      });\n\n    // Dispose overlay when closing animation is complete\n    _containerInstance._animationStateChanged\n      .pipe(\n        filter(event => event.state === 'closed'),\n        take(1)\n      )\n      .subscribe(() => {\n        clearTimeout(this._closeFallbackTimeout);\n        this._finishModalClose();\n      });\n\n    _overlayRef.detachments().subscribe(() => {\n      this._beforeClosed.next(this._result);\n      this._beforeClosed.complete();\n      this._afterClosed.next(this._result);\n      this._afterClosed.complete();\n      this.componentInstance = null;\n      this._overlayRef.dispose();\n    });\n\n    _overlayRef\n      .keydownEvents()\n      .pipe(\n        filter(event => {\n          return (\n            event.keyCode === ESCAPE &&\n            !this.disableClose &&\n            !hasModifierKey(event)\n          );\n        })\n      )\n      .subscribe(event => {\n        event.preventDefault();\n        _closeModalVia(this, 'keyboard');\n      });\n\n    _overlayRef.backdropClick().subscribe(async () => {\n      if (this.disableClose) {\n        await this._containerInstance._recaptureFocus();\n      } else {\n        _closeModalVia(this, 'mouse');\n      }\n    });\n  }\n\n  /**\n   * Close the modal.\n   * @param modalResult Optional result to return to the modal opener.\n   */\n  public close(modalResult?: R): void {\n    this._result = modalResult;\n\n    // Transition the backdrop in parallel to the modal.\n    this._containerInstance._animationStateChanged\n      .pipe(\n        filter(event => event.state === 'closing'),\n        take(1)\n      )\n      .subscribe(event => {\n        this._beforeClosed.next(modalResult);\n        this._beforeClosed.complete();\n        this._overlayRef.detachBackdrop();\n        // The logic that disposes of the overlay depends on the exit animation completing, however\n        // it isn't guaranteed if the parent view is destroyed while it's running. Add a fallback\n        // timeout which will clean everything up if the animation hasn't fired within the specified\n        // amount of time plus 100ms. We don't need to run this outside the NgZone, because for the\n        // vast majority of cases the timeout will have been cleared before it has the chance to fire.\n        this._closeFallbackTimeout = setTimeout(\n          () => this._finishModalClose(),\n          (event.totalTime as number) + 100\n        );\n      });\n\n    this._state = BaoModalState.CLOSING;\n    this._containerInstance._startExitAnimation();\n  }\n\n  /**\n   * Gets an observable that is notified when the modal is finished opening.\n   */\n  public afterOpened(): Observable<void> {\n    return this._afterOpened;\n  }\n\n  /**\n   * Gets an observable that is notified when the modal is finished closing.\n   */\n  public afterClosed(): Observable<R | undefined> {\n    return this._afterClosed;\n  }\n\n  /**\n   * Gets an observable that is notified when the modal has started closing.\n   */\n  public beforeClosed(): Observable<R | undefined> {\n    return this._beforeClosed;\n  }\n\n  /**\n   * Gets an observable that emits when the overlay's backdrop has been clicked.\n   */\n  public backdropClick(): Observable<MouseEvent> {\n    return this._overlayRef.backdropClick();\n  }\n\n  /**\n   * Gets an observable that emits when keydown events are targeted on the overlay.\n   */\n  public keydownEvents(): Observable<KeyboardEvent> {\n    return this._overlayRef.keydownEvents();\n  }\n\n  /**\n   * Updates the dialog's position.\n   */\n  public updatePosition(position?: ModalPosition): this {\n    const strategy = this._getPositionStrategy();\n\n    if (position && (position.left || position.right)) {\n      position.left\n        ? strategy.left(position.left)\n        : strategy.right(position.right);\n    } else {\n      strategy.centerHorizontally();\n    }\n\n    if (position && (position.top || position.bottom)) {\n      position.top\n        ? strategy.top(position.top)\n        : strategy.bottom(position.bottom);\n    } else {\n      strategy.centerVertically();\n    }\n\n    this._overlayRef.updatePosition();\n\n    return this;\n  }\n\n  /**\n   * Updates the modal's width and height.\n   */\n  public updateSize(width = '', height = ''): this {\n    this._overlayRef.updateSize({ width, height });\n    this._overlayRef.updatePosition();\n    return this;\n  }\n\n  /** Add a CSS class or an array of classes to the overlay pane. */\n  public addPanelClass(classes: string | string[]): this {\n    this._overlayRef.addPanelClass(classes);\n    return this;\n  }\n\n  /** Remove a CSS class or an array of classes from the overlay pane. */\n  public removePanelClass(classes: string | string[]): this {\n    this._overlayRef.removePanelClass(classes);\n    return this;\n  }\n\n  /** Gets the current state of the modal's lifecycle. */\n  public getState(): BaoModalState {\n    return this._state;\n  }\n\n  /**\n   * Finishes the modal close by updating the state of the modal\n   * and disposing the overlay.\n   */\n  private _finishModalClose() {\n    this._state = BaoModalState.CLOSED;\n    this._overlayRef.dispose();\n  }\n\n  /** Fetches the position strategy object from the overlay ref. */\n  private _getPositionStrategy(): GlobalPositionStrategy {\n    return this._overlayRef.getConfig()\n      .positionStrategy as GlobalPositionStrategy;\n  }\n}\n\n/**\n * Closes the modal with the specified interaction type. This is currently not part of\n * `BaoModalRef` as that would conflict with custom modal ref mocks provided in tests.\n * More details. See: https://github.com/angular/components/pull/9257#issuecomment-651342226.\n */\nexport function _closeModalVia<R>(\n  ref: BaoModalRef<R>,\n  interactionType: FocusOrigin,\n  result?: R\n) {\n  // Some mock modal ref instances in tests do not have the `_containerInstance` property.\n  // For those, we keep the behavior as is and do not deal with the interaction type.\n  if (ref._containerInstance !== undefined) {\n    ref._containerInstance._closeInteractionType = interactionType;\n  }\n  return ref.close(result);\n}\n"]}