@skyux/forms 11.22.0 → 11.24.0

package/esm2022/testing/modules/checkbox/checkbox-group-harness.mjs

@@ -0,0 +1,158 @@
+import { SkyComponentHarness } from '@skyux/core/testing';
+import { SkyHelpInlineHarness } from '@skyux/help-inline/testing';
+import { SkyFormErrorsHarness } from '../form-error/form-errors-harness';
+import { SkyCheckboxHarness } from './checkbox-harness';
+/**
+ * Harness for interacting with a checkbox group component in tests.
+ */
+export class SkyCheckboxGroupHarness extends SkyComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-checkbox-group'; }
+    #getCheckboxes = this.locatorForAll(SkyCheckboxHarness);
+    #getHeading = this.locatorFor('.sky-checkbox-group-heading');
+    #getHeadingWrapper = this.locatorFor('.sky-checkbox-group-legend');
+    #getHintText = this.locatorForOptional('.sky-checkbox-group-hint-text');
+    #getLegendDefault = this.locatorForOptional('legend .sky-checkbox-group-heading-text');
+    #getLegendH3 = this.locatorForOptional('legend h3');
+    #getLegendH4 = this.locatorForOptional('legend h4');
+    #getLegendH5 = this.locatorForOptional('legend h5');
+    #getLegendHeading = this.locatorFor('legend h3,h4,h5,.sky-checkbox-group-heading-text');
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyCheckboxGroupHarness` that meets certain criteria.
+     */
+    static with(filters) {
+        return SkyCheckboxGroupHarness.getDataSkyIdPredicate(filters);
+    }
+    /**
+     * Clicks the help inline button.
+     */
+    async clickHelpInline() {
+        await (await this.#getHelpInline()).click();
+    }
+    /**
+     * Gets an array of harnesses for the checkboxes in the checkbox group.
+     */
+    async getCheckboxes() {
+        return await this.#getCheckboxes();
+    }
+    /**
+     * Gets the help popover content.
+     */
+    async getHelpPopoverContent() {
+        const content = await (await this.#getHelpInline()).getPopoverContent();
+        return content;
+    }
+    /**
+     * Gets the help popover title.
+     */
+    async getHelpPopoverTitle() {
+        return await (await this.#getHelpInline()).getPopoverTitle();
+    }
+    /**
+     * Gets the checkbox group's heading text. If `headingHidden` is true,
+     * the text will still be returned.
+     */
+    async getHeadingText() {
+        return await (await this.#getLegendHeading()).text();
+    }
+    /**
+     * Gets the checkbox group's hint text.
+     */
+    async getHintText() {
+        const hintText = await this.#getHintText();
+        return (await hintText?.text())?.trim() ?? '';
+    }
+    /**
+     * Whether the heading is hidden.
+     */
+    async getHeadingHidden() {
+        return await (await this.#getHeadingWrapper()).hasClass('sky-screen-reader-only');
+    }
+    /**
+     * The semantic heading level used for the checkbox group. Returns undefined if heading level is not set.
+     */
+    async getHeadingLevel() {
+        const heading = await this.#getLegendHeading();
+        const h3 = await heading.matchesSelector('h3');
+        const h4 = await heading.matchesSelector('h4');
+        const h5 = await heading.matchesSelector('h5');
+        if (h3) {
+            return 3;
+        }
+        else if (h4) {
+            return 4;
+        }
+        else if (h5) {
+            return 5;
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * The heading style used for the checkbox group.
+     */
+    async getHeadingStyle() {
+        const heading = await this.#getLegendHeading();
+        const isHeadingStyle3 = await heading.hasClass('sky-font-heading-3');
+        const isHeadingStyle4 = await heading.hasClass('sky-font-heading-4');
+        if (isHeadingStyle3) {
+            return 3;
+        }
+        else if (isHeadingStyle4) {
+            return 4;
+        }
+        else {
+            return 5;
+        }
+    }
+    /**
+     * Whether the checkbox group is required.
+     */
+    async getRequired() {
+        const heading = await this.#getHeading();
+        return await heading.hasClass('sky-control-label-required');
+    }
+    /**
+     * Whether the checkbox group is stacked.
+     */
+    async getStacked() {
+        const host = await this.host();
+        const heading = (await this.#getLegendH3()) ||
+            (await this.#getLegendH4()) ||
+            (await this.#getLegendH5());
+        const label = await this.#getLegendDefault();
+        return (((await host.hasClass('sky-form-field-stacked')) && !!label) ||
+            ((await host.hasClass('sky-field-group-stacked')) && !!heading));
+    }
+    /**
+     * Whether all the checkboxes in a required group are unchecked.
+     */
+    async hasRequiredError() {
+        return await (await this.#getFormErrors()).hasError('required');
+    }
+    /**
+     * Whether the checkbox group has errors.
+     */
+    async hasError(errorName) {
+        return await (await this.#getFormErrors()).hasError(errorName);
+    }
+    async #getFormErrors() {
+        return await this.locatorFor(SkyFormErrorsHarness.with({
+            dataSkyId: 'checkbox-group-form-errors',
+        }))();
+    }
+    async #getHelpInline() {
+        const harness = await this.locatorForOptional(SkyHelpInlineHarness.with({
+            ancestor: '.sky-checkbox-group > .sky-checkbox-group-legend',
+        }))();
+        if (harness) {
+            return harness;
+        }
+        throw Error('No help inline found.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkbox-group-harness.js","sourceRoot":"","sources":["../../../../../../../../libs/components/forms/testing/src/modules/checkbox/checkbox-group-harness.ts"],"names":[],"mappings":"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","sourcesContent":["import { HarnessPredicate } from '@angular/cdk/testing';\nimport { SkyComponentHarness } from '@skyux/core/testing';\nimport {\n  SkyCheckboxGroupHeadingLevel,\n  SkyCheckboxGroupHeadingStyle,\n} from '@skyux/forms';\nimport { SkyHelpInlineHarness } from '@skyux/help-inline/testing';\n\nimport { SkyFormErrorsHarness } from '../form-error/form-errors-harness';\n\nimport { SkyCheckboxGroupHarnessFilters } from './checkbox-group-harness-filters';\nimport { SkyCheckboxHarness } from './checkbox-harness';\n\n/**\n * Harness for interacting with a checkbox group component in tests.\n */\nexport class SkyCheckboxGroupHarness extends SkyComponentHarness {\n  /**\n   * @internal\n   */\n  public static hostSelector = 'sky-checkbox-group';\n\n  #getCheckboxes = this.locatorForAll(SkyCheckboxHarness);\n  #getHeading = this.locatorFor('.sky-checkbox-group-heading');\n  #getHeadingWrapper = this.locatorFor('.sky-checkbox-group-legend');\n  #getHintText = this.locatorForOptional('.sky-checkbox-group-hint-text');\n  #getLegendDefault = this.locatorForOptional(\n    'legend .sky-checkbox-group-heading-text',\n  );\n  #getLegendH3 = this.locatorForOptional('legend h3');\n  #getLegendH4 = this.locatorForOptional('legend h4');\n  #getLegendH5 = this.locatorForOptional('legend h5');\n  #getLegendHeading = this.locatorFor(\n    'legend h3,h4,h5,.sky-checkbox-group-heading-text',\n  );\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a\n   * `SkyCheckboxGroupHarness` that meets certain criteria.\n   */\n  public static with(\n    filters: SkyCheckboxGroupHarnessFilters,\n  ): HarnessPredicate<SkyCheckboxGroupHarness> {\n    return SkyCheckboxGroupHarness.getDataSkyIdPredicate(filters);\n  }\n\n  /**\n   * Clicks the help inline button.\n   */\n  public async clickHelpInline(): Promise<void> {\n    await (await this.#getHelpInline()).click();\n  }\n\n  /**\n   * Gets an array of harnesses for the checkboxes in the checkbox group.\n   */\n  public async getCheckboxes(): Promise<SkyCheckboxHarness[]> {\n    return await this.#getCheckboxes();\n  }\n\n  /**\n   * Gets the help popover content.\n   */\n  public async getHelpPopoverContent(): Promise<string | undefined> {\n    const content = await (await this.#getHelpInline()).getPopoverContent();\n\n    return content as string | undefined;\n  }\n\n  /**\n   * Gets the help popover title.\n   */\n  public async getHelpPopoverTitle(): Promise<string | undefined> {\n    return await (await this.#getHelpInline()).getPopoverTitle();\n  }\n\n  /**\n   * Gets the checkbox group's heading text. If `headingHidden` is true,\n   * the text will still be returned.\n   */\n  public async getHeadingText(): Promise<string | undefined> {\n    return await (await this.#getLegendHeading()).text();\n  }\n\n  /**\n   * Gets the checkbox group's hint text.\n   */\n  public async getHintText(): Promise<string> {\n    const hintText = await this.#getHintText();\n\n    return (await hintText?.text())?.trim() ?? '';\n  }\n\n  /**\n   * Whether the heading is hidden.\n   */\n  public async getHeadingHidden(): Promise<boolean> {\n    return await (\n      await this.#getHeadingWrapper()\n    ).hasClass('sky-screen-reader-only');\n  }\n\n  /**\n   * The semantic heading level used for the checkbox group. Returns undefined if heading level is not set.\n   */\n  public async getHeadingLevel(): Promise<\n    SkyCheckboxGroupHeadingLevel | undefined\n  > {\n    const heading = await this.#getLegendHeading();\n    const h3 = await heading.matchesSelector('h3');\n    const h4 = await heading.matchesSelector('h4');\n    const h5 = await heading.matchesSelector('h5');\n\n    if (h3) {\n      return 3;\n    } else if (h4) {\n      return 4;\n    } else if (h5) {\n      return 5;\n    } else {\n      return undefined;\n    }\n  }\n\n  /**\n   * The heading style used for the checkbox group.\n   */\n  public async getHeadingStyle(): Promise<SkyCheckboxGroupHeadingStyle> {\n    const heading = await this.#getLegendHeading();\n\n    const isHeadingStyle3 = await heading.hasClass('sky-font-heading-3');\n    const isHeadingStyle4 = await heading.hasClass('sky-font-heading-4');\n\n    if (isHeadingStyle3) {\n      return 3;\n    } else if (isHeadingStyle4) {\n      return 4;\n    } else {\n      return 5;\n    }\n  }\n\n  /**\n   * Whether the checkbox group is required.\n   */\n  public async getRequired(): Promise<boolean> {\n    const heading = await this.#getHeading();\n\n    return await heading.hasClass('sky-control-label-required');\n  }\n\n  /**\n   * Whether the checkbox group is stacked.\n   */\n  public async getStacked(): Promise<boolean> {\n    const host = await this.host();\n    const heading =\n      (await this.#getLegendH3()) ||\n      (await this.#getLegendH4()) ||\n      (await this.#getLegendH5());\n    const label = await this.#getLegendDefault();\n\n    return (\n      ((await host.hasClass('sky-form-field-stacked')) && !!label) ||\n      ((await host.hasClass('sky-field-group-stacked')) && !!heading)\n    );\n  }\n\n  /**\n   * Whether all the checkboxes in a required group are unchecked.\n   */\n  public async hasRequiredError(): Promise<boolean> {\n    return await (await this.#getFormErrors()).hasError('required');\n  }\n\n  /**\n   * Whether the checkbox group has errors.\n   */\n  public async hasError(errorName: string): Promise<boolean> {\n    return await (await this.#getFormErrors()).hasError(errorName);\n  }\n\n  async #getFormErrors(): Promise<SkyFormErrorsHarness> {\n    return await this.locatorFor(\n      SkyFormErrorsHarness.with({\n        dataSkyId: 'checkbox-group-form-errors',\n      }),\n    )();\n  }\n\n  async #getHelpInline(): Promise<SkyHelpInlineHarness> {\n    const harness = await this.locatorForOptional(\n      SkyHelpInlineHarness.with({\n        ancestor: '.sky-checkbox-group > .sky-checkbox-group-legend',\n      }),\n    )();\n\n    if (harness) {\n      return harness;\n    }\n\n    throw Error('No help inline found.');\n  }\n}\n"]}

package/esm2022/testing/modules/checkbox/checkbox-harness-filters.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tib3gtaGFybmVzcy1maWx0ZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL2Zvcm1zL3Rlc3Rpbmcvc3JjL21vZHVsZXMvY2hlY2tib3gvY2hlY2tib3gtaGFybmVzcy1maWx0ZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTa3lIYXJuZXNzRmlsdGVycyB9IGZyb20gJ0Bza3l1eC9jb3JlL3Rlc3RpbmcnO1xuXG4vKipcbiAqIEEgc2V0IG9mIGNyaXRlcmlhIHRoYXQgY2FuIGJlIHVzZWQgdG8gZmlsdGVyIGEgbGlzdCBvZiBgU2t5Q2hlY2tib3hIYXJuZXNzYCBpbnN0YW5jZXMuXG4gKiBAaW50ZXJuYWxcbiAqL1xuLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby1lbXB0eS1pbnRlcmZhY2UsIEB0eXBlc2NyaXB0LWVzbGludC9uby1lbXB0eS1vYmplY3QtdHlwZVxuZXhwb3J0IGludGVyZmFjZSBTa3lDaGVja2JveEhhcm5lc3NGaWx0ZXJzIGV4dGVuZHMgU2t5SGFybmVzc0ZpbHRlcnMge31cbiJdfQ==

package/esm2022/testing/modules/checkbox/checkbox-harness.mjs

@@ -0,0 +1,196 @@
+import { SkyComponentHarness } from '@skyux/core/testing';
+import { SkyHelpInlineHarness } from '@skyux/help-inline/testing';
+import { SkyFormErrorsHarness } from '../form-error/form-errors-harness';
+import { SkyCheckboxLabelHarness } from './checkbox-label-harness';
+import { SkyCheckboxLabelTextLabelHarness } from './checkbox-label-text-label.harness';
+/**
+ * Harness for interacting with a checkbox component in tests.
+ */
+export class SkyCheckboxHarness extends SkyComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-checkbox'; }
+    #getHintText = this.locatorForOptional('.sky-checkbox-hint-text');
+    #getInput = this.locatorFor('input.sky-checkbox-input');
+    #getLabel = this.locatorForOptional(SkyCheckboxLabelHarness);
+    #getLabelTextLabel = this.locatorForOptional(SkyCheckboxLabelTextLabelHarness);
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyCheckboxHarness` that meets certain criteria.
+     */
+    static with(filters) {
+        return SkyCheckboxHarness.getDataSkyIdPredicate(filters);
+    }
+    /**
+     * Blurs the checkbox.
+     */
+    async blur() {
+        await (await this.#getInput()).blur();
+    }
+    /**
+     * Clicks the help inline button.
+     */
+    async clickHelpInline() {
+        await (await this.#getHelpInline()).click();
+    }
+    /**
+     * Puts the checkbox in a checked state by toggling it if it is currently unchecked, or doing nothing if it is already checked.
+     */
+    async check() {
+        if (!(await this.isChecked())) {
+            await this.#toggle();
+        }
+    }
+    /**
+     * Focuses the checkbox.
+     */
+    async focus() {
+        await (await this.#getInput()).focus();
+    }
+    /**
+     * Gets the checkbox's aria-label.
+     */
+    async getAriaLabel() {
+        return await (await this.#getInput()).getAttribute('aria-label');
+    }
+    /**
+     * Gets the checkbox's aria-labelledby.
+     */
+    async getAriaLabelledby() {
+        return await (await this.#getInput()).getAttribute('aria-labelledby');
+    }
+    /**
+     * Gets the help popover content.
+     */
+    async getHelpPopoverContent() {
+        const content = await (await this.#getHelpInline()).getPopoverContent();
+        return content;
+    }
+    /**
+     * Gets the help popover title.
+     */
+    async getHelpPopoverTitle() {
+        return await (await this.#getHelpInline()).getPopoverTitle();
+    }
+    /**
+     * Gets the checkbox's label text. If the label is set via `labelText` and `labelHidden` is true,
+     * the text will still be returned.
+     */
+    async getLabelText() {
+        const labelTextLabel = await this.#getLabelTextLabel();
+        const label = await this.#getLabel();
+        if (labelTextLabel) {
+            const text = await labelTextLabel.getText();
+            const ariaLabel = await this.getAriaLabel();
+            // if labelText is set, ariaLabel will never return null
+            return text || ariaLabel;
+        }
+        else {
+            return await label?.getText();
+        }
+    }
+    /**
+     * Whether the label is hidden. Only supported when using the `labelText` input to set the label.
+     */
+    async getLabelHidden() {
+        const labelTextLabel = await this.#getLabelTextLabel();
+        const label = await this.#getLabel();
+        if (label) {
+            throw new Error('`labelIsHidden` is only supported when setting the checkbox label via the `labelText` input.');
+        }
+        else {
+            return !(await labelTextLabel?.getText());
+        }
+    }
+    /**
+     * Gets the checkbox's hint text.
+     */
+    async getHintText() {
+        const hintText = await this.#getHintText();
+        return (await hintText?.text())?.trim() ?? '';
+    }
+    /**
+     * Gets the checkbox's name.
+     */
+    async getName() {
+        return await (await this.#getInput()).getAttribute('name');
+    }
+    /**
+     * Gets the checkbox's value.
+     */
+    async getValue() {
+        return await (await this.#getInput()).getProperty('value');
+    }
+    /**
+     * Whether the checkbox displays custom error.
+     */
+    async hasCustomError(errorName) {
+        return await (await this.#getFormErrors()).hasError(errorName);
+    }
+    /**
+     * Whether the checkbox displays an error that it is required.
+     */
+    async hasRequiredError() {
+        return await (await this.#getFormErrors()).hasError('required');
+    }
+    /**
+     * Whether the checkbox is checked.
+     */
+    async isChecked() {
+        return await (await this.#getInput()).getProperty('checked');
+    }
+    /**
+     * Whether the checkbox is disabled.
+     */
+    async isDisabled() {
+        const disabled = await (await this.#getInput()).getAttribute('disabled');
+        return disabled !== null;
+    }
+    /**
+     * Whether the checkbox is focused.
+     */
+    async isFocused() {
+        return await (await this.#getInput()).isFocused();
+    }
+    /**
+     * Whether the checkbox is required.
+     */
+    async isRequired() {
+        const value = await (await this.#getInput()).getAttribute('required');
+        return value !== null;
+    }
+    /**
+     * Whether the checkbox is stacked.
+     */
+    async isStacked() {
+        return await (await this.host()).hasClass('sky-form-field-stacked');
+    }
+    /**
+     * Puts the checkbox in an unchecked state by toggling it if it is currently checked, or doing nothing if it is already unchecked.
+     */
+    async uncheck() {
+        if (await this.isChecked()) {
+            await this.#toggle();
+        }
+    }
+    async #getFormErrors() {
+        return await this.locatorFor(SkyFormErrorsHarness)();
+    }
+    async #getHelpInline() {
+        const harness = await this.locatorForOptional(SkyHelpInlineHarness)();
+        if (harness) {
+            return harness;
+        }
+        throw Error('No help inline found.');
+    }
+    async #toggle() {
+        if (await this.isDisabled()) {
+            throw new Error('Could not toggle the checkbox because it is disabled.');
+        }
+        else {
+            await (await this.#getInput()).click();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"checkbox-harness.js","sourceRoot":"","sources":["../../../../../../../../libs/components/forms/testing/src/modules/checkbox/checkbox-harness.ts"],"names":[],"mappings":"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","sourcesContent":["import { HarnessPredicate } from '@angular/cdk/testing';\nimport { SkyComponentHarness } from '@skyux/core/testing';\nimport { SkyHelpInlineHarness } from '@skyux/help-inline/testing';\n\nimport { SkyFormErrorsHarness } from '../form-error/form-errors-harness';\n\nimport { SkyCheckboxHarnessFilters } from './checkbox-harness-filters';\nimport { SkyCheckboxLabelHarness } from './checkbox-label-harness';\nimport { SkyCheckboxLabelTextLabelHarness } from './checkbox-label-text-label.harness';\n\n/**\n * Harness for interacting with a checkbox component in tests.\n */\nexport class SkyCheckboxHarness extends SkyComponentHarness {\n  /**\n   * @internal\n   */\n  public static hostSelector = 'sky-checkbox';\n\n  #getHintText = this.locatorForOptional('.sky-checkbox-hint-text');\n\n  #getInput = this.locatorFor('input.sky-checkbox-input');\n\n  #getLabel = this.locatorForOptional(SkyCheckboxLabelHarness);\n\n  #getLabelTextLabel = this.locatorForOptional(\n    SkyCheckboxLabelTextLabelHarness,\n  );\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a\n   * `SkyCheckboxHarness` that meets certain criteria.\n   */\n  public static with(\n    filters: SkyCheckboxHarnessFilters,\n  ): HarnessPredicate<SkyCheckboxHarness> {\n    return SkyCheckboxHarness.getDataSkyIdPredicate(filters);\n  }\n\n  /**\n   * Blurs the checkbox.\n   */\n  public async blur(): Promise<void> {\n    await (await this.#getInput()).blur();\n  }\n\n  /**\n   * Clicks the help inline button.\n   */\n  public async clickHelpInline(): Promise<void> {\n    await (await this.#getHelpInline()).click();\n  }\n\n  /**\n   * Puts the checkbox in a checked state by toggling it if it is currently unchecked, or doing nothing if it is already checked.\n   */\n  public async check(): Promise<void> {\n    if (!(await this.isChecked())) {\n      await this.#toggle();\n    }\n  }\n\n  /**\n   * Focuses the checkbox.\n   */\n  public async focus(): Promise<void> {\n    await (await this.#getInput()).focus();\n  }\n\n  /**\n   * Gets the checkbox's aria-label.\n   */\n  public async getAriaLabel(): Promise<string | null> {\n    return await (await this.#getInput()).getAttribute('aria-label');\n  }\n\n  /**\n   * Gets the checkbox's aria-labelledby.\n   */\n  public async getAriaLabelledby(): Promise<string | null> {\n    return await (await this.#getInput()).getAttribute('aria-labelledby');\n  }\n\n  /**\n   * Gets the help popover content.\n   */\n  public async getHelpPopoverContent(): Promise<string | undefined> {\n    const content = await (await this.#getHelpInline()).getPopoverContent();\n\n    return content as string | undefined;\n  }\n\n  /**\n   * Gets the help popover title.\n   */\n  public async getHelpPopoverTitle(): Promise<string | undefined> {\n    return await (await this.#getHelpInline()).getPopoverTitle();\n  }\n\n  /**\n   * Gets the checkbox's label text. If the label is set via `labelText` and `labelHidden` is true,\n   * the text will still be returned.\n   */\n  public async getLabelText(): Promise<string | undefined> {\n    const labelTextLabel = await this.#getLabelTextLabel();\n    const label = await this.#getLabel();\n\n    if (labelTextLabel) {\n      const text = await labelTextLabel.getText();\n      const ariaLabel = await this.getAriaLabel();\n\n      // if labelText is set, ariaLabel will never return null\n      return text || ariaLabel!;\n    } else {\n      return await label?.getText();\n    }\n  }\n\n  /**\n   * Whether the label is hidden. Only supported when using the `labelText` input to set the label.\n   */\n  public async getLabelHidden(): Promise<boolean> {\n    const labelTextLabel = await this.#getLabelTextLabel();\n    const label = await this.#getLabel();\n\n    if (label) {\n      throw new Error(\n        '`labelIsHidden` is only supported when setting the checkbox label via the `labelText` input.',\n      );\n    } else {\n      return !(await labelTextLabel?.getText());\n    }\n  }\n\n  /**\n   * Gets the checkbox's hint text.\n   */\n  public async getHintText(): Promise<string> {\n    const hintText = await this.#getHintText();\n\n    return (await hintText?.text())?.trim() ?? '';\n  }\n\n  /**\n   * Gets the checkbox's name.\n   */\n  public async getName(): Promise<string | null> {\n    return await (await this.#getInput()).getAttribute('name');\n  }\n\n  /**\n   * Gets the checkbox's value.\n   */\n  public async getValue(): Promise<string | null> {\n    return await (await this.#getInput()).getProperty<string | null>('value');\n  }\n\n  /**\n   * Whether the checkbox displays custom error.\n   */\n  public async hasCustomError(errorName: string): Promise<boolean> {\n    return await (await this.#getFormErrors()).hasError(errorName);\n  }\n\n  /**\n   * Whether the checkbox displays an error that it is required.\n   */\n  public async hasRequiredError(): Promise<boolean> {\n    return await (await this.#getFormErrors()).hasError('required');\n  }\n\n  /**\n   * Whether the checkbox is checked.\n   */\n  public async isChecked(): Promise<boolean> {\n    return await (await this.#getInput()).getProperty<boolean>('checked');\n  }\n\n  /**\n   * Whether the checkbox is disabled.\n   */\n  public async isDisabled(): Promise<boolean> {\n    const disabled = await (await this.#getInput()).getAttribute('disabled');\n    return disabled !== null;\n  }\n\n  /**\n   * Whether the checkbox is focused.\n   */\n  public async isFocused(): Promise<boolean> {\n    return await (await this.#getInput()).isFocused();\n  }\n\n  /**\n   * Whether the checkbox is required.\n   */\n  public async isRequired(): Promise<boolean> {\n    const value = await (await this.#getInput()).getAttribute('required');\n    return value !== null;\n  }\n\n  /**\n   * Whether the checkbox is stacked.\n   */\n  public async isStacked(): Promise<boolean> {\n    return await (await this.host()).hasClass('sky-form-field-stacked');\n  }\n\n  /**\n   * Puts the checkbox in an unchecked state by toggling it if it is currently checked, or doing nothing if it is already unchecked.\n   */\n  public async uncheck(): Promise<void> {\n    if (await this.isChecked()) {\n      await this.#toggle();\n    }\n  }\n\n  async #getFormErrors(): Promise<SkyFormErrorsHarness> {\n    return await this.locatorFor(SkyFormErrorsHarness)();\n  }\n\n  async #getHelpInline(): Promise<SkyHelpInlineHarness> {\n    const harness = await this.locatorForOptional(SkyHelpInlineHarness)();\n\n    if (harness) {\n      return harness;\n    }\n\n    throw Error('No help inline found.');\n  }\n\n  async #toggle(): Promise<void> {\n    if (await this.isDisabled()) {\n      throw new Error('Could not toggle the checkbox because it is disabled.');\n    } else {\n      await (await this.#getInput()).click();\n    }\n  }\n}\n"]}

package/esm2022/testing/modules/checkbox/checkbox-label-harness.mjs

@@ -0,0 +1,19 @@
+import { ComponentHarness } from '@angular/cdk/testing';
+/**
+ * Harness for interacting with a checkbox label component in tests.
+ * @internal
+ */
+export class SkyCheckboxLabelHarness extends ComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-checkbox-label'; }
+    #getLabelContent = this.locatorFor('.sky-switch-label');
+    /**
+     * Gets the text content of the checkbox label.
+     */
+    async getText() {
+        return await (await this.#getLabelContent()).text();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tib3gtbGFiZWwtaGFybmVzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9mb3Jtcy90ZXN0aW5nL3NyYy9tb2R1bGVzL2NoZWNrYm94L2NoZWNrYm94LWxhYmVsLWhhcm5lc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFeEQ7OztHQUdHO0FBQ0gsTUFBTSxPQUFPLHVCQUF3QixTQUFRLGdCQUFnQjtJQUMzRDs7T0FFRzthQUNXLGlCQUFZLEdBQUcsb0JBQW9CLENBQUM7SUFFbEQsZ0JBQWdCLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDO0lBRXhEOztPQUVHO0lBQ0ksS0FBSyxDQUFDLE9BQU87UUFDbEIsT0FBTyxNQUFNLENBQUMsTUFBTSxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3RELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnRIYXJuZXNzIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL3Rlc3RpbmcnO1xuXG4vKipcbiAqIEhhcm5lc3MgZm9yIGludGVyYWN0aW5nIHdpdGggYSBjaGVja2JveCBsYWJlbCBjb21wb25lbnQgaW4gdGVzdHMuXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGNsYXNzIFNreUNoZWNrYm94TGFiZWxIYXJuZXNzIGV4dGVuZHMgQ29tcG9uZW50SGFybmVzcyB7XG4gIC8qKlxuICAgKiBAaW50ZXJuYWxcbiAgICovXG4gIHB1YmxpYyBzdGF0aWMgaG9zdFNlbGVjdG9yID0gJ3NreS1jaGVja2JveC1sYWJlbCc7XG5cbiAgI2dldExhYmVsQ29udGVudCA9IHRoaXMubG9jYXRvckZvcignLnNreS1zd2l0Y2gtbGFiZWwnKTtcblxuICAvKipcbiAgICogR2V0cyB0aGUgdGV4dCBjb250ZW50IG9mIHRoZSBjaGVja2JveCBsYWJlbC5cbiAgICovXG4gIHB1YmxpYyBhc3luYyBnZXRUZXh0KCk6IFByb21pc2U8c3RyaW5nPiB7XG4gICAgcmV0dXJuIGF3YWl0IChhd2FpdCB0aGlzLiNnZXRMYWJlbENvbnRlbnQoKSkudGV4dCgpO1xuICB9XG59XG4iXX0=

package/esm2022/testing/modules/checkbox/checkbox-label-text-label.harness.mjs

@@ -0,0 +1,19 @@
+import { ComponentHarness } from '@angular/cdk/testing';
+/**
+ * Harness for interacting with a `labelText` checkbox label component in tests.
+ * @internal
+ */
+export class SkyCheckboxLabelTextLabelHarness extends ComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-checkbox-label-text-label'; }
+    #getLabelContent = this.locatorForOptional('.sky-switch-label');
+    /**
+     * Gets the text content of the `labelText` checkbox label.
+     */
+    async getText() {
+        return await (await this.#getLabelContent())?.text();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tib3gtbGFiZWwtdGV4dC1sYWJlbC5oYXJuZXNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL2Zvcm1zL3Rlc3Rpbmcvc3JjL21vZHVsZXMvY2hlY2tib3gvY2hlY2tib3gtbGFiZWwtdGV4dC1sYWJlbC5oYXJuZXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRXhEOzs7R0FHRztBQUNILE1BQU0sT0FBTyxnQ0FBaUMsU0FBUSxnQkFBZ0I7SUFDcEU7O09BRUc7YUFDVyxpQkFBWSxHQUFHLCtCQUErQixDQUFDO0lBRTdELGdCQUFnQixHQUFHLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDO0lBRWhFOztPQUVHO0lBQ0ksS0FBSyxDQUFDLE9BQU87UUFDbEIsT0FBTyxNQUFNLENBQUMsTUFBTSxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQyxFQUFFLElBQUksRUFBRSxDQUFDO0lBQ3ZELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnRIYXJuZXNzIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL3Rlc3RpbmcnO1xuXG4vKipcbiAqIEhhcm5lc3MgZm9yIGludGVyYWN0aW5nIHdpdGggYSBgbGFiZWxUZXh0YCBjaGVja2JveCBsYWJlbCBjb21wb25lbnQgaW4gdGVzdHMuXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGNsYXNzIFNreUNoZWNrYm94TGFiZWxUZXh0TGFiZWxIYXJuZXNzIGV4dGVuZHMgQ29tcG9uZW50SGFybmVzcyB7XG4gIC8qKlxuICAgKiBAaW50ZXJuYWxcbiAgICovXG4gIHB1YmxpYyBzdGF0aWMgaG9zdFNlbGVjdG9yID0gJ3NreS1jaGVja2JveC1sYWJlbC10ZXh0LWxhYmVsJztcblxuICAjZ2V0TGFiZWxDb250ZW50ID0gdGhpcy5sb2NhdG9yRm9yT3B0aW9uYWwoJy5za3ktc3dpdGNoLWxhYmVsJyk7XG5cbiAgLyoqXG4gICAqIEdldHMgdGhlIHRleHQgY29udGVudCBvZiB0aGUgYGxhYmVsVGV4dGAgY2hlY2tib3ggbGFiZWwuXG4gICAqL1xuICBwdWJsaWMgYXN5bmMgZ2V0VGV4dCgpOiBQcm9taXNlPHN0cmluZyB8IHVuZGVmaW5lZD4ge1xuICAgIHJldHVybiBhd2FpdCAoYXdhaXQgdGhpcy4jZ2V0TGFiZWxDb250ZW50KCkpPy50ZXh0KCk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/testing/modules/field-group/field-group-harness-filters.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGQtZ3JvdXAtaGFybmVzcy1maWx0ZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL2Zvcm1zL3Rlc3Rpbmcvc3JjL21vZHVsZXMvZmllbGQtZ3JvdXAvZmllbGQtZ3JvdXAtaGFybmVzcy1maWx0ZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTa3lIYXJuZXNzRmlsdGVycyB9IGZyb20gJ0Bza3l1eC9jb3JlL3Rlc3RpbmcnO1xuXG4vKipcbiAqIEEgc2V0IG9mIGNyaXRlcmlhIHRoYXQgY2FuIGJlIHVzZWQgdG8gZmlsdGVyIGEgbGlzdCBvZiBgU2t5RmllbGRHcm91cEhhcm5lc3NgIGluc3RhbmNlcy5cbiAqIEBpbnRlcm5hbFxuICovXG4vLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLWVtcHR5LWludGVyZmFjZSwgQHR5cGVzY3JpcHQtZXNsaW50L25vLWVtcHR5LW9iamVjdC10eXBlXG5leHBvcnQgaW50ZXJmYWNlIFNreUZpZWxkR3JvdXBIYXJuZXNzRmlsdGVycyBleHRlbmRzIFNreUhhcm5lc3NGaWx0ZXJzIHt9XG4iXX0=

package/esm2022/testing/modules/field-group/field-group-harness.mjs

@@ -0,0 +1,92 @@
+import { SkyComponentHarness } from '@skyux/core/testing';
+import { SkyHelpInlineHarness } from '@skyux/help-inline/testing';
+/**
+ * Harness for interacting with a field group component in tests.
+ */
+export class SkyFieldGroupHarness extends SkyComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-field-group'; }
+    #getLegend = this.locatorFor('legend');
+    #getLegendH3 = this.locatorForOptional('legend h3');
+    #getLegendH4 = this.locatorForOptional('legend h4');
+    #getLegendHeading = this.locatorFor('legend h3,h4');
+    #getHintText = this.locatorForOptional('.sky-field-group-hint-text');
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyFieldGroupHarness` that meets certain criteria.
+     */
+    static with(filters) {
+        return SkyFieldGroupHarness.getDataSkyIdPredicate(filters);
+    }
+    /**
+     * Gets the field group's heading text. If `headingHidden` is true,
+     * the text will still be returned.
+     */
+    async getHeadingText() {
+        return await (await this.#getLegendHeading()).text();
+    }
+    /**
+     * Gets the field group's hint text.
+     */
+    async getHintText() {
+        const hintText = await this.#getHintText();
+        return (await hintText?.text())?.trim() ?? '';
+    }
+    /**
+     * Whether the heading is hidden.
+     */
+    async getHeadingHidden() {
+        return await (await this.#getLegend()).hasClass('sky-screen-reader-only');
+    }
+    /**
+     * Whether the field group is stacked.
+     */
+    async getStacked() {
+        const host = await this.host();
+        return await host.hasClass('sky-margin-stacked-xl');
+    }
+    /**
+     * The semantic heading level used for the field group.
+     */
+    async getHeadingLevel() {
+        const h3 = await this.#getLegendH3();
+        return h3 ? 3 : 4;
+    }
+    /**
+     * The heading style used for the field group.
+     */
+    async getHeadingStyle() {
+        const heading = (await this.#getLegendH3()) || (await this.#getLegendH4());
+        return (await heading?.hasClass('sky-font-heading-3')) ? 3 : 4;
+    }
+    /**
+     * Clicks the help inline button.
+     */
+    async clickHelpInline() {
+        await (await this.#getHelpInline()).click();
+    }
+    /**
+     * Gets the help popover content.
+     */
+    async getHelpPopoverContent() {
+        return await (await this.#getHelpInline()).getPopoverContent();
+    }
+    /**
+     * Gets the help popover title.
+     */
+    async getHelpPopoverTitle() {
+        return await (await this.#getHelpInline()).getPopoverTitle();
+    }
+    async #getHelpInline() {
+        const harness = await this.locatorForOptional(SkyHelpInlineHarness.with({
+            ancestor: '.sky-field-group > .sky-field-group-legend',
+        }))();
+        if (harness) {
+            return harness;
+        }
+        throw Error('No help inline found.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/modules/file-attachment/file-drop/file-drop-harness-filters.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1kcm9wLWhhcm5lc3MtZmlsdGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9mb3Jtcy90ZXN0aW5nL3NyYy9tb2R1bGVzL2ZpbGUtYXR0YWNobWVudC9maWxlLWRyb3AvZmlsZS1kcm9wLWhhcm5lc3MtZmlsdGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2t5SGFybmVzc0ZpbHRlcnMgfSBmcm9tICdAc2t5dXgvY29yZS90ZXN0aW5nJztcblxuLyoqXG4gKiBBIHNldCBvZiBjcml0ZXJpYSB0aGF0IGNhbiBiZSB1c2VkIHRvIGZpbHRlciBhIGxpc3Qgb2YgYFNreUZpbGVEcm9wSGFybmVzc2AgaW5zdGFuY2VzLlxuICogQGludGVybmFsXG4gKi9cbi8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tZW1wdHktaW50ZXJmYWNlLCBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tZW1wdHktb2JqZWN0LXR5cGVcbmV4cG9ydCBpbnRlcmZhY2UgU2t5RmlsZURyb3BIYXJuZXNzRmlsdGVycyBleHRlbmRzIFNreUhhcm5lc3NGaWx0ZXJzIHt9XG4iXX0=

package/esm2022/testing/modules/file-attachment/file-drop/file-drop-harness.mjs

@@ -0,0 +1,45 @@
+import { SkyComponentHarness } from '@skyux/core/testing';
+/**
+ * Harness for interacting with a file drop component in tests.
+ * @internal
+ */
+export class SkyFileDropHarness extends SkyComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-file-drop'; }
+    #getDropTarget = this.locatorFor('.sky-file-drop-target');
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyFileDropHarness` that meets certain criteria.
+     */
+    static with(filters) {
+        return SkyFileDropHarness.getDataSkyIdPredicate(filters);
+    }
+    /**
+     * Drops a file onto the component's drop target.
+     */
+    async dropFile(file) {
+        await this.#dropFiles([file]);
+    }
+    // Consider making this public when we finalize this harness's public API.
+    async #dropFiles(files) {
+        const dropTarget = await this.#getDropTarget();
+        const fileList = {
+            item: (index) => files[index],
+            length: files.length,
+        };
+        dropTarget.dispatchEvent('drop', {
+            dataTransfer: {
+                files: fileList,
+            },
+        });
+        // The file drop component's `filesChanged` event happens asynchronously as the
+        // result of an event handler which is outside of the test harness async logic,
+        // so get in the queue after the event handler, then resolve.
+        return await new Promise((resolve) => {
+            setTimeout(() => resolve(), 100);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/modules/form-error/form-error-harness.filters.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybS1lcnJvci1oYXJuZXNzLmZpbHRlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvZm9ybXMvdGVzdGluZy9zcmMvbW9kdWxlcy9mb3JtLWVycm9yL2Zvcm0tZXJyb3ItaGFybmVzcy5maWx0ZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTa3lIYXJuZXNzRmlsdGVycyB9IGZyb20gJ0Bza3l1eC9jb3JlL3Rlc3RpbmcnO1xuXG4vKipcbiAqIEEgc2V0IG9mIGNyaXRlcmlhIHRoYXQgY2FuIGJlIHVzZWQgdG8gZmlsdGVyIGEgbGlzdCBvZiBgU2t5Rm9ybUVycm9ySGFybmVzc2AgaW5zdGFuY2VzLlxuICovXG4vLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLWVtcHR5LWludGVyZmFjZSwgQHR5cGVzY3JpcHQtZXNsaW50L25vLWVtcHR5LW9iamVjdC10eXBlXG5leHBvcnQgaW50ZXJmYWNlIFNreUZvcm1FcnJvckhhcm5lc3NGaWx0ZXJzIGV4dGVuZHMgU2t5SGFybmVzc0ZpbHRlcnMge31cbiJdfQ==