@skyux/modals 8.7.2 → 9.0.0-alpha.1

package/esm2022/lib/modules/modal/modal-host.service.mjs

@@ -0,0 +1,62 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+const BASE_Z_INDEX = 1040;
+const modalHosts = [];
+/**
+ * @internal
+ * @dynamic
+ */
+export class SkyModalHostService {
+    static get openModalCount() {
+        return modalHosts.length;
+    }
+    static get fullPageModalCount() {
+        const fullPageModals = modalHosts.filter((modal) => modal.fullPage);
+        return fullPageModals.length;
+    }
+    static get backdropZIndex() {
+        return BASE_Z_INDEX + modalHosts.length * 10;
+    }
+    static get topModal() {
+        return modalHosts[modalHosts.length - 1];
+    }
+    constructor() {
+        this.close = new Subject();
+        this.fullPage = false;
+        this.openHelp = new Subject();
+        this.zIndex = this.#calculateZIndex();
+        modalHosts.push(this);
+    }
+    getModalZIndex() {
+        return this.zIndex;
+    }
+    onClose() {
+        this.close.next();
+    }
+    onOpenHelp(helpKey) {
+        this.openHelp.next(helpKey);
+    }
+    destroy() {
+        modalHosts.splice(modalHosts.indexOf(this), 1);
+    }
+    #calculateZIndex() {
+        const zIndexArray = modalHosts.map((hostService) => hostService.zIndex);
+        if (zIndexArray.length === 0) {
+            return BASE_Z_INDEX + 11;
+        }
+        else {
+            const currentMaxZIndex = Math.max(...zIndexArray);
+            return currentMaxZIndex + 10;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyModalHostService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyModalHostService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyModalHostService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modules/modal/modal-instance.mjs

@@ -0,0 +1,123 @@
+import { Subject } from 'rxjs';
+import { SkyModalBeforeCloseHandler } from './modal-before-close-handler';
+import { SkyModalCloseArgs } from './modal-close-args';
+export class SkyModalInstance {
+    /**
+     * An event that the modal instance emits when it is about to close.
+     * It emits a `SkyModalBeforeCloseHandler` object with a `closeModal` method
+     * that closes the modal. If a subscription exists for this event,
+     * the modal does not close until the subscriber calls the `closeModal` method.
+     */
+    get beforeClose() {
+        return this.#_beforeClose;
+    }
+    /**
+     * An event that the modal instance emits when it closes.
+     * It emits a `SkyModalCloseArgs` object with a `data` property that includes
+     * data passed from users on close or save and a `reason` property that indicates
+     * whether the modal was saved or closed without saving.
+     * The `reason` property accepts any string value.
+     * Common examples include `"cancel"`, `"close"`, and `"save"`.
+     */
+    get closed() {
+        return this.#_closed;
+    }
+    /**
+     * An event that the modal instance emits when users click
+     * the <i class="fa fa-question-circle" aria-hidden="true"></i> button.
+     * If a `helpKey` parameter was specified, the `helpOpened` event broadcasts the `helpKey`.
+     */
+    get helpOpened() {
+        return this.#_helpOpened;
+    }
+    /**
+     * Sets the component adapter for the instance. This is used internally for actions such as scrolling the content.
+     * @internal
+     */
+    set adapter(value) {
+        this.#adapter = value;
+    }
+    /**
+     * Sets the component ref for the instance. This is used to extract the component instance for the public API and the element ref for internal use.
+     * @internal
+     */
+    set componentRef(value) {
+        this.componentInstance = value.instance;
+        this.#elementRef = value.location;
+    }
+    #_beforeClose = new Subject();
+    #_closed = new Subject();
+    #_helpOpened = new Subject();
+    #adapter;
+    #elementRef;
+    /**
+     * Closes the modal instance.
+     * @param result Specifies an object to emit to subscribers of the `closed` event of the
+     * modal instance. The `SkyModalInstance` provider can be injected into a component's constructor
+     * so that this `close` function can be called from a button in the `sky-modal-footer`.
+     * @param reason Specifies the reason for the modal closing, with the default reason of `"close"`.
+     * @param ignoreBeforeClose Indicates whether to ignore the modal instance's `beforeClose` event.
+     */
+    close(result, reason, ignoreBeforeClose) {
+        if (reason === undefined) {
+            reason = 'close';
+        }
+        this.#closeModal(reason, result, ignoreBeforeClose);
+    }
+    /**
+     * Closes the modal instance with `reason="cancel"`.
+     * @param result Specifies an object to emit to subscribers of the `closed` event of the modal
+     * instance. The `SkyModalInstance` provider can be injected into a component's constructor so
+     * that this cancel function can be called from a button in the `sky-modal-footer`.
+     */
+    cancel(result) {
+        this.#closeModal('cancel', result);
+    }
+    /**
+     * Closes the modal instance with `reason="save"`.
+     * @param result Specifies an object to emit to subscribers of the `closed` event of the modal
+     * instance. The `SkyModalInstance` provider can be injected into a component's constructor so
+     * that this `save` function can be called from a button in `the sky-modal-footer`.
+     */
+    save(result) {
+        this.#closeModal('save', result);
+    }
+    /**
+     * Scrolls the modal content area to the top of its scrollable area.
+     */
+    scrollContentToTop() {
+        if (this.#adapter && this.#elementRef) {
+            this.#adapter.scrollContentToTop(this.#elementRef);
+        }
+    }
+    /**
+     * Triggers the `helpOpened` event that broadcasts a `helpKey` parameter to open
+     * when users click the <i class="fa fa-question-circle" aria-hidden="true"></i> button.
+     * @param helpKey Specifies a string to emit to subscribers of
+     * the modal instance's `helpOpened` event. Consumers can inject the `SkyModalInstance` provider
+     * into a component's constructor to call the `openHelp` function in the modal template.
+     */
+    openHelp(helpKey) {
+        this.#_helpOpened.next(helpKey);
+    }
+    #closeModal(type, result, ignoreBeforeClose = false) {
+        const args = new SkyModalCloseArgs();
+        args.reason = type;
+        args.data = result;
+        if (this.#_beforeClose.observers.length === 0 || ignoreBeforeClose) {
+            this.#notifyClosed(args);
+        }
+        else {
+            this.#_beforeClose.next(new SkyModalBeforeCloseHandler(() => {
+                this.#notifyClosed(args);
+            }, args));
+        }
+    }
+    #notifyClosed(args) {
+        this.#_closed.next(args);
+        this.#_closed.complete();
+        this.#_beforeClose.complete();
+        this.#_helpOpened.complete();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal-instance.js","sourceRoot":"","sources":["../../../../../../../../libs/components/modals/src/lib/modules/modal/modal-instance.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef, ElementRef } from '@angular/core';\n\nimport { Observable, Subject } from 'rxjs';\n\nimport { SkyModalAdapterService } from './modal-adapter.service';\nimport { SkyModalBeforeCloseHandler } from './modal-before-close-handler';\nimport { SkyModalCloseArgs } from './modal-close-args';\n\nexport class SkyModalInstance {\n  /**\n   * An event that the modal instance emits when it is about to close.\n   * It emits a `SkyModalBeforeCloseHandler` object with a `closeModal` method\n   * that closes the modal. If a subscription exists for this event,\n   * the modal does not close until the subscriber calls the `closeModal` method.\n   */\n  public get beforeClose(): Observable<SkyModalBeforeCloseHandler> {\n    return this.#_beforeClose;\n  }\n\n  /**\n   * An event that the modal instance emits when it closes.\n   * It emits a `SkyModalCloseArgs` object with a `data` property that includes\n   * data passed from users on close or save and a `reason` property that indicates\n   * whether the modal was saved or closed without saving.\n   * The `reason` property accepts any string value.\n   * Common examples include `\"cancel\"`, `\"close\"`, and `\"save\"`.\n   */\n  public get closed(): Observable<SkyModalCloseArgs> {\n    return this.#_closed;\n  }\n\n  /**\n   * An event that the modal instance emits when users click\n   * the <i class=\"fa fa-question-circle\" aria-hidden=\"true\"></i> button.\n   * If a `helpKey` parameter was specified, the `helpOpened` event broadcasts the `helpKey`.\n   */\n  public get helpOpened(): Observable<string> {\n    return this.#_helpOpened;\n  }\n\n  /**\n   * A direct reference to the provided component's class.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public componentInstance: any;\n\n  /**\n   * Sets the component adapter for the instance. This is used internally for actions such as scrolling the content.\n   * @internal\n   */\n  public set adapter(value: SkyModalAdapterService) {\n    this.#adapter = value;\n  }\n\n  /**\n   * Sets the component ref for the instance. This is used to extract the component instance for the public API and the element ref for internal use.\n   * @internal\n   */\n  public set componentRef(value: ComponentRef<any>) {\n    this.componentInstance = value.instance;\n    this.#elementRef = value.location;\n  }\n\n  #_beforeClose = new Subject<SkyModalBeforeCloseHandler>();\n\n  #_closed = new Subject<SkyModalCloseArgs>();\n\n  #_helpOpened = new Subject<string>();\n\n  #adapter: SkyModalAdapterService | undefined;\n  #elementRef: ElementRef | undefined;\n\n  /**\n   * Closes the modal instance.\n   * @param result Specifies an object to emit to subscribers of the `closed` event of the\n   * modal instance. The `SkyModalInstance` provider can be injected into a component's constructor\n   * so that this `close` function can be called from a button in the `sky-modal-footer`.\n   * @param reason Specifies the reason for the modal closing, with the default reason of `\"close\"`.\n   * @param ignoreBeforeClose Indicates whether to ignore the modal instance's `beforeClose` event.\n   */\n  public close(\n    result?: any,\n    reason?: string,\n    ignoreBeforeClose?: boolean\n  ): void {\n    if (reason === undefined) {\n      reason = 'close';\n    }\n\n    this.#closeModal(reason, result, ignoreBeforeClose);\n  }\n\n  /**\n   * Closes the modal instance with `reason=\"cancel\"`.\n   * @param result Specifies an object to emit to subscribers of the `closed` event of the modal\n   * instance. The `SkyModalInstance` provider can be injected into a component's constructor so\n   * that this cancel function can be called from a button in the `sky-modal-footer`.\n   */\n  public cancel(result?: any): void {\n    this.#closeModal('cancel', result);\n  }\n\n  /**\n   * Closes the modal instance with `reason=\"save\"`.\n   * @param result Specifies an object to emit to subscribers of the `closed` event of the modal\n   * instance. The `SkyModalInstance` provider can be injected into a component's constructor so\n   * that this `save` function can be called from a button in `the sky-modal-footer`.\n   */\n  public save(result?: any): void {\n    this.#closeModal('save', result);\n  }\n\n  /**\n   * Scrolls the modal content area to the top of its scrollable area.\n   */\n  public scrollContentToTop(): void {\n    if (this.#adapter && this.#elementRef) {\n      this.#adapter.scrollContentToTop(this.#elementRef);\n    }\n  }\n\n  /**\n   * Triggers the `helpOpened` event that broadcasts a `helpKey` parameter to open\n   * when users click the <i class=\"fa fa-question-circle\" aria-hidden=\"true\"></i> button.\n   * @param helpKey Specifies a string to emit to subscribers of\n   * the modal instance's `helpOpened` event. Consumers can inject the `SkyModalInstance` provider\n   * into a component's constructor to call the `openHelp` function in the modal template.\n   */\n  public openHelp(helpKey: string): void {\n    this.#_helpOpened.next(helpKey);\n  }\n\n  #closeModal(type: string, result?: any, ignoreBeforeClose = false): void {\n    const args = new SkyModalCloseArgs();\n\n    args.reason = type;\n    args.data = result;\n\n    if (this.#_beforeClose.observers.length === 0 || ignoreBeforeClose) {\n      this.#notifyClosed(args);\n    } else {\n      this.#_beforeClose.next(\n        new SkyModalBeforeCloseHandler(() => {\n          this.#notifyClosed(args);\n        }, args)\n      );\n    }\n  }\n\n  #notifyClosed(args: SkyModalCloseArgs): void {\n    this.#_closed.next(args);\n    this.#_closed.complete();\n    this.#_beforeClose.complete();\n    this.#_helpOpened.complete();\n  }\n}\n"]}

package/esm2022/lib/modules/modal/modal-is-dirty.directive.mjs

@@ -0,0 +1,94 @@
+import { Directive, HostBinding, Input, inject, } from '@angular/core';
+import { SkyLibResourcesService } from '@skyux/i18n';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { SkyConfirmType } from '../confirm/confirm-type';
+import { SkyConfirmService } from '../confirm/confirm.service';
+import { SkyModalInstance } from './modal-instance';
+import * as i0 from "@angular/core";
+/**
+ * Provides a way to mark a modal as "dirty" and displays a confirmation
+ * message when a user closes the modal without saving.
+ */
+export class SkyModalIsDirtyDirective {
+    constructor() {
+        /**
+         * Whether the user edited an input on the modal.
+         * @required
+         */
+        this.isDirty = false;
+        this.#ngUnsubscribe = new Subject();
+        this.#modalInstance = inject(SkyModalInstance);
+        this.#confirmSvc = inject(SkyConfirmService);
+        this.#resourcesSvc = inject(SkyLibResourcesService);
+    }
+    #ngUnsubscribe;
+    #modalInstance;
+    #confirmSvc;
+    #resourcesSvc;
+    ngOnInit() {
+        this.#modalInstance.beforeClose
+            .pipe(takeUntil(this.#ngUnsubscribe))
+            .subscribe((handler) => this.#promptIfDirty(handler));
+    }
+    ngOnDestroy() {
+        this.#ngUnsubscribe.next();
+        this.#ngUnsubscribe.complete();
+    }
+    #promptIfDirty(handler) {
+        if (this.isDirty && handler.closeArgs.reason === 'close') {
+            this.#resourcesSvc
+                .getStrings({
+                message: 'skyux_modal_dirty_default_message',
+                discardActionText: 'skyux_modal_dirty_default_discard_changes_text',
+                keepActionText: 'skyux_modal_dirty_default_keep_working_text',
+            })
+                .subscribe((textValues) => {
+                const discardAction = 'discard';
+                const keepAction = 'keep';
+                this.#confirmSvc
+                    .open({
+                    message: textValues.message,
+                    buttons: [
+                        {
+                            action: discardAction,
+                            text: textValues.discardActionText,
+                            styleType: 'primary',
+                        },
+                        {
+                            action: keepAction,
+                            text: textValues.keepActionText,
+                            styleType: 'link',
+                        },
+                    ],
+                    type: SkyConfirmType.Custom,
+                })
+                    .closed.subscribe((args) => {
+                    if (args.action === discardAction) {
+                        handler.closeModal();
+                    }
+                });
+            });
+        }
+        else {
+            handler.closeModal();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyModalIsDirtyDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", type: SkyModalIsDirtyDirective, selector: "sky-modal[isDirty]", inputs: { isDirty: "isDirty" }, host: { properties: { "attr.data-sky-modal-is-dirty": "this.isDirty" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyModalIsDirtyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // Since this is limited to sky-modal, it should be safe to
+                    // leave off the sky prefix.
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'sky-modal[isDirty]',
+                }]
+        }], propDecorators: { isDirty: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['attr.data-sky-modal-is-dirty']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modules/modal/modal-scroll-shadow.directive.mjs

@@ -0,0 +1,129 @@
+import { Directive, EventEmitter, HostListener, Optional, Output, } from '@angular/core';
+import { SkyTheme } from '@skyux/theme';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@skyux/core";
+import * as i2 from "@skyux/theme";
+/**
+ * Raises an event when the box shadow for the modal header or footer should be adjusted
+ * based on the scroll position of the host element.
+ * @internal
+ */
+export class SkyModalScrollShadowDirective {
+    #currentShadow;
+    #currentTheme;
+    #mutationObserver;
+    #ngUnsubscribe;
+    #elRef;
+    #mutationObserverSvc;
+    #ngZone;
+    #themeSvc;
+    constructor(elRef, mutationObserverSvc, ngZone, themeSvc) {
+        this.skyModalScrollShadow = new EventEmitter();
+        this.#ngUnsubscribe = new Subject();
+        this.#elRef = elRef;
+        this.#mutationObserverSvc = mutationObserverSvc;
+        this.#ngZone = ngZone;
+        this.#themeSvc = themeSvc;
+    }
+    windowResize() {
+        this.#checkForShadow();
+    }
+    scroll() {
+        this.#checkForShadow();
+    }
+    ngOnInit() {
+        if (this.#themeSvc) {
+            this.#themeSvc.settingsChange
+                .pipe(takeUntil(this.#ngUnsubscribe))
+                .subscribe((themeSettings) => {
+                this.#currentTheme = themeSettings.currentSettings.theme;
+                if (this.#currentTheme === SkyTheme.presets.modern) {
+                    this.#initMutationObserver();
+                }
+                else {
+                    this.#emitShadow({
+                        bottomShadow: 'none',
+                        topShadow: 'none',
+                    });
+                    this.#destroyMutationObserver();
+                }
+            });
+        }
+    }
+    ngOnDestroy() {
+        this.#ngUnsubscribe.next();
+        this.#ngUnsubscribe.complete();
+        this.#destroyMutationObserver();
+    }
+    #initMutationObserver() {
+        if (!this.#mutationObserver) {
+            const el = this.#elRef.nativeElement;
+            // MutationObserver is patched by Zone.js and therefore becomes part of the
+            // Angular change detection cycle, but this can lead to infinite loops in some
+            // scenarios. This will keep MutationObserver from triggering change detection.
+            this.#ngZone.runOutsideAngular(() => {
+                this.#mutationObserver = this.#mutationObserverSvc.create(() => {
+                    this.#checkForShadow();
+                });
+                this.#mutationObserver.observe(el, {
+                    attributes: true,
+                    characterData: true,
+                    childList: true,
+                    subtree: true,
+                });
+            });
+        }
+    }
+    #destroyMutationObserver() {
+        if (this.#mutationObserver) {
+            this.#mutationObserver.disconnect();
+            this.#mutationObserver = undefined;
+        }
+    }
+    #checkForShadow() {
+        if (this.#currentTheme === SkyTheme.presets.modern) {
+            const el = this.#elRef.nativeElement;
+            const topShadow = this.#buildShadowStyle(el.scrollTop);
+            const bottomShadow = this.#buildShadowStyle(el.scrollHeight - el.scrollTop - el.clientHeight);
+            this.#emitShadow({
+                bottomShadow,
+                topShadow,
+            });
+        }
+    }
+    #buildShadowStyle(pixelsFromEnd) {
+        // Progressively darken the shadow until the user scrolls 30 pixels from the top or bottom
+        // of the scrollable element, with a max opacity of 0.3.
+        const opacity = Math.min(pixelsFromEnd / 30, 1) * 0.3;
+        return opacity > 0 ? `0px 1px 8px 0px rgba(0, 0, 0, ${opacity})` : 'none';
+    }
+    #emitShadow(shadow) {
+        if (!this.#currentShadow ||
+            this.#currentShadow.bottomShadow !== shadow.bottomShadow ||
+            this.#currentShadow.topShadow !== shadow.topShadow) {
+            this.skyModalScrollShadow.emit(shadow);
+            this.#currentShadow = shadow;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyModalScrollShadowDirective, deps: [{ token: i0.ElementRef }, { token: i1.SkyMutationObserverService }, { token: i0.NgZone }, { token: i2.SkyThemeService, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.7", type: SkyModalScrollShadowDirective, selector: "[skyModalScrollShadow]", outputs: { skyModalScrollShadow: "skyModalScrollShadow" }, host: { listeners: { "window:resize": "windowResize()", "scroll": "scroll()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyModalScrollShadowDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[skyModalScrollShadow]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.SkyMutationObserverService }, { type: i0.NgZone }, { type: i2.SkyThemeService, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { skyModalScrollShadow: [{
+                type: Output
+            }], windowResize: [{
+                type: HostListener,
+                args: ['window:resize']
+            }], scroll: [{
+                type: HostListener,
+                args: ['scroll']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal-scroll-shadow.directive.js","sourceRoot":"","sources":["../../../../../../../../libs/components/modals/src/lib/modules/modal/modal-scroll-shadow.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  ElementRef,\n  EventEmitter,\n  HostListener,\n  NgZone,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n} from '@angular/core';\nimport { SkyMutationObserverService } from '@skyux/core';\nimport { SkyTheme, SkyThemeService } from '@skyux/theme';\n\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { SkyModalScrollShadowEventArgs } from './modal-scroll-shadow-event-args';\n\n/**\n * Raises an event when the box shadow for the modal header or footer should be adjusted\n * based on the scroll position of the host element.\n * @internal\n */\n@Directive({\n  selector: '[skyModalScrollShadow]',\n})\nexport class SkyModalScrollShadowDirective implements OnInit, OnDestroy {\n  @Output()\n  public skyModalScrollShadow =\n    new EventEmitter<SkyModalScrollShadowEventArgs>();\n\n  #currentShadow: SkyModalScrollShadowEventArgs | undefined;\n\n  #currentTheme: SkyTheme | undefined;\n\n  #mutationObserver: MutationObserver | undefined;\n\n  #ngUnsubscribe = new Subject<void>();\n\n  #elRef: ElementRef;\n  #mutationObserverSvc: SkyMutationObserverService;\n  #ngZone: NgZone;\n  #themeSvc: SkyThemeService | undefined;\n\n  constructor(\n    elRef: ElementRef,\n    mutationObserverSvc: SkyMutationObserverService,\n    ngZone: NgZone,\n    @Optional() themeSvc?: SkyThemeService\n  ) {\n    this.#elRef = elRef;\n    this.#mutationObserverSvc = mutationObserverSvc;\n    this.#ngZone = ngZone;\n    this.#themeSvc = themeSvc;\n  }\n\n  @HostListener('window:resize')\n  public windowResize(): void {\n    this.#checkForShadow();\n  }\n\n  @HostListener('scroll')\n  public scroll(): void {\n    this.#checkForShadow();\n  }\n\n  public ngOnInit(): void {\n    if (this.#themeSvc) {\n      this.#themeSvc.settingsChange\n        .pipe(takeUntil(this.#ngUnsubscribe))\n        .subscribe((themeSettings) => {\n          this.#currentTheme = themeSettings.currentSettings.theme;\n\n          if (this.#currentTheme === SkyTheme.presets.modern) {\n            this.#initMutationObserver();\n          } else {\n            this.#emitShadow({\n              bottomShadow: 'none',\n              topShadow: 'none',\n            });\n\n            this.#destroyMutationObserver();\n          }\n        });\n    }\n  }\n\n  public ngOnDestroy(): void {\n    this.#ngUnsubscribe.next();\n    this.#ngUnsubscribe.complete();\n\n    this.#destroyMutationObserver();\n  }\n\n  #initMutationObserver(): void {\n    if (!this.#mutationObserver) {\n      const el = this.#elRef.nativeElement;\n\n      // MutationObserver is patched by Zone.js and therefore becomes part of the\n      // Angular change detection cycle, but this can lead to infinite loops in some\n      // scenarios. This will keep MutationObserver from triggering change detection.\n      this.#ngZone.runOutsideAngular(() => {\n        this.#mutationObserver = this.#mutationObserverSvc.create(() => {\n          this.#checkForShadow();\n        });\n\n        this.#mutationObserver.observe(el, {\n          attributes: true,\n          characterData: true,\n          childList: true,\n          subtree: true,\n        });\n      });\n    }\n  }\n\n  #destroyMutationObserver(): void {\n    if (this.#mutationObserver) {\n      this.#mutationObserver.disconnect();\n      this.#mutationObserver = undefined;\n    }\n  }\n\n  #checkForShadow(): void {\n    if (this.#currentTheme === SkyTheme.presets.modern) {\n      const el = this.#elRef.nativeElement;\n\n      const topShadow = this.#buildShadowStyle(el.scrollTop);\n\n      const bottomShadow = this.#buildShadowStyle(\n        el.scrollHeight - el.scrollTop - el.clientHeight\n      );\n\n      this.#emitShadow({\n        bottomShadow,\n        topShadow,\n      });\n    }\n  }\n\n  #buildShadowStyle(pixelsFromEnd: number): string {\n    // Progressively darken the shadow until the user scrolls 30 pixels from the top or bottom\n    // of the scrollable element, with a max opacity of 0.3.\n    const opacity = Math.min(pixelsFromEnd / 30, 1) * 0.3;\n\n    return opacity > 0 ? `0px 1px 8px 0px rgba(0, 0, 0, ${opacity})` : 'none';\n  }\n\n  #emitShadow(shadow: SkyModalScrollShadowEventArgs): void {\n    if (\n      !this.#currentShadow ||\n      this.#currentShadow.bottomShadow !== shadow.bottomShadow ||\n      this.#currentShadow.topShadow !== shadow.topShadow\n    ) {\n      this.skyModalScrollShadow.emit(shadow);\n      this.#currentShadow = shadow;\n    }\n  }\n}\n"]}