ng-hub-ui-portal 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Carlos Morcillo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# Portal
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 17.3.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project portal` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project portal`.
+> Note: Don't forget to add `--project portal` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build portal` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build portal`, go to the dist folder `cd dist/portal` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test portal` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/esm2022/lib/portal-config.mjs

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A configuration service for the [`HubPortal`](#/components/portal/api#HubPortal) service.
+ *
+ * You can inject this service, typically in your root component, and customize the values of its properties in
+ * order to provide default values for all portals used in the application.
+ *
+ * @since 3.1.0
+ */
+export class HubPortalConfig {
+    constructor() {
+        this.backdrop = false;
+        this.fullscreen = false;
+        this.keyboard = true;
+        this.dismissSelector = '[data-dismiss="portal"]';
+        this.closeSelector = '[data-close="portal"]';
+    }
+    get animation() {
+        return this._animation ?? true /* this._hubConfig.animation */;
+    }
+    set animation(animation) {
+        this._animation = animation;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: HubPortalConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: HubPortalConfig, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: HubPortalConfig, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"portal-config.js","sourceRoot":"","sources":["../../../../projects/portal/src/lib/portal-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAY,MAAM,eAAe,CAAC;;AAoKrD;;;;;;;GAOG;AAEH,MAAM,OAAO,eAAe;IAD5B;QAOC,aAAQ,GAAuB,KAAK,CAAC;QAIrC,eAAU,GAAyD,KAAK,CAAC;QAEzE,aAAQ,GAAG,IAAI,CAAC;QAQhB,oBAAe,GAAW,yBAAyB,CAAC;QACpD,kBAAa,GAAW,uBAAuB,CAAC;KAShD;IANA,IAAI,SAAS;QACZ,OAAO,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,+BAA+B,CAAC;IAChE,CAAC;IACD,IAAI,SAAS,CAAC,SAAkB;QAC/B,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;IAC7B,CAAC;8GA7BW,eAAe;kHAAf,eAAe,cADF,MAAM;;2FACnB,eAAe;kBAD3B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["import { Injectable, Injector } from '@angular/core';\n// import { HubConfig } from '../hub-config';\n\n/**\n * Options available when opening new portal windows with `HubPortal.open()` method.\n */\nexport interface HubPortalOptions {\n\t/**\n\t * If `true`, portal opening and closing will be animated.\n\t *\n\t * @since 8.0.0\n\t */\n\tanimation?: boolean;\n\n\t/**\n\t * `aria-labelledby` attribute value to set on the portal window.\n\t *\n\t * @since 2.2.0\n\t */\n\tariaLabelledBy?: string;\n\n\t/**\n\t * `aria-describedby` attribute value to set on the portal window.\n\t *\n\t * @since 6.1.0\n\t */\n\tariaDescribedBy?: string;\n\n\t/**\n\t * Callback right before the portal will be dismissed.\n\t *\n\t * If this function returns:\n\t * * `false`\n\t * * a promise resolved with `false`\n\t * * a promise that is rejected\n\t *\n\t * then the portal won't be dismissed.\n\t */\n\tbeforeDismiss?: () => boolean | Promise<boolean>;\n\n\t/**\n\t * If `true`, the portal will be centered vertically.\n\t *\n\t * Default value is `false`.\n\t *\n\t * @since 1.1.0\n\t */\n\tcentered?: boolean;\n\n\t/**\n\t * A selector specifying the element all new portal windows should be appended to.\n\t * Since v5.3.0 it is also possible to pass the reference to an `HTMLElement`.\n\t *\n\t * If not specified, will be `body`.\n\t */\n\tcontainer?: string | HTMLElement;\n\n\t/**\n\t * If `true` portal will always be displayed in fullscreen mode.\n\t *\n\t * For values like `'md'` it means that portal will be displayed in fullscreen mode\n\t * only if the viewport width is below `'md'`. For custom strings (ex. when passing `'mysize'`)\n\t * it will add a `'portal-fullscreen-mysize-down'` class.\n\t *\n\t * If not specified will be `false`.\n\t *\n\t * @since 12.1.0\n\t */\n\tfullscreen?: 'sm' | 'md' | 'lg' | 'xl' | 'xxl' | boolean | string;\n\n\t/**\n\t * The `Injector` to use for portal content.\n\t */\n\tinjector?: Injector;\n\n\t/**\n\t * If `true`, the portal will be closed when `Escape` key is pressed\n\t *\n\t * Default value is `true`.\n\t */\n\tkeyboard?: boolean;\n\n\t/**\n\t * Scrollable portal content (false by default).\n\t *\n\t * @since 5.0.0\n\t */\n\tscrollable?: boolean;\n\n\t/**\n\t * Size of a new portal window.\n\t */\n\tsize?: 'sm' | 'lg' | 'xl' | string;\n\n\t/**\n\t * A custom class to append to the portal window.\n\t */\n\twindowClass?: string;\n\n\t/**\n\t * A custom class to append to the portal dialog.\n\t *\n\t * @since 9.1.0\n\t */\n\tportalDialogClass?: string;\n\n\t/**\n\t * A custom class to append to the portal backdrop.\n\t *\n\t * @since 1.1.0\n\t */\n\tbackdropClass?: string;\n\n\t/**\n\t * Allows to specify a custom selector for the header element of the portal window. This can be useful if you want to target\n\t * a specific element within the portal to act as the header, for example, to apply custom styling or functionality to it. By\n\t * providing a CSS selector string, you can target the desired\theader element within the portal content.\n\t */\n\theaderSelector?: string;\n\n\t/**\n\t * Allows to specify a custom selector for the footer element of the portal window. This can be useful if you want to target\n\t * a specific element within the portal to act as the footer, for example, to apply custom styling or functionality to it. By\n\t * providing a CSS selector string, you can target the desired footer element within the portal content.\n\t */\n\tfooterSelector?: string;\n\n\t/** Used to specify a custom selector for elements that can trigger the dismissal of the portal window. By providing a CSS selector\n\t * string for `dismissSelector`, you can target specific elements within the portal content that, when interacted with (e.g., clicked),\n\t * will close or dismiss the portal window.\n\t */\n\tdismissSelector?: string;\n\n\t/**\n\t * Used to specify a custom selector for elements that can trigger the closing of the portal window. By providing a CSS selector\n\t * string for `closeSelector`, you can target specific elements within the portal content that, when interacted with (e.g., clicked),\n\t * will close the portal window. This allows for customization of the elements that can act as close buttons for the portal.\n\t */\n\tcloseSelector?: string;\n\n\t/** Used to store any additional data that needs to be passed to the portal window when it is opened. This property allows you\n\t * to provide custom data to the portal component, which can then be accessed and utilized within the portal content or logic.\n\t * It provides flexibility for passing dynamic information to the portal window based on the specific use case or requirements.\n\t */\n\tdata?: any;\n}\n\n/**\n * Options that can be changed on an opened portal with `HubPortalRef.update()` and `HubActivePortal.update()` methods.\n *\n * @since 14.2.0\n */\nexport type HubPortalUpdatableOptions = Pick<\n\tHubPortalOptions,\n\t| 'ariaLabelledBy'\n\t| 'ariaDescribedBy'\n\t| 'centered'\n\t| 'fullscreen'\n\t| 'backdropClass'\n\t| 'size'\n\t| 'windowClass'\n\t| 'portalDialogClass'\n>;\n\n/**\n * A configuration service for the [`HubPortal`](#/components/portal/api#HubPortal) service.\n *\n * You can inject this service, typically in your root component, and customize the values of its properties in\n * order to provide default values for all portals used in the application.\n *\n * @since 3.1.0\n */\n@Injectable({ providedIn: 'root' })\nexport class HubPortalConfig implements Required<HubPortalOptions> {\n\t// private _hubConfig = inject(HubConfig);\n\tprivate _animation: boolean;\n\n\tariaLabelledBy: string;\n\tariaDescribedBy: string;\n\tbackdrop: boolean | 'static' = false;\n\tbeforeDismiss: () => boolean | Promise<boolean>;\n\tcentered: boolean;\n\tcontainer: string | HTMLElement;\n\tfullscreen: 'sm' | 'md' | 'lg' | 'xl' | 'xxl' | boolean | string = false;\n\tinjector: Injector;\n\tkeyboard = true;\n\tscrollable: boolean;\n\tsize: 'sm' | 'lg' | 'xl' | string;\n\twindowClass: string;\n\tportalDialogClass: string;\n\tbackdropClass: string;\n\theaderSelector: string;\n\tfooterSelector: string;\n\tdismissSelector: string = '[data-dismiss=\"portal\"]';\n\tcloseSelector: string = '[data-close=\"portal\"]';\n\tdata: any;\n\n\tget animation(): boolean {\n\t\treturn this._animation ?? true /* this._hubConfig.animation */;\n\t}\n\tset animation(animation: boolean) {\n\t\tthis._animation = animation;\n\t}\n}\n"]}

package/esm2022/lib/portal-dismiss-reasons.mjs

@@ -0,0 +1,6 @@
+export var PortalDismissReasons;
+(function (PortalDismissReasons) {
+    PortalDismissReasons[PortalDismissReasons["BACKDROP_CLICK"] = 0] = "BACKDROP_CLICK";
+    PortalDismissReasons[PortalDismissReasons["ESC"] = 1] = "ESC";
+})(PortalDismissReasons || (PortalDismissReasons = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9ydGFsLWRpc21pc3MtcmVhc29ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3BvcnRhbC9zcmMvbGliL3BvcnRhbC1kaXNtaXNzLXJlYXNvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksb0JBR1g7QUFIRCxXQUFZLG9CQUFvQjtJQUMvQixtRkFBYyxDQUFBO0lBQ2QsNkRBQUcsQ0FBQTtBQUNKLENBQUMsRUFIVyxvQkFBb0IsS0FBcEIsb0JBQW9CLFFBRy9CIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gUG9ydGFsRGlzbWlzc1JlYXNvbnMge1xuXHRCQUNLRFJPUF9DTElDSyxcblx0RVNDXG59XG4iXX0=

package/esm2022/lib/portal-ref.mjs

@@ -0,0 +1,193 @@
+import { isDefined, isPromise } from 'ng-hub-ui-utils';
+import { Subject, zip } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+/**
+ * A reference to the currently opened (active) portal.
+ *
+ * Instances of this class can be injected into your component passed as portal content.
+ * So you can `.update()`, `.close()` or `.dismiss()` the portal window from your component.
+ */
+export class HubActivePortal {
+    /**
+     * Updates options of an opened portal.
+     *
+     * @since 14.2.0
+     */
+    update(options) { }
+    /**
+     * Closes the portal with an optional `result` value.
+     *
+     * The `HubPortalRef.result` promise will be resolved with the provided value.
+     */
+    close(result) { }
+    /**
+     * Dismisses the portal with an optional `reason` value.
+     *
+     * The `HubPortalRef.result` promise will be rejected with the provided value.
+     */
+    dismiss(reason) { }
+}
+const WINDOW_ATTRIBUTES = [
+    'animation',
+    'ariaLabelledBy',
+    'ariaDescribedBy',
+    'backdrop',
+    'centered',
+    'fullscreen',
+    'keyboard',
+    'scrollable',
+    'size',
+    'windowClass',
+    'portalDialogClass'
+];
+const BACKDROP_ATTRIBUTES = ['animation', 'backdropClass'];
+/**
+ * A reference to the newly opened portal returned by the `HubPortal.open()` method.
+ */
+export class HubPortalRef {
+    _applyWindowOptions(windowInstance, options) {
+        WINDOW_ATTRIBUTES.forEach((optionName) => {
+            if (isDefined(options[optionName])) {
+                windowInstance[optionName] = options[optionName];
+            }
+        });
+    }
+    /**
+     * Updates options of an opened portal.
+     *
+     * @since 14.2.0
+     */
+    update(options) {
+        this._applyWindowOptions(this._windowCmptRef.instance, options);
+    }
+    /**
+     * The instance of a component used for the portal content.
+     *
+     * When a `TemplateRef` is used as the content or when the portal is closed, will return `undefined`.
+     */
+    get componentInstance() {
+        if (this._contentRef && this._contentRef.componentRef) {
+            return this._contentRef.componentRef.instance;
+        }
+    }
+    /**
+     * The observable that emits when the portal is closed via the `.close()` method.
+     *
+     * It will emit the result passed to the `.close()` method.
+     *
+     * @since 8.0.0
+     */
+    get closed() {
+        return this._closed.asObservable().pipe(takeUntil(this._hidden));
+    }
+    /**
+     * The observable that emits when the portal is dismissed via the `.dismiss()` method.
+     *
+     * It will emit the reason passed to the `.dismissed()` method by the user, or one of the internal
+     * reasons like backdrop click or ESC key press.
+     *
+     * @since 8.0.0
+     */
+    get dismissed() {
+        return this._dismissed.asObservable().pipe(takeUntil(this._hidden));
+    }
+    /**
+     * The observable that emits when both portal window and backdrop are closed and animations were finished.
+     * At this point portal and backdrop elements will be removed from the DOM tree.
+     *
+     * This observable will be completed after emitting.
+     *
+     * @since 8.0.0
+     */
+    get hidden() {
+        return this._hidden.asObservable();
+    }
+    /**
+     * The observable that emits when portal is fully visible and animation was finished.
+     * Portal DOM element is always available synchronously after calling 'portal.open()' service.
+     *
+     * This observable will be completed after emitting.
+     * It will not emit, if portal is closed before open animation is finished.
+     *
+     * @since 8.0.0
+     */
+    get shown() {
+        return this._windowCmptRef.instance.shown.asObservable();
+    }
+    constructor(_windowCmptRef, _contentRef, _beforeDismiss) {
+        this._windowCmptRef = _windowCmptRef;
+        this._contentRef = _contentRef;
+        this._beforeDismiss = _beforeDismiss;
+        this._closed = new Subject();
+        this._dismissed = new Subject();
+        this._hidden = new Subject();
+        _windowCmptRef.instance.dismissEvent.subscribe((reason) => {
+            this.dismiss(reason);
+        });
+        this.result = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+        });
+        this.result.then(null, () => { });
+    }
+    /**
+     * Closes the portal with an optional `result` value.
+     *
+     * The `HubMobalRef.result` promise will be resolved with the provided value.
+     */
+    close(result) {
+        if (this._windowCmptRef) {
+            this._closed.next(result);
+            this._resolve(result);
+            this._removePortalElements();
+        }
+    }
+    _dismiss(reason) {
+        this._dismissed.next(reason);
+        this._reject(reason);
+        this._removePortalElements();
+    }
+    /**
+     * Dismisses the portal with an optional `reason` value.
+     *
+     * The `HubPortalRef.result` promise will be rejected with the provided value.
+     */
+    dismiss(reason) {
+        if (this._windowCmptRef) {
+            if (!this._beforeDismiss) {
+                this._dismiss(reason);
+            }
+            else {
+                const dismiss = this._beforeDismiss();
+                if (isPromise(dismiss)) {
+                    dismiss.then((result) => {
+                        if (result !== false) {
+                            this._dismiss(reason);
+                        }
+                    }, () => { });
+                }
+                else if (dismiss !== false) {
+                    this._dismiss(reason);
+                }
+            }
+        }
+    }
+    _removePortalElements() {
+        const windowTransition$ = this._windowCmptRef.instance.hide();
+        // hiding window
+        windowTransition$.subscribe(() => {
+            const { nativeElement } = this._windowCmptRef.location;
+            nativeElement.parentNode.removeChild(nativeElement);
+            this._windowCmptRef.destroy();
+            this._contentRef?.viewRef?.destroy();
+            this._windowCmptRef = null;
+            this._contentRef = null;
+        });
+        // all done
+        zip(windowTransition$).subscribe(() => {
+            this._hidden.next();
+            this._hidden.complete();
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"portal-ref.js","sourceRoot":"","sources":["../../../../projects/portal/src/lib/portal-ref.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef } from '@angular/core';\nimport { ContentRef, isDefined, isPromise } from 'ng-hub-ui-utils';\nimport { Observable, Subject, zip } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { HubPortalOptions, HubPortalUpdatableOptions } from './portal-config';\nimport { HubPortalWindow } from './portal-window';\n\n/**\n * A reference to the currently opened (active) portal.\n *\n * Instances of this class can be injected into your component passed as portal content.\n * So you can `.update()`, `.close()` or `.dismiss()` the portal window from your component.\n */\nexport class HubActivePortal {\n\t/**\n\t * Updates options of an opened portal.\n\t *\n\t * @since 14.2.0\n\t */\n\tupdate(options: HubPortalUpdatableOptions): void {}\n\t/**\n\t * Closes the portal with an optional `result` value.\n\t *\n\t * The `HubPortalRef.result` promise will be resolved with the provided value.\n\t */\n\tclose(result?: any): void {}\n\n\t/**\n\t * Dismisses the portal with an optional `reason` value.\n\t *\n\t * The `HubPortalRef.result` promise will be rejected with the provided value.\n\t */\n\tdismiss(reason?: any): void {}\n}\n\nconst WINDOW_ATTRIBUTES: string[] = [\n\t'animation',\n\t'ariaLabelledBy',\n\t'ariaDescribedBy',\n\t'backdrop',\n\t'centered',\n\t'fullscreen',\n\t'keyboard',\n\t'scrollable',\n\t'size',\n\t'windowClass',\n\t'portalDialogClass'\n];\nconst BACKDROP_ATTRIBUTES: string[] = ['animation', 'backdropClass'];\n\n/**\n * A reference to the newly opened portal returned by the `HubPortal.open()` method.\n */\nexport class HubPortalRef {\n\tprivate _closed = new Subject<any>();\n\tprivate _dismissed = new Subject<any>();\n\tprivate _hidden = new Subject<void>();\n\tprivate _resolve!: (result?: any) => void;\n\tprivate _reject!: (reason?: any) => void;\n\n\tprivate _applyWindowOptions(\n\t\twindowInstance: HubPortalWindow,\n\t\toptions: HubPortalOptions\n\t): void {\n\t\tWINDOW_ATTRIBUTES.forEach((optionName: string) => {\n\t\t\tif (isDefined(options[optionName])) {\n\t\t\t\twindowInstance[optionName] = options[optionName];\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * Updates options of an opened portal.\n\t *\n\t * @since 14.2.0\n\t */\n\tupdate(options: HubPortalUpdatableOptions): void {\n\t\tthis._applyWindowOptions(this._windowCmptRef.instance, options);\n\t}\n\n\t/**\n\t * The instance of a component used for the portal content.\n\t *\n\t * When a `TemplateRef` is used as the content or when the portal is closed, will return `undefined`.\n\t */\n\tget componentInstance(): any {\n\t\tif (this._contentRef && this._contentRef.componentRef) {\n\t\t\treturn this._contentRef.componentRef.instance;\n\t\t}\n\t}\n\n\t/**\n\t * The promise that is resolved when the portal is closed and rejected when the portal is dismissed.\n\t */\n\tresult: Promise<any>;\n\n\t/**\n\t * The observable that emits when the portal is closed via the `.close()` method.\n\t *\n\t * It will emit the result passed to the `.close()` method.\n\t *\n\t * @since 8.0.0\n\t */\n\tget closed(): Observable<any> {\n\t\treturn this._closed.asObservable().pipe(takeUntil(this._hidden));\n\t}\n\n\t/**\n\t * The observable that emits when the portal is dismissed via the `.dismiss()` method.\n\t *\n\t * It will emit the reason passed to the `.dismissed()` method by the user, or one of the internal\n\t * reasons like backdrop click or ESC key press.\n\t *\n\t * @since 8.0.0\n\t */\n\tget dismissed(): Observable<any> {\n\t\treturn this._dismissed.asObservable().pipe(takeUntil(this._hidden));\n\t}\n\n\t/**\n\t * The observable that emits when both portal window and backdrop are closed and animations were finished.\n\t * At this point portal and backdrop elements will be removed from the DOM tree.\n\t *\n\t * This observable will be completed after emitting.\n\t *\n\t * @since 8.0.0\n\t */\n\tget hidden(): Observable<void> {\n\t\treturn this._hidden.asObservable();\n\t}\n\n\t/**\n\t * The observable that emits when portal is fully visible and animation was finished.\n\t * Portal DOM element is always available synchronously after calling 'portal.open()' service.\n\t *\n\t * This observable will be completed after emitting.\n\t * It will not emit, if portal is closed before open animation is finished.\n\t *\n\t * @since 8.0.0\n\t */\n\tget shown(): Observable<void> {\n\t\treturn this._windowCmptRef.instance.shown.asObservable();\n\t}\n\n\tconstructor(\n\t\tprivate _windowCmptRef: ComponentRef<HubPortalWindow>,\n\t\tprivate _contentRef: ContentRef,\n\t\tprivate _beforeDismiss?: () => boolean | Promise<boolean>\n\t) {\n\t\t_windowCmptRef.instance.dismissEvent.subscribe((reason: any) => {\n\t\t\tthis.dismiss(reason);\n\t\t});\n\n\t\tthis.result = new Promise((resolve, reject) => {\n\t\t\tthis._resolve = resolve;\n\t\t\tthis._reject = reject;\n\t\t});\n\t\tthis.result.then(null, () => {});\n\t}\n\n\t/**\n\t * Closes the portal with an optional `result` value.\n\t *\n\t * The `HubMobalRef.result` promise will be resolved with the provided value.\n\t */\n\tclose(result?: any): void {\n\t\tif (this._windowCmptRef) {\n\t\t\tthis._closed.next(result);\n\t\t\tthis._resolve(result);\n\t\t\tthis._removePortalElements();\n\t\t}\n\t}\n\n\tprivate _dismiss(reason?: any) {\n\t\tthis._dismissed.next(reason);\n\t\tthis._reject(reason);\n\t\tthis._removePortalElements();\n\t}\n\n\t/**\n\t * Dismisses the portal with an optional `reason` value.\n\t *\n\t * The `HubPortalRef.result` promise will be rejected with the provided value.\n\t */\n\tdismiss(reason?: any): void {\n\t\tif (this._windowCmptRef) {\n\t\t\tif (!this._beforeDismiss) {\n\t\t\t\tthis._dismiss(reason);\n\t\t\t} else {\n\t\t\t\tconst dismiss = this._beforeDismiss();\n\t\t\t\tif (isPromise(dismiss)) {\n\t\t\t\t\tdismiss.then(\n\t\t\t\t\t\t(result) => {\n\t\t\t\t\t\t\tif (result !== false) {\n\t\t\t\t\t\t\t\tthis._dismiss(reason);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t},\n\t\t\t\t\t\t() => {}\n\t\t\t\t\t);\n\t\t\t\t} else if (dismiss !== false) {\n\t\t\t\t\tthis._dismiss(reason);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate _removePortalElements() {\n\t\tconst windowTransition$ = this._windowCmptRef.instance.hide();\n\n\t\t// hiding window\n\t\twindowTransition$.subscribe(() => {\n\t\t\tconst { nativeElement } = this._windowCmptRef.location;\n\t\t\tnativeElement.parentNode.removeChild(nativeElement);\n\t\t\tthis._windowCmptRef.destroy();\n\t\t\tthis._contentRef?.viewRef?.destroy();\n\n\t\t\tthis._windowCmptRef = <any>null;\n\t\t\tthis._contentRef = <any>null;\n\t\t});\n\n\t\t// all done\n\t\tzip(windowTransition$).subscribe(() => {\n\t\t\tthis._hidden.next();\n\t\t\tthis._hidden.complete();\n\t\t});\n\t}\n}\n"]}