@skyux/indicators 8.7.0 → 9.0.0-alpha.0

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

@@ -0,0 +1,159 @@
+import { Injectable, inject } from '@angular/core';
+import { SkyAppWindowRef, SkyDynamicComponentLocation, SkyDynamicComponentService, } from '@skyux/core';
+import { defer as observableDefer } from 'rxjs';
+import { finalize } from 'rxjs/operators';
+import { SkyWaitPageComponent } from './wait-page.component';
+import * as i0 from "@angular/core";
+let waitComponent;
+let waitComponentRef;
+let pageWaitBlockingCount = 0;
+let pageWaitNonBlockingCount = 0;
+// Need to add the following to classes which contain static methods.
+// See: https://github.com/ng-packagr/ng-packagr/issues/641
+// @dynamic
+export class SkyWaitService {
+    #windowSvc = inject(SkyAppWindowRef);
+    #dynamicComponentService = inject(SkyDynamicComponentService);
+    /**
+     * Starts a blocking page wait on the page.
+     */
+    beginBlockingPageWait() {
+        this.#beginPageWait(true);
+    }
+    /**
+     * Starts a non-blocking page wait on the page.
+     */
+    beginNonBlockingPageWait() {
+        this.#beginPageWait(false);
+    }
+    /**
+     * Ends a blocking page wait on the page. Blocking page wait indication
+     * is removed when all running blocking page waits are ended.
+     */
+    endBlockingPageWait() {
+        this.#endPageWait(true);
+    }
+    /**
+     * Ends a non-blocking page wait on the page. Non-blocking page wait indication
+     * is removed when all running non-blocking page waits are ended.
+     */
+    endNonBlockingPageWait() {
+        this.#endPageWait(false);
+    }
+    /**
+     * Clears all blocking and non-blocking page waits on the page.
+     */
+    clearAllPageWaits() {
+        this.#clearPageWait(true);
+        this.#clearPageWait(false);
+    }
+    /**
+     * @internal
+     */
+    dispose() {
+        if (waitComponent) {
+            waitComponent = undefined;
+            pageWaitBlockingCount = 0;
+            pageWaitNonBlockingCount = 0;
+            this.#dynamicComponentService.removeComponent(waitComponentRef);
+        }
+    }
+    /**
+     * Launches a page wait and automatically stops when the specific asynchronous event completes.
+     */
+    blockingWrap(observable) {
+        return observableDefer(() => {
+            this.beginBlockingPageWait();
+            return observable.pipe(finalize(() => this.endBlockingPageWait()));
+        });
+    }
+    /**
+     * Launches a non-blocking page wait and automatically stops when the specific
+     * asynchronous event completes.
+     */
+    nonBlockingWrap(observable) {
+        return observableDefer(() => {
+            this.beginNonBlockingPageWait();
+            return observable.pipe(finalize(() => this.endNonBlockingPageWait()));
+        });
+    }
+    #setWaitComponentProperties(isBlocking) {
+        if (waitComponent) {
+            if (isBlocking) {
+                waitComponent.hasBlockingWait = true;
+                pageWaitBlockingCount++;
+            }
+            else {
+                waitComponent.hasNonBlockingWait = true;
+                pageWaitNonBlockingCount++;
+            }
+        }
+    }
+    #beginPageWait(isBlocking) {
+        if (!waitComponent) {
+            /*
+                Dynamic component creation needs to be done in a timeout to prevent ApplicationRef from
+                crashing when wait service is called in Angular lifecycle functions.
+            */
+            this.#windowSvc.nativeWindow.setTimeout(() => {
+                // Ensuring here that we recheck this after the setTimeout is over so that we don't clash
+                // with any other waits that are created.
+                if (!waitComponent) {
+                    waitComponentRef = this.#dynamicComponentService.createComponent(SkyWaitPageComponent, { location: SkyDynamicComponentLocation.BodyBottom });
+                    waitComponent = waitComponentRef.instance;
+                }
+                this.#setWaitComponentProperties(isBlocking);
+            });
+        }
+        else {
+            this.#setWaitComponentProperties(isBlocking);
+        }
+    }
+    #endPageWait(isBlocking) {
+        /*
+            Needs to yield so that wait creation can finish
+            before it is dismissed in the event of a race.
+        */
+        this.#windowSvc.nativeWindow.setTimeout(() => {
+            if (waitComponent) {
+                if (isBlocking) {
+                    if (pageWaitBlockingCount > 0) {
+                        pageWaitBlockingCount--;
+                    }
+                    if (pageWaitBlockingCount < 1) {
+                        waitComponent.hasBlockingWait = false;
+                    }
+                }
+                else {
+                    if (pageWaitNonBlockingCount > 0) {
+                        pageWaitNonBlockingCount--;
+                    }
+                    if (pageWaitNonBlockingCount < 1) {
+                        waitComponent.hasNonBlockingWait = false;
+                    }
+                }
+            }
+        });
+    }
+    #clearPageWait(isBlocking) {
+        if (waitComponent) {
+            if (isBlocking) {
+                pageWaitBlockingCount = 0;
+                waitComponent.hasBlockingWait = false;
+            }
+            else {
+                pageWaitNonBlockingCount = 0;
+                waitComponent.hasNonBlockingWait = false;
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyWaitService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyWaitService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.7", ngImport: i0, type: SkyWaitService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wait.service.js","sourceRoot":"","sources":["../../../../../../../../libs/components/indicators/src/lib/modules/wait/wait.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentRef, Injectable, inject } from '@angular/core';\nimport {\n  SkyAppWindowRef,\n  SkyDynamicComponentLocation,\n  SkyDynamicComponentService,\n} from '@skyux/core';\n\nimport { Observable, defer as observableDefer } from 'rxjs';\nimport { finalize } from 'rxjs/operators';\n\nimport { SkyWaitPageComponent } from './wait-page.component';\n\nlet waitComponent: SkyWaitPageComponent | undefined;\nlet waitComponentRef: ComponentRef<SkyWaitPageComponent> | undefined;\nlet pageWaitBlockingCount = 0;\nlet pageWaitNonBlockingCount = 0;\n\n// Need to add the following to classes which contain static methods.\n// See: https://github.com/ng-packagr/ng-packagr/issues/641\n// @dynamic\n@Injectable({\n  providedIn: 'root',\n})\nexport class SkyWaitService {\n  #windowSvc = inject(SkyAppWindowRef);\n  #dynamicComponentService = inject(SkyDynamicComponentService);\n\n  /**\n   * Starts a blocking page wait on the page.\n   */\n  public beginBlockingPageWait(): void {\n    this.#beginPageWait(true);\n  }\n\n  /**\n   * Starts a non-blocking page wait on the page.\n   */\n  public beginNonBlockingPageWait(): void {\n    this.#beginPageWait(false);\n  }\n\n  /**\n   * Ends a blocking page wait on the page. Blocking page wait indication\n   * is removed when all running blocking page waits are ended.\n   */\n  public endBlockingPageWait(): void {\n    this.#endPageWait(true);\n  }\n\n  /**\n   * Ends a non-blocking page wait on the page. Non-blocking page wait indication\n   * is removed when all running non-blocking page waits are ended.\n   */\n  public endNonBlockingPageWait(): void {\n    this.#endPageWait(false);\n  }\n\n  /**\n   * Clears all blocking and non-blocking page waits on the page.\n   */\n  public clearAllPageWaits(): void {\n    this.#clearPageWait(true);\n    this.#clearPageWait(false);\n  }\n\n  /**\n   * @internal\n   */\n  public dispose(): void {\n    if (waitComponent) {\n      waitComponent = undefined;\n      pageWaitBlockingCount = 0;\n      pageWaitNonBlockingCount = 0;\n      this.#dynamicComponentService.removeComponent(waitComponentRef);\n    }\n  }\n\n  /**\n   * Launches a page wait and automatically stops when the specific asynchronous event completes.\n   */\n  public blockingWrap<T>(observable: Observable<T>): Observable<T> {\n    return observableDefer(() => {\n      this.beginBlockingPageWait();\n      return observable.pipe(finalize(() => this.endBlockingPageWait()));\n    });\n  }\n\n  /**\n   * Launches a non-blocking page wait and automatically stops when the specific\n   * asynchronous event completes.\n   */\n  public nonBlockingWrap<T>(observable: Observable<T>): Observable<T> {\n    return observableDefer(() => {\n      this.beginNonBlockingPageWait();\n      return observable.pipe(finalize(() => this.endNonBlockingPageWait()));\n    });\n  }\n\n  #setWaitComponentProperties(isBlocking: boolean): void {\n    if (waitComponent) {\n      if (isBlocking) {\n        waitComponent.hasBlockingWait = true;\n        pageWaitBlockingCount++;\n      } else {\n        waitComponent.hasNonBlockingWait = true;\n        pageWaitNonBlockingCount++;\n      }\n    }\n  }\n\n  #beginPageWait(isBlocking: boolean): void {\n    if (!waitComponent) {\n      /*\n          Dynamic component creation needs to be done in a timeout to prevent ApplicationRef from\n          crashing when wait service is called in Angular lifecycle functions.\n      */\n      this.#windowSvc.nativeWindow.setTimeout(() => {\n        // Ensuring here that we recheck this after the setTimeout is over so that we don't clash\n        // with any other waits that are created.\n        if (!waitComponent) {\n          waitComponentRef = this.#dynamicComponentService.createComponent(\n            SkyWaitPageComponent,\n            { location: SkyDynamicComponentLocation.BodyBottom }\n          );\n          waitComponent = waitComponentRef.instance;\n        }\n\n        this.#setWaitComponentProperties(isBlocking);\n      });\n    } else {\n      this.#setWaitComponentProperties(isBlocking);\n    }\n  }\n\n  #endPageWait(isBlocking: boolean): void {\n    /*\n        Needs to yield so that wait creation can finish\n        before it is dismissed in the event of a race.\n    */\n    this.#windowSvc.nativeWindow.setTimeout(() => {\n      if (waitComponent) {\n        if (isBlocking) {\n          if (pageWaitBlockingCount > 0) {\n            pageWaitBlockingCount--;\n          }\n\n          if (pageWaitBlockingCount < 1) {\n            waitComponent.hasBlockingWait = false;\n          }\n        } else {\n          if (pageWaitNonBlockingCount > 0) {\n            pageWaitNonBlockingCount--;\n          }\n\n          if (pageWaitNonBlockingCount < 1) {\n            waitComponent.hasNonBlockingWait = false;\n          }\n        }\n      }\n    });\n  }\n\n  #clearPageWait(isBlocking: boolean): void {\n    if (waitComponent) {\n      if (isBlocking) {\n        pageWaitBlockingCount = 0;\n        waitComponent.hasBlockingWait = false;\n      } else {\n        pageWaitNonBlockingCount = 0;\n        waitComponent.hasNonBlockingWait = false;\n      }\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,112 @@
+import { SkyComponentHarness } from '@skyux/core/testing';
+/**
+ * Harness for interacting with an alert component in tests.
+ */
+export class SkyAlertHarness extends SkyComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-alert'; }
+    #getAlert = this.locatorFor('.sky-alert');
+    #getContent = this.locatorFor('.sky-alert-content');
+    #getCloseButton = this.locatorFor('.sky-alert-close');
+    #getScreenReaderTextEl = this.locatorForOptional('.sky-screen-reader-only');
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyAlertHarness` that meets certain criteria.
+     */
+    static with(filters) {
+        return SkyAlertHarness.getDataSkyIdPredicate(filters);
+    }
+    /**
+     * Gets the current alert type.
+     */
+    async getAlertType() {
+        const alert = await this.#getAlert();
+        if (await alert.hasClass('sky-alert-danger')) {
+            return 'danger';
+        }
+        if (await alert.hasClass('sky-alert-info')) {
+            return 'info';
+        }
+        if (await alert.hasClass('sky-alert-success')) {
+            return 'success';
+        }
+        return 'warning';
+    }
+    /**
+     * Gets the current alert text.
+     */
+    async getText() {
+        return await (await this.#getContent()).text();
+    }
+    /**
+     * Closes the alert.
+     */
+    async close() {
+        if (!(await this.isCloseable())) {
+            throw new Error('The alert is not closeable.');
+        }
+        (await this.#getCloseButton()).click();
+    }
+    /**
+     * Whether the user closed the alert.
+     */
+    async isClosed() {
+        const alert = await this.#getAlert();
+        return await alert.getProperty('hidden');
+    }
+    /**
+     * Whether the user can close the alert.
+     */
+    async isCloseable() {
+        const closeBtn = await this.#getCloseButton();
+        return !(await closeBtn.getProperty('hidden'));
+    }
+    /**
+     * Gets the `descriptionType` of the label component.
+     */
+    async getDescriptionType() {
+        const srEl = await this.#getScreenReaderTextEl();
+        if (!srEl) {
+            return 'none';
+        }
+        const srText = await srEl.text();
+        switch (srText) {
+            case 'Attention:':
+                return 'attention';
+            case 'Caution:':
+                return 'caution';
+            case 'Completed:':
+                return 'completed';
+            case 'Danger:':
+                return 'danger';
+            case 'Error:':
+                return 'error';
+            case 'Important information:':
+                return 'important-info';
+            case 'Important warning:':
+                return 'important-warning';
+            case 'Success:':
+                return 'success';
+            case 'Warning:':
+                return 'warning';
+            default:
+                return 'custom';
+        }
+    }
+    /**
+     * Gets the custom text used for the screen reader description of the label component icon.
+     */
+    async getCustomDescription() {
+        const descriptionType = await this.getDescriptionType();
+        if (descriptionType === 'custom') {
+            const srEl = await this.#getScreenReaderTextEl();
+            if (srEl) {
+                return await srEl.text();
+            }
+        }
+        return '';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alert-harness.js","sourceRoot":"","sources":["../../../../../../../libs/components/indicators/testing/src/alert/alert-harness.ts"],"names":[],"mappings":"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","sourcesContent":["import { HarnessPredicate } from '@angular/cdk/testing';\nimport { SkyComponentHarness } from '@skyux/core/testing';\nimport type {\n  SkyIndicatorDescriptionType,\n  SkyIndicatorIconType,\n} from '@skyux/indicators';\n\nimport { SkyAlertHarnessFilters } from './alert-harness-filters';\n\n/**\n * Harness for interacting with an alert component in tests.\n */\nexport class SkyAlertHarness extends SkyComponentHarness {\n  /**\n   * @internal\n   */\n  public static hostSelector = 'sky-alert';\n\n  #getAlert = this.locatorFor('.sky-alert');\n  #getContent = this.locatorFor('.sky-alert-content');\n  #getCloseButton = this.locatorFor('.sky-alert-close');\n  #getScreenReaderTextEl = this.locatorForOptional('.sky-screen-reader-only');\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a\n   * `SkyAlertHarness` that meets certain criteria.\n   */\n  public static with(\n    filters: SkyAlertHarnessFilters\n  ): HarnessPredicate<SkyAlertHarness> {\n    return SkyAlertHarness.getDataSkyIdPredicate(filters);\n  }\n\n  /**\n   * Gets the current alert type.\n   */\n  public async getAlertType(): Promise<SkyIndicatorIconType | undefined> {\n    const alert = await this.#getAlert();\n\n    if (await alert.hasClass('sky-alert-danger')) {\n      return 'danger';\n    }\n\n    if (await alert.hasClass('sky-alert-info')) {\n      return 'info';\n    }\n\n    if (await alert.hasClass('sky-alert-success')) {\n      return 'success';\n    }\n\n    return 'warning';\n  }\n\n  /**\n   * Gets the current alert text.\n   */\n  public async getText(): Promise<string> {\n    return await (await this.#getContent()).text();\n  }\n\n  /**\n   * Closes the alert.\n   */\n  public async close(): Promise<void> {\n    if (!(await this.isCloseable())) {\n      throw new Error('The alert is not closeable.');\n    }\n\n    (await this.#getCloseButton()).click();\n  }\n\n  /**\n   * Whether the user closed the alert.\n   */\n  public async isClosed(): Promise<boolean> {\n    const alert = await this.#getAlert();\n\n    return await alert.getProperty('hidden');\n  }\n\n  /**\n   * Whether the user can close the alert.\n   */\n  public async isCloseable(): Promise<boolean> {\n    const closeBtn = await this.#getCloseButton();\n    return !(await closeBtn.getProperty('hidden'));\n  }\n\n  /**\n   * Gets the `descriptionType` of the label component.\n   */\n  public async getDescriptionType(): Promise<SkyIndicatorDescriptionType> {\n    const srEl = await this.#getScreenReaderTextEl();\n\n    if (!srEl) {\n      return 'none';\n    }\n\n    const srText = await srEl.text();\n\n    switch (srText) {\n      case 'Attention:':\n        return 'attention';\n      case 'Caution:':\n        return 'caution';\n      case 'Completed:':\n        return 'completed';\n      case 'Danger:':\n        return 'danger';\n      case 'Error:':\n        return 'error';\n      case 'Important information:':\n        return 'important-info';\n      case 'Important warning:':\n        return 'important-warning';\n      case 'Success:':\n        return 'success';\n      case 'Warning:':\n        return 'warning';\n      default:\n        return 'custom';\n    }\n  }\n\n  /**\n   * Gets the custom text used for the screen reader description of the label component icon.\n   */\n  public async getCustomDescription(): Promise<string> {\n    const descriptionType = await this.getDescriptionType();\n\n    if (descriptionType === 'custom') {\n      const srEl = await this.#getScreenReaderTextEl();\n\n      if (srEl) {\n        return await srEl.text();\n      }\n    }\n\n    return '';\n  }\n}\n"]}

package/esm2022/testing/alert-fixture.mjs

@@ -0,0 +1,70 @@
+import { By } from '@angular/platform-browser';
+import { SkyAppTestUtility } from '@skyux-sdk/testing';
+/**
+ * Allows interaction with a SKY UX alert component.
+ * @deprecated Use `SkyAlertHarness` instead.
+ * @internal
+ */
+export class SkyAlertFixture {
+    /**
+     * The alert's current text.
+     */
+    get text() {
+        return SkyAppTestUtility.getText(this.#debugEl);
+    }
+    /**
+     * A flag indicating whether the alert can be closed.
+     */
+    get closeable() {
+        const closeBtnEl = this.#getCloseBtnEl();
+        return SkyAppTestUtility.isVisible(closeBtnEl);
+    }
+    /**
+     * Returns a flag indicating whether the alert is closed.
+     */
+    get closed() {
+        return !SkyAppTestUtility.isVisible(this.#getAlertEl());
+    }
+    /**
+     * The alert's current type.
+     */
+    get alertType() {
+        const clsList = this.#getAlertEl().nativeElement.classList;
+        if (clsList.contains('sky-alert-danger')) {
+            return 'danger';
+        }
+        if (clsList.contains('sky-alert-info')) {
+            return 'info';
+        }
+        if (clsList.contains('sky-alert-success')) {
+            return 'success';
+        }
+        if (clsList.contains('sky-alert-warning')) {
+            return 'warning';
+        }
+        return undefined;
+    }
+    #debugEl;
+    constructor(fixture, skyTestId) {
+        this.#debugEl = SkyAppTestUtility.getDebugElementByTestId(fixture, skyTestId, 'sky-alert');
+    }
+    /**
+     * Closes the alert.  If the alert is not closeable, an error is thrown.
+     */
+    close() {
+        if (this.closeable) {
+            const closeBtnEl = this.#getCloseBtnEl();
+            closeBtnEl.triggerEventHandler('click', {});
+        }
+        else {
+            throw new Error('The alert is not closeable.');
+        }
+    }
+    #getAlertEl() {
+        return this.#debugEl.query(By.css('.sky-alert'));
+    }
+    #getCloseBtnEl() {
+        return this.#debugEl.query(By.css('.sky-alert-close'));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,38 @@
+import { SkyComponentHarness } from '@skyux/core/testing';
+/**
+ * Harness for interacting with a chevron component in tests.
+ */
+export class SkyChevronHarness extends SkyComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-chevron'; }
+    #getButton = this.locatorFor('button.sky-chevron');
+    /**
+     * Gets the chevron direction.
+     */
+    async getDirection() {
+        return (await (await this.#getButton()).hasClass('sky-chevron-up'))
+            ? 'up'
+            : 'down';
+    }
+    /**
+     * Whether the chevron is disabled.
+     */
+    async isDisabled() {
+        const disabled = await (await this.#getButton()).getAttribute('disabled');
+        return disabled !== null;
+    }
+    /**
+     * Toggles the chevron.
+     */
+    async toggle() {
+        if (await this.isDisabled()) {
+            throw new Error('Could not toggle the checkbox because it is disabled.');
+        }
+        else {
+            await (await this.#getButton()).click();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/help-inline/help-inline-harness.mjs

@@ -0,0 +1,25 @@
+import { SkyComponentHarness } from '@skyux/core/testing';
+/**
+ * Harness for interacting with a help inline component in tests.
+ */
+export class SkyHelpInlineHarness extends SkyComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-help-inline'; }
+    #getInlineHelpButton = this.locatorFor('.sky-help-inline');
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyInlineHelpHarness` that meets certain criteria
+     */
+    static with(filters) {
+        return SkyHelpInlineHarness.getDataSkyIdPredicate(filters);
+    }
+    /**
+     * Clicks the help inline icon button
+     */
+    async click() {
+        await (await this.#getInlineHelpButton()).click();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,86 @@
+import { SkyComponentHarness } from '@skyux/core/testing';
+/**
+ * Harness for interacting with an icon component in tests.
+ */
+export class SkyIconHarness extends SkyComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-icon'; }
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyIconHarness` that meets certain criteria.
+     */
+    static with(filters) {
+        return SkyIconHarness.getDataSkyIdPredicate(filters);
+    }
+    /**
+     * Gets the icon name.
+     */
+    async getIconName() {
+        // No need to check for null here since #getIcon() will throw an error when
+        // icon name is null.
+        return (await this.#getSpecifiedIconInfo()).icon;
+    }
+    /**
+     * Gets the icon size.
+     */
+    async getIconSize() {
+        const iconClasses = await this.#getIconClasses();
+        for (const iconClass of iconClasses) {
+            // match a class name that starts with `fa-` and follows with `lg`, `2x`, `3x`, `4x`, `5x`
+            if (/^fa-(?=2xs|lg|[2-5]+x)/.test(iconClass)) {
+                return iconClass.replace('fa-', '');
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Gets the icon type.
+     */
+    async getIconType() {
+        return (await this.#getSpecifiedIconInfo()).iconType || 'fa';
+    }
+    /**
+     * Gets if the icon is a variant.
+     */
+    async getVariant() {
+        const iconInfo = await this.#getSpecifiedIconInfo();
+        if (iconInfo.iconType === 'skyux') {
+            return iconInfo.variant || 'line';
+        }
+        throw new Error('Variant cannot be determined because variants are only assigned to icons with type `skyux`.');
+    }
+    /**
+     * Whether the icon has fixed width.
+     */
+    async isFixedWidth() {
+        const icon = await this.#getIcon();
+        return icon.hasClass(`fa-fw`);
+    }
+    async #getIcon() {
+        const icon = await this.locatorForOptional('.sky-icon')();
+        if (icon) {
+            return icon;
+        }
+        throw new Error('Icon could not be rendered.');
+    }
+    async #getIconClasses() {
+        const iconClasses = await (await this.#getIcon()).getProperty('classList');
+        return Array.from(iconClasses);
+    }
+    async #getSpecifiedIconInfo() {
+        // Since SKY UX icons have Font Awesome alternatives that may be used
+        // in default theme instead of the icon specified by the consumer, we
+        // need to get the specified values using data- attributes added by
+        // the icon component. This conflicts with the usual pattern of giving
+        // the effective state of the component but is necessary in this case.
+        const icon = await this.#getIcon();
+        return {
+            icon: await icon.getAttribute('data-sky-icon'),
+            iconType: await icon.getAttribute('data-sky-icon-type'),
+            variant: await icon.getAttribute('data-sky-icon-variant'),
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/key-info/key-info-harness.mjs

@@ -0,0 +1,43 @@
+import { SkyComponentHarness } from '@skyux/core/testing';
+import { SkyKeyInfoLabelHarness } from './key-info-label-harness';
+import { SkyKeyInfoValueHarness } from './key-info-value-harness';
+/**
+ * Harness for interacting with a key info component in tests.
+ */
+export class SkyKeyInfoHarness extends SkyComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-key-info'; }
+    #getLabel = this.locatorFor(SkyKeyInfoLabelHarness);
+    #getValue = this.locatorFor(SkyKeyInfoValueHarness);
+    #getWrapper = this.locatorFor('.sky-key-info');
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyKeyInfoHarness` that meets certain criteria.
+     */
+    static with(filters) {
+        return SkyKeyInfoHarness.getDataSkyIdPredicate(filters);
+    }
+    /**
+     * Gets the current value text.
+     */
+    async getValueText() {
+        return await (await this.#getValue()).getText();
+    }
+    /**
+     * Gets the current label text.
+     */
+    async getLabelText() {
+        return await (await this.#getLabel()).getText();
+    }
+    /**
+     * Gets the current layout type.
+     */
+    async getLayout() {
+        return (await (await this.#getWrapper()).hasClass('sky-key-info-horizontal'))
+            ? 'horizontal'
+            : 'vertical';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/testing/key-info/key-info-label-harness.mjs

@@ -4,6 +4,10 @@ import { SkyComponentHarness } from '@skyux/core/testing';
  * @internal
  */
 export class SkyKeyInfoLabelHarness extends SkyComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-key-info-label'; }
     /**
      * Gets the text value of the component content.
      */
@@ -11,8 +15,4 @@ export class SkyKeyInfoLabelHarness extends SkyComponentHarness {
         return (await this.host()).text();
     }
 }
-/**
- * @internal
- */
-SkyKeyInfoLabelHarness.hostSelector = 'sky-key-info-label';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5LWluZm8tbGFiZWwtaGFybmVzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9pbmRpY2F0b3JzL3Rlc3Rpbmcvc3JjL2tleS1pbmZvL2tleS1pbmZvLWxhYmVsLWhhcm5lc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFMUQ7OztHQUdHO0FBQ0gsTUFBTSxPQUFPLHNCQUF1QixTQUFRLG1CQUFtQjtJQU03RDs7T0FFRztJQUNJLEtBQUssQ0FBQyxPQUFPO1FBQ2xCLE9BQU8sQ0FBQyxNQUFNLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3BDLENBQUM7O0FBVkQ7O0dBRUc7QUFDVyxtQ0FBWSxHQUFHLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2t5Q29tcG9uZW50SGFybmVzcyB9IGZyb20gJ0Bza3l1eC9jb3JlL3Rlc3RpbmcnO1xuXG4vKipcbiAqIEhhcm5lc3MgZm9yIGludGVyYWN0aW5nIHdpdGggYSBrZXkgaW5mbyBsYWJlbCBjb21wb25lbnQgaW4gdGVzdHMuXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGNsYXNzIFNreUtleUluZm9MYWJlbEhhcm5lc3MgZXh0ZW5kcyBTa3lDb21wb25lbnRIYXJuZXNzIHtcbiAgLyoqXG4gICAqIEBpbnRlcm5hbFxuICAgKi9cbiAgcHVibGljIHN0YXRpYyBob3N0U2VsZWN0b3IgPSAnc2t5LWtleS1pbmZvLWxhYmVsJztcblxuICAvKipcbiAgICogR2V0cyB0aGUgdGV4dCB2YWx1ZSBvZiB0aGUgY29tcG9uZW50IGNvbnRlbnQuXG4gICAqL1xuICBwdWJsaWMgYXN5bmMgZ2V0VGV4dCgpOiBQcm9taXNlPHN0cmluZz4ge1xuICAgIHJldHVybiAoYXdhaXQgdGhpcy5ob3N0KCkpLnRleHQoKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5LWluZm8tbGFiZWwtaGFybmVzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9pbmRpY2F0b3JzL3Rlc3Rpbmcvc3JjL2tleS1pbmZvL2tleS1pbmZvLWxhYmVsLWhhcm5lc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFMUQ7OztHQUdHO0FBQ0gsTUFBTSxPQUFPLHNCQUF1QixTQUFRLG1CQUFtQjtJQUM3RDs7T0FFRzthQUNXLGlCQUFZLEdBQUcsb0JBQW9CLENBQUM7SUFFbEQ7O09BRUc7SUFDSSxLQUFLLENBQUMsT0FBTztRQUNsQixPQUFPLENBQUMsTUFBTSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUNwQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2t5Q29tcG9uZW50SGFybmVzcyB9IGZyb20gJ0Bza3l1eC9jb3JlL3Rlc3RpbmcnO1xuXG4vKipcbiAqIEhhcm5lc3MgZm9yIGludGVyYWN0aW5nIHdpdGggYSBrZXkgaW5mbyBsYWJlbCBjb21wb25lbnQgaW4gdGVzdHMuXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGNsYXNzIFNreUtleUluZm9MYWJlbEhhcm5lc3MgZXh0ZW5kcyBTa3lDb21wb25lbnRIYXJuZXNzIHtcbiAgLyoqXG4gICAqIEBpbnRlcm5hbFxuICAgKi9cbiAgcHVibGljIHN0YXRpYyBob3N0U2VsZWN0b3IgPSAnc2t5LWtleS1pbmZvLWxhYmVsJztcblxuICAvKipcbiAgICogR2V0cyB0aGUgdGV4dCB2YWx1ZSBvZiB0aGUgY29tcG9uZW50IGNvbnRlbnQuXG4gICAqL1xuICBwdWJsaWMgYXN5bmMgZ2V0VGV4dCgpOiBQcm9taXNlPHN0cmluZz4ge1xuICAgIHJldHVybiAoYXdhaXQgdGhpcy5ob3N0KCkpLnRleHQoKTtcbiAgfVxufVxuIl19