@skyux/modals 8.6.0 → 9.0.0-alpha.0

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

@@ -0,0 +1,97 @@
+import { Injectable } from '@angular/core';
+import { SkyModalHostContext } from './modal-host-context';
+import { SkyModalHostComponent } from './modal-host.component';
+import { SkyModalInstance } from './modal-instance';
+import * as i0 from "@angular/core";
+import * as i1 from "@skyux/core";
+/**
+ * A service that launches modals.
+ * @dynamic
+ */
+export class SkyModalService {
+    #dynamicComponentService;
+    constructor(dynamicComponentService) {
+        this.#dynamicComponentService = dynamicComponentService;
+    }
+    /**
+     * @internal
+     * Removes the modal host from the DOM.
+     */
+    dispose() {
+        if (SkyModalService.host) {
+            this.#dynamicComponentService.removeComponent(SkyModalService.host);
+            SkyModalService.host = undefined;
+        }
+    }
+    /**
+     * Opens a modal using the specified component.
+     * @param component Determines the component to render.
+     * @param {SkyModalConfigurationInterface} config Specifies configuration options for the modal.
+     */
+    open(component, config) {
+        const modalInstance = new SkyModalInstance();
+        this.#createHostComponent();
+        const params = this.#getConfigFromParameter(config);
+        params.providers ||= [];
+        params.providers.push({
+            provide: SkyModalInstance,
+            useValue: modalInstance,
+        });
+        if (SkyModalService.host) {
+            SkyModalService.host.instance.open(modalInstance, component, params);
+        }
+        return modalInstance;
+    }
+    #getConfigFromParameter(providersOrConfig) {
+        const defaultParams = {
+            providers: [],
+            fullPage: false,
+            size: 'medium',
+            tiledBody: false,
+        };
+        let params = {};
+        let method = undefined;
+        // Object Literal Lookup for backwards compatibility.
+        method = {
+            'providers?': Object.assign({}, defaultParams, {
+                providers: providersOrConfig,
+            }),
+            config: Object.assign({}, defaultParams, providersOrConfig),
+        };
+        if (Array.isArray(providersOrConfig) === true) {
+            params = method['providers?'];
+        }
+        else {
+            params = method['config'];
+        }
+        return params;
+    }
+    #createHostComponent() {
+        if (!SkyModalService.host) {
+            SkyModalService.host = this.#dynamicComponentService.createComponent(SkyModalHostComponent, {
+                providers: [
+                    {
+                        provide: SkyModalHostContext,
+                        useValue: new SkyModalHostContext({
+                            teardownCallback: () => {
+                                this.dispose();
+                            },
+                        }),
+                    },
+                ],
+            });
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyModalService, deps: [{ token: i1.SkyDynamicComponentService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyModalService, providedIn: 'any' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyModalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    // Must be 'any' so that the modal component is created in the context of its module's injector.
+                    // If set to 'root', the component's dependency injections would only be derived from the root
+                    // injector and may lose context if the modal was opened from within a lazy-loaded module.
+                    providedIn: 'any',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkyDynamicComponentService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modules/shared/sky-modals-resources.module.mjs

@@ -0,0 +1,61 @@
+/**
+ * NOTICE: DO NOT MODIFY THIS FILE!
+ * The contents of this file were automatically generated by
+ * the 'ng generate @skyux/i18n:lib-resources-module lib/modules/shared/sky-modals' schematic.
+ * To update this file, simply rerun the command.
+ */
+import { NgModule } from '@angular/core';
+import { SKY_LIB_RESOURCES_PROVIDERS, SkyI18nModule, getLibStringForLocale, } from '@skyux/i18n';
+import * as i0 from "@angular/core";
+const RESOURCES = {
+    'EN-US': {
+        skyux_confirm_dialog_default_ok_text: { message: 'OK' },
+        skyux_confirm_dialog_default_yes_text: { message: 'Yes' },
+        skyux_confirm_dialog_default_no_text: { message: 'No' },
+        skyux_confirm_dialog_default_cancel_text: { message: 'Cancel' },
+        skyux_modal_close: { message: 'Close modal' },
+        skyux_modal_open_help: { message: 'Open Help' },
+        skyux_modal_footer_cancel_button: { message: 'Cancel' },
+        skyux_modal_footer_primary_button: { message: 'Save' },
+        skyux_modal_dirty_default_message: {
+            message: 'Are you sure you want to discard your changes?',
+        },
+        skyux_modal_dirty_default_discard_changes_text: {
+            message: 'Discard changes',
+        },
+        skyux_modal_dirty_default_keep_working_text: { message: 'Keep working' },
+    },
+};
+export class SkyModalsResourcesProvider {
+    getString(localeInfo, name) {
+        return getLibStringForLocale(RESOURCES, localeInfo.locale, name);
+    }
+}
+/**
+ * Import into any component library module that needs to use resource strings.
+ */
+export class SkyModalsResourcesModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyModalsResourcesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.7", ngImport: i0, type: SkyModalsResourcesModule, exports: [SkyI18nModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyModalsResourcesModule, providers: [
+            {
+                provide: SKY_LIB_RESOURCES_PROVIDERS,
+                useClass: SkyModalsResourcesProvider,
+                multi: true,
+            },
+        ], imports: [SkyI18nModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyModalsResourcesModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [SkyI18nModule],
+                    providers: [
+                        {
+                            provide: SKY_LIB_RESOURCES_PROVIDERS,
+                            useClass: SkyModalsResourcesProvider,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/confirm/confirm-button-harness.mjs

@@ -0,0 +1,46 @@
+import { ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+/**
+ * Harness for interacting with a confirm component in tests.
+ * @internal
+ */
+export class SkyConfirmButtonHarness extends ComponentHarness {
+    static { this.hostSelector = '.sky-confirm-buttons .sky-btn'; }
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyConfirmButtonHarness` that meets certain criteria.
+     */
+    static with(filters) {
+        return new HarnessPredicate(SkyConfirmButtonHarness, filters)
+            .addOption('text', filters.text, async (harness, text) => HarnessPredicate.stringMatches(await harness.getText(), text))
+            .addOption('styleType', filters.styleType, async (harness, styleType) => HarnessPredicate.stringMatches(await harness.getStyleType(), styleType));
+    }
+    /**
+     * Clicks the confirm button.
+     */
+    async click() {
+        return (await this.host()).click();
+    }
+    /**
+     * Gets the button style of the confirm button.
+     */
+    async getStyleType() {
+        const hostEl = await this.host();
+        if (await hostEl.hasClass('sky-btn-primary')) {
+            return 'primary';
+        }
+        else if (await hostEl.hasClass('sky-btn-link')) {
+            return 'link';
+        }
+        else if (await hostEl.hasClass('sky-btn-danger')) {
+            return 'danger';
+        }
+        return 'default';
+    }
+    /**
+     * Gets the text content of the confirm button.
+     */
+    async getText() {
+        return (await this.host()).text();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/confirm/confirm-harness.mjs

@@ -0,0 +1,90 @@
+import { SkyComponentHarness } from '@skyux/core/testing';
+import { SkyConfirmType } from '@skyux/modals';
+import { SkyConfirmButtonHarness } from './confirm-button-harness';
+/**
+ * Harness for interacting with a confirm component in tests.
+ */
+export class SkyConfirmHarness extends SkyComponentHarness {
+    static { this.hostSelector = 'sky-confirm'; }
+    #getBodyEl = this.locatorForOptional('.sky-confirm-body');
+    #getButtons = this.locatorForAll(SkyConfirmButtonHarness);
+    #getConfirmEl = this.locatorFor('.sky-confirm');
+    #getMessageEl = this.locatorFor('.sky-confirm-message');
+    /**
+     * Clicks a confirm button.
+     */
+    async clickCustomButton(filters) {
+        const buttons = await this.getCustomButtons(filters);
+        if (buttons.length > 1) {
+            if (filters.text instanceof RegExp) {
+                filters.text = filters.text.toString();
+            }
+            throw new Error(`More than one button matches the filter(s): ${JSON.stringify(filters)}.`);
+        }
+        await buttons[0].click();
+    }
+    /**
+     * Clicks a confirm button.
+     */
+    async clickOkButton() {
+        const type = await this.getType();
+        if (type === SkyConfirmType.Custom) {
+            throw new Error('Cannot click OK button on a confirm of type custom.');
+        }
+        const buttons = await this.#getButtons();
+        await buttons[0].click();
+    }
+    /**
+     * Gets the body of the confirm component.
+     */
+    async getBodyText() {
+        return (await this.#getBodyEl())?.text();
+    }
+    /**
+     * Gets the confirm component's custom buttons.
+     */
+    async getCustomButtons(filters) {
+        const confirmType = await this.getType();
+        if (confirmType === SkyConfirmType.OK) {
+            throw new Error('Cannot get custom buttons for confirm of type OK.');
+        }
+        const harnesses = await this.#queryHarnesses(SkyConfirmButtonHarness.with(filters || {}));
+        if (filters && harnesses.length === 0) {
+            // Stringify the regular expression so that it's readable in the console log.
+            if (filters.text instanceof RegExp) {
+                filters.text = filters.text.toString();
+            }
+            throw new Error(`Could not find buttons matching filter(s): ${JSON.stringify(filters)}.`);
+        }
+        return harnesses;
+    }
+    /**
+     * Gets the message of the confirm component.
+     */
+    async getMessageText() {
+        return (await this.#getMessageEl()).text();
+    }
+    /**
+     * Gets the type of the confirm component.
+     */
+    async getType() {
+        const confirmEl = await this.#getConfirmEl();
+        if (await confirmEl.hasClass('sky-confirm-type-ok')) {
+            return SkyConfirmType.OK;
+        }
+        return SkyConfirmType.Custom;
+    }
+    /**
+     * Whether the whitespace is preserved on the confirm component.
+     */
+    async isWhiteSpacePreserved() {
+        return (await this.#getMessageEl()).hasClass('sky-confirm-preserve-white-space');
+    }
+    /**
+     * Returns child harnesses.
+     */
+    async #queryHarnesses(harness) {
+        return this.locatorForAll(harness)();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"confirm-harness.js","sourceRoot":"","sources":["../../../../../../../libs/components/modals/testing/src/confirm/confirm-harness.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentHarness, HarnessQuery } from '@angular/cdk/testing';\nimport { SkyComponentHarness } from '@skyux/core/testing';\nimport { SkyConfirmType } from '@skyux/modals';\n\nimport { SkyConfirmButtonHarness } from './confirm-button-harness';\nimport { SkyConfirmButtonHarnessFilters } from './confirm-button-harness-filters';\n\n/**\n * Harness for interacting with a confirm component in tests.\n */\nexport class SkyConfirmHarness extends SkyComponentHarness {\n  public static hostSelector = 'sky-confirm';\n\n  #getBodyEl = this.locatorForOptional('.sky-confirm-body');\n  #getButtons = this.locatorForAll(SkyConfirmButtonHarness);\n  #getConfirmEl = this.locatorFor('.sky-confirm');\n  #getMessageEl = this.locatorFor('.sky-confirm-message');\n\n  /**\n   * Clicks a confirm button.\n   */\n  public async clickCustomButton(\n    filters: SkyConfirmButtonHarnessFilters\n  ): Promise<void> {\n    const buttons = await this.getCustomButtons(filters);\n\n    if (buttons.length > 1) {\n      if (filters.text instanceof RegExp) {\n        filters.text = filters.text.toString();\n      }\n      throw new Error(\n        `More than one button matches the filter(s): ${JSON.stringify(\n          filters\n        )}.`\n      );\n    }\n    await buttons[0].click();\n  }\n\n  /**\n   * Clicks a confirm button.\n   */\n  public async clickOkButton(): Promise<void> {\n    const type = await this.getType();\n\n    if (type === SkyConfirmType.Custom) {\n      throw new Error('Cannot click OK button on a confirm of type custom.');\n    }\n    const buttons = await this.#getButtons();\n    await buttons[0].click();\n  }\n\n  /**\n   * Gets the body of the confirm component.\n   */\n  public async getBodyText(): Promise<string | undefined> {\n    return (await this.#getBodyEl())?.text();\n  }\n\n  /**\n   * Gets the confirm component's custom buttons.\n   */\n  public async getCustomButtons(\n    filters?: SkyConfirmButtonHarnessFilters\n  ): Promise<SkyConfirmButtonHarness[]> {\n    const confirmType = await this.getType();\n\n    if (confirmType === SkyConfirmType.OK) {\n      throw new Error('Cannot get custom buttons for confirm of type OK.');\n    }\n\n    const harnesses = await this.#queryHarnesses(\n      SkyConfirmButtonHarness.with(filters || {})\n    );\n\n    if (filters && harnesses.length === 0) {\n      // Stringify the regular expression so that it's readable in the console log.\n      if (filters.text instanceof RegExp) {\n        filters.text = filters.text.toString();\n      }\n\n      throw new Error(\n        `Could not find buttons matching filter(s): ${JSON.stringify(filters)}.`\n      );\n    }\n\n    return harnesses;\n  }\n\n  /**\n   * Gets the message of the confirm component.\n   */\n  public async getMessageText(): Promise<string> {\n    return (await this.#getMessageEl()).text();\n  }\n\n  /**\n   * Gets the type of the confirm component.\n   */\n  public async getType(): Promise<SkyConfirmType> {\n    const confirmEl = await this.#getConfirmEl();\n    if (await confirmEl.hasClass('sky-confirm-type-ok')) {\n      return SkyConfirmType.OK;\n    }\n\n    return SkyConfirmType.Custom;\n  }\n\n  /**\n   * Whether the whitespace is preserved on the confirm component.\n   */\n  public async isWhiteSpacePreserved(): Promise<boolean> {\n    return (await this.#getMessageEl()).hasClass(\n      'sky-confirm-preserve-white-space'\n    );\n  }\n\n  /**\n   * Returns child harnesses.\n   */\n  async #queryHarnesses<T extends ComponentHarness>(\n    harness: HarnessQuery<T>\n  ): Promise<T[]> {\n    return this.locatorForAll(harness)();\n  }\n}\n"]}

package/esm2022/testing/modal/modal-harness.mjs

@@ -0,0 +1,75 @@
+import { SkyComponentHarness } from '@skyux/core/testing';
+/**
+ * Harness for interacting with a modal component in tests.
+ */
+export class SkyModalHarness extends SkyComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-modal'; }
+    #getModal = this.locatorFor('.sky-modal');
+    #getModalDialog = this.locatorFor('.sky-modal-dialog');
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyModalHarness` that meets certain criteria
+     */
+    static with(filters) {
+        return SkyModalHarness.getDataSkyIdPredicate(filters);
+    }
+    /**
+     * Gets the aria-describedBy property of the modal
+     */
+    async getAriaDescribedBy() {
+        return (await this.#getModalDialog()).getAttribute('aria-describedby');
+    }
+    /**
+     * Gets the aria-labelledBy property of the modal
+     */
+    async getAriaLabelledBy() {
+        return (await this.#getModalDialog()).getAttribute('aria-labelledby');
+    }
+    /**
+     * Gets the role of the modal.
+     */
+    async getAriaRole() {
+        return (await this.#getModalDialog()).getAttribute('role');
+    }
+    /**
+     * Gets the modal size.
+     */
+    async getSize() {
+        if (await this.isFullPage()) {
+            throw new Error('Size cannot be determined because size property is overridden when modal is full page');
+        }
+        const modal = await this.#getModal();
+        if (await modal.hasClass('sky-modal-small')) {
+            return 'small';
+        }
+        if (await modal.hasClass('sky-modal-large')) {
+            return 'large';
+        }
+        return 'medium';
+    }
+    /**
+     * Gets the wrapper class of the modal.
+     */
+    async getWrapperClass() {
+        return await (await this.host()).getProperty('className');
+    }
+    /**
+     * Whether the modal is full page.
+     */
+    async isFullPage() {
+        const modal = this.#getModal();
+        return (await modal).hasClass('sky-modal-full-page');
+    }
+    /**
+     * Whether the modal has {@link SkyModalIsDirtyDirective.isDirty} set to dirty.
+     */
+    async isDirty() {
+        const modalHost = await this.host();
+        const isDirtyAttribute = await modalHost.getAttribute('data-sky-modal-is-dirty');
+        return isDirtyAttribute === 'true';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/modal-fixture.mjs

@@ -0,0 +1,143 @@
+/**
+ * Allows interaction with a SKY UX modal component.
+ * @internal
+ */
+export class SkyModalFixture {
+    #modalElement;
+    #fixture;
+    constructor(fixture, skyTestId) {
+        this.#fixture = fixture;
+        const modalElement = document.querySelector('sky-modal[data-sky-id="' + skyTestId + '"]');
+        if (!modalElement) {
+            throw new Error(`No element was found with a \`data-sky-id\` value of "${skyTestId}".`);
+        }
+        this.#modalElement = modalElement;
+    }
+    /**
+     * The modal component's ARIA describedby attribute.
+     */
+    get ariaDescribedBy() {
+        const modalDialogElement = this.#getModalDialogElement();
+        /* Non-null assertion as our component has a default for if the user does not provide this attribute or if they provide "undefined" */
+        const describedByAttribute = 
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        modalDialogElement.getAttribute('aria-describedby');
+        return describedByAttribute;
+    }
+    /**
+     * The modal component's ARIA labelledby attribute.
+     */
+    get ariaLabelledBy() {
+        const modalDialogElement = this.#getModalDialogElement();
+        /* Non-null assertion as our component has a default for if the user does not provide this attribute or if they provide "undefined" */
+        const labelledByAttribute = 
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        modalDialogElement.getAttribute('aria-labelledby');
+        return labelledByAttribute;
+    }
+    /**
+     * The modal component's role attribute.
+     */
+    get ariaRole() {
+        const modalDialogElement = this.#getModalDialogElement();
+        /* Non-null assertion as our component has a default for if the user does not provide this attribute or if they provide "undefined" */
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const roleAttribute = modalDialogElement.getAttribute('role');
+        return roleAttribute;
+    }
+    /**
+     * Whether or not the modal is a full page modal.
+     */
+    get fullPage() {
+        const modalDivElement = this.getModalDiv();
+        return modalDivElement.classList.contains('sky-modal-full-page');
+    }
+    /**
+     * The size of the modal.
+     */
+    get size() {
+        const modalDivElement = this.getModalDiv();
+        const possibleSizes = ['small', 'medium', 'large'];
+        for (const size of possibleSizes) {
+            if (modalDivElement.classList.contains('sky-modal-' + size)) {
+                return size;
+            }
+        }
+        return;
+    }
+    /**
+     * Whether or not the modal is set up for tiled content.
+     */
+    get tiledBody() {
+        const modalDivElement = this.getModalDiv();
+        return modalDivElement.classList.contains('sky-modal-tiled');
+    }
+    /**
+     * Clicks the modal header's "close" button.
+     */
+    clickHeaderCloseButton() {
+        this.#checkModalElement();
+        const closeButton = this.#modalElement.querySelector('.sky-modal .sky-modal-btn-close');
+        if (closeButton &&
+            window.getComputedStyle(closeButton).display !== 'none') {
+            closeButton.click();
+            this.#fixture.detectChanges();
+        }
+        else {
+            throw new Error(`No header close button exists.`);
+        }
+    }
+    /**
+     * Clicks the modal header's "help" button.
+     */
+    clickHelpButton() {
+        this.#checkModalElement();
+        const helpButton = this.#modalElement.querySelector('.sky-modal .sky-modal-header-buttons button[name="help-button"]');
+        if (helpButton && window.getComputedStyle(helpButton).display !== 'none') {
+            helpButton.click();
+            this.#fixture.detectChanges();
+        }
+        else {
+            throw new Error(`No help button exists.`);
+        }
+    }
+    /**
+     * Returns the main modal element.
+     */
+    getModalDiv() {
+        this.#checkModalElement();
+        return this.#modalElement.querySelector('.sky-modal');
+    }
+    /**
+     * Returns the modal's content element.
+     */
+    getModalContentEl() {
+        this.#checkModalElement();
+        return this.#modalElement.querySelector('.sky-modal-content');
+    }
+    /**
+     * Returns the modal's footer element.
+     */
+    getModalFooterEl() {
+        this.#checkModalElement();
+        return this.#modalElement.querySelector('.sky-modal-footer');
+    }
+    /**
+     * Returns the modal's header element.
+     */
+    getModalHeaderEl() {
+        this.#checkModalElement();
+        return this.#modalElement.querySelector('.sky-modal-header');
+    }
+    #checkModalElement() {
+        if (!document.contains(this.#modalElement)) {
+            throw new Error('Modal element no longer exists. Was the modal closed?');
+        }
+    }
+    #getModalDialogElement() {
+        this.#checkModalElement();
+        // We can always know that the dialog element will exist if the modal is open and exists.
+        return this.#modalElement.querySelector('.sky-modal-dialog');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal-fixture.js","sourceRoot":"","sources":["../../../../../../libs/components/modals/testing/src/modal-fixture.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentFixture } from '@angular/core/testing';\n\n/**\n * Allows interaction with a SKY UX modal component.\n * @internal\n */\nexport class SkyModalFixture {\n  #modalElement: HTMLElement;\n\n  #fixture: ComponentFixture<unknown>;\n\n  constructor(fixture: ComponentFixture<unknown>, skyTestId: string) {\n    this.#fixture = fixture;\n    const modalElement = document.querySelector(\n      'sky-modal[data-sky-id=\"' + skyTestId + '\"]'\n    ) as HTMLElement;\n\n    if (!modalElement) {\n      throw new Error(\n        `No element was found with a \\`data-sky-id\\` value of \"${skyTestId}\".`\n      );\n    }\n\n    this.#modalElement = modalElement;\n  }\n\n  /**\n   * The modal component's ARIA describedby attribute.\n   */\n  public get ariaDescribedBy(): string | undefined {\n    const modalDialogElement = this.#getModalDialogElement();\n    /* Non-null assertion as our component has a default for if the user does not provide this attribute or if they provide \"undefined\" */\n    const describedByAttribute =\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      modalDialogElement.getAttribute('aria-describedby')!;\n    return describedByAttribute;\n  }\n\n  /**\n   * The modal component's ARIA labelledby attribute.\n   */\n  public get ariaLabelledBy(): string | undefined {\n    const modalDialogElement = this.#getModalDialogElement();\n    /* Non-null assertion as our component has a default for if the user does not provide this attribute or if they provide \"undefined\" */\n    const labelledByAttribute =\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      modalDialogElement.getAttribute('aria-labelledby')!;\n\n    return labelledByAttribute;\n  }\n\n  /**\n   * The modal component's role attribute.\n   */\n  public get ariaRole(): string | undefined {\n    const modalDialogElement = this.#getModalDialogElement();\n    /* Non-null assertion as our component has a default for if the user does not provide this attribute or if they provide \"undefined\" */\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const roleAttribute = modalDialogElement.getAttribute('role')!;\n    return roleAttribute;\n  }\n\n  /**\n   * Whether or not the modal is a full page modal.\n   */\n  public get fullPage(): boolean {\n    const modalDivElement = this.getModalDiv();\n    return modalDivElement.classList.contains('sky-modal-full-page');\n  }\n\n  /**\n   * The size of the modal.\n   */\n  public get size(): string | undefined {\n    const modalDivElement = this.getModalDiv();\n    const possibleSizes = ['small', 'medium', 'large'];\n\n    for (const size of possibleSizes) {\n      if (modalDivElement.classList.contains('sky-modal-' + size)) {\n        return size;\n      }\n    }\n\n    return;\n  }\n\n  /**\n   * Whether or not the modal is set up for tiled content.\n   */\n  public get tiledBody(): boolean {\n    const modalDivElement = this.getModalDiv();\n    return modalDivElement.classList.contains('sky-modal-tiled');\n  }\n\n  /**\n   * Clicks the modal header's \"close\" button.\n   */\n  public clickHeaderCloseButton(): void {\n    this.#checkModalElement();\n    const closeButton: HTMLElement | null = this.#modalElement.querySelector(\n      '.sky-modal .sky-modal-btn-close'\n    );\n\n    if (\n      closeButton &&\n      window.getComputedStyle(closeButton).display !== 'none'\n    ) {\n      closeButton.click();\n      this.#fixture.detectChanges();\n    } else {\n      throw new Error(`No header close button exists.`);\n    }\n  }\n\n  /**\n   * Clicks the modal header's \"help\" button.\n   */\n  public clickHelpButton(): void {\n    this.#checkModalElement();\n    const helpButton: HTMLElement | null = this.#modalElement.querySelector(\n      '.sky-modal .sky-modal-header-buttons button[name=\"help-button\"]'\n    );\n\n    if (helpButton && window.getComputedStyle(helpButton).display !== 'none') {\n      helpButton.click();\n      this.#fixture.detectChanges();\n    } else {\n      throw new Error(`No help button exists.`);\n    }\n  }\n\n  /**\n   * Returns the main modal element.\n   */\n  public getModalDiv(): any {\n    this.#checkModalElement();\n    return this.#modalElement.querySelector('.sky-modal');\n  }\n\n  /**\n   * Returns the modal's content element.\n   */\n  public getModalContentEl(): any {\n    this.#checkModalElement();\n    return this.#modalElement.querySelector('.sky-modal-content');\n  }\n\n  /**\n   * Returns the modal's footer element.\n   */\n  public getModalFooterEl(): any {\n    this.#checkModalElement();\n    return this.#modalElement.querySelector('.sky-modal-footer');\n  }\n\n  /**\n   * Returns the modal's header element.\n   */\n  public getModalHeaderEl(): any {\n    this.#checkModalElement();\n    return this.#modalElement.querySelector('.sky-modal-header');\n  }\n\n  #checkModalElement(): void {\n    if (!document.contains(this.#modalElement)) {\n      throw new Error('Modal element no longer exists. Was the modal closed?');\n    }\n  }\n\n  #getModalDialogElement(): HTMLElement {\n    this.#checkModalElement();\n    // We can always know that the dialog element will exist if the modal is open and exists.\n    return this.#modalElement.querySelector('.sky-modal-dialog')!;\n  }\n}\n"]}