@theseam/ui-common 0.4.13 → 0.4.15

package/esm2020/testing/harnesses/ng-select-dropdown.harness.mjs

@@ -0,0 +1,39 @@
+import { ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { TheSeamNgSelectOptionHarness } from './ng-select-option.harness';
+export class TheSeamNgSelectDropdownHarness extends ComponentHarness {
+    // private readonly _ngSelect = this.locatorFor(TheSeamNgSelectDropdownHarness)
+    // private readonly _requiredIndicator = this.locatorFor(TheSeamFormFieldRequiredIndicatorHarness)
+    // private readonly _valueLabel = this.locatorForOptional('.ng-value-label')
+    // private readonly _options = this.locatorForOptional(TheSeamNgSelectOptionHarness)
+    /** Creates a `HarnessPredicate` used to locate a particular `MyMenuHarness`. */
+    static with(options) {
+        return new HarnessPredicate(TheSeamNgSelectDropdownHarness, options)
+            .addOption('field id', options.id, (harness, id) => HarnessPredicate.stringMatches(harness.getId(), id));
+    }
+    async getId() {
+        return (await this.host()).getAttribute('id');
+    }
+    /**
+     * Gets a list of `TheSeamNgSelectOptionHarness` representing the items in the menu.
+     * @param filters Optionally filters which menu items are included.
+     */
+    async getOptions(filters) {
+        return this.locatorForAll(TheSeamNgSelectOptionHarness.with({
+            ...(filters || {}),
+        }))();
+    }
+    /**
+     * Clicks an option in the dropdown.
+     * @param optionFilter A filter used to represent which option in the dropdown should be clicked. The
+     *     first matching dropdown option will be clicked.
+     */
+    async clickOption(optionFilter) {
+        const options = await this.getOptions(optionFilter);
+        if (!options.length) {
+            throw Error(`Could not find option matching ${JSON.stringify(optionFilter)}`);
+        }
+        return options[0].click();
+    }
+}
+TheSeamNgSelectDropdownHarness.hostSelector = 'ng-dropdown-panel';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/testing/harnesses/ng-select-option.harness.mjs

@@ -0,0 +1,26 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+export class TheSeamNgSelectOptionHarness extends ComponentHarness {
+    /** Creates a `HarnessPredicate` used to locate a particular `MyMenuHarness`. */
+    static with(options) {
+        return new HarnessPredicate(TheSeamNgSelectOptionHarness, options)
+            .addOption('option value', options.value, (harness, value) => HarnessPredicate.stringMatches(harness.getValue(), value));
+    }
+    /**
+     * NOTE: Only works with string values, curently.
+     * @returns value of the select option
+     */
+    async getValue() {
+        return (await this.host()).text();
+    }
+    /** Whether the ng-select is disabled. */
+    async isDisabled() {
+        const disabled = (await this.host()).getAttribute('disabled');
+        return coerceBooleanProperty(await disabled);
+    }
+    async click() {
+        return (await this.host()).click();
+    }
+}
+TheSeamNgSelectOptionHarness.hostSelector = '.ng-option';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/testing/harnesses/ng-select.harness.mjs

@@ -0,0 +1,104 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ComponentHarness, HarnessPredicate } from '@angular/cdk/testing';
+import { TheSeamNgSelectDropdownHarness } from './ng-select-dropdown.harness';
+export class TheSeamNgSelectHarness extends ComponentHarness {
+    constructor() {
+        super(...arguments);
+        this._documentRootLocator = this.documentRootLocatorFactory();
+        this._value = this.locatorForOptional('.ng-value');
+        this._valueLabel = this.locatorForOptional('.ng-value-label');
+    }
+    /** Creates a `HarnessPredicate` used to locate a particular `MyMenuHarness`. */
+    static with(options) {
+        return new HarnessPredicate(TheSeamNgSelectHarness, options);
+        // .addOption('field name', options.name,
+        //     (harness, name) => HarnessPredicate.stringMatches(harness.getName(), name))
+    }
+    async getId() {
+        return (await this.getInputElement()).getAttribute('id');
+    }
+    async getAriaControls() {
+        return (await this.getInputElement()).getAttribute('aria-controls');
+    }
+    async getName() {
+        return (await this.getInputElement()).getAttribute('name');
+    }
+    /**
+     * NOTE: Only works with string values, curently.
+     * @returns value of the select
+     */
+    async getValue() {
+        const valueLabel = await this._valueLabel();
+        if (valueLabel === null) {
+            const value = await this._value();
+            if (value === null) {
+                return null;
+            }
+            return value.text();
+        }
+        return valueLabel.text();
+    }
+    /**
+     * Gets a list of `TheSeamNgSelectOptionHarness` representing the options in the dropdown.
+     *
+     * NOTE: Must open the dropdown first. eg. `await ngSelectHarness.click()`
+     *
+     * @param filters Optionally filters which menu items are included.
+     */
+    async getOptions(filters) {
+        const dropdown = await this._getDropdown();
+        if (dropdown === null) {
+            return [];
+        }
+        return dropdown.getOptions(filters);
+    }
+    /**
+     * Clicks an option in the dropdown.
+     * @param optionFilter A filter used to represent which option in the dropdown should be clicked. The
+     *     first matching dropdown option will be clicked.
+     */
+    async clickOption(optionFilter) {
+        await this.click();
+        const dropdown = await this._getDropdown();
+        if (dropdown === null) {
+            throw Error(`Could not find dropdown.`);
+        }
+        return dropdown.clickOption(optionFilter);
+    }
+    /** Whether the ng-select is disabled. */
+    async isDisabled() {
+        const disabled = (await this.host()).getAttribute('disabled');
+        return coerceBooleanProperty(await disabled);
+    }
+    /**
+     * Returns the required state of the ng-select.
+     *
+     * @returns true if the ng-select is required, false if not
+     */
+    async isRequired() {
+        const required = await (await this.host()).getAttribute('required');
+        return required === undefined ? true : coerceBooleanProperty(required);
+    }
+    async click() {
+        return (await this.getInputElement()).click();
+    }
+    /**
+     * Returns the input element of the checkbox.
+     *
+     * @returns the input element of the checkbox
+     */
+    async getInputElement() {
+        return this.locatorFor('input')();
+    }
+    async _getDropdown() {
+        const ariaControls = await this.getAriaControls();
+        if (ariaControls) {
+            return this._documentRootLocator.locatorForOptional(TheSeamNgSelectDropdownHarness.with({
+                id: ariaControls,
+            }))();
+        }
+        return null;
+    }
+}
+TheSeamNgSelectHarness.hostSelector = 'ng-select';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng-select.harness.js","sourceRoot":"","sources":["../../../../../projects/ui-common/testing/harnesses/ng-select.harness.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion'\nimport { BaseHarnessFilters, ComponentHarness, HarnessPredicate } from '@angular/cdk/testing'\n\nimport { TheSeamFormFieldRequiredIndicatorHarness } from '@theseam/ui-common/form-field'\nimport { TheSeamNgSelectOptionHarness, TheSeamNgSelectOptionHarnessFilters } from './ng-select-option.harness'\nimport { TheSeamNgSelectDropdownHarness, TheSeamNgSelectDropdownHarnessFilters } from './ng-select-dropdown.harness'\n\nexport interface TheSeamNgSelectHarnessFilters extends BaseHarnessFilters {\n  /** Filters based on the name of the field. */\n  // name?: string | RegExp\n}\n\nexport class TheSeamNgSelectHarness extends ComponentHarness {\n  private _documentRootLocator = this.documentRootLocatorFactory()\n\n  static hostSelector = 'ng-select'\n\n  private readonly _value = this.locatorForOptional('.ng-value')\n  private readonly _valueLabel = this.locatorForOptional('.ng-value-label')\n\n  /** Creates a `HarnessPredicate` used to locate a particular `MyMenuHarness`. */\n  static with(options: TheSeamNgSelectHarnessFilters): HarnessPredicate<TheSeamNgSelectHarness> {\n    return new HarnessPredicate(TheSeamNgSelectHarness, options)\n        // .addOption('field name', options.name,\n        //     (harness, name) => HarnessPredicate.stringMatches(harness.getName(), name))\n  }\n\n  public async getId(): Promise<string | null> {\n    return (await this.getInputElement()).getAttribute('id')\n  }\n\n  public async getAriaControls(): Promise<string | null> {\n    return (await this.getInputElement()).getAttribute('aria-controls')\n  }\n\n  public async getName(): Promise<string | null> {\n    return (await this.getInputElement()).getAttribute('name')\n  }\n\n  /**\n   * NOTE: Only works with string values, curently.\n   * @returns value of the select\n   */\n  public async getValue(): Promise<any> {\n    const valueLabel = await this._valueLabel()\n    if (valueLabel === null) {\n      const value = await this._value()\n      if (value === null) {\n        return null\n      }\n\n      return value.text()\n    }\n\n    return valueLabel.text()\n  }\n\n  /**\n   * Gets a list of `TheSeamNgSelectOptionHarness` representing the options in the dropdown.\n   *\n   * NOTE: Must open the dropdown first. eg. `await ngSelectHarness.click()`\n   *\n   * @param filters Optionally filters which menu items are included.\n   */\n  async getOptions(\n    filters?: Omit<TheSeamNgSelectOptionHarnessFilters, 'ancestor'>,\n  ): Promise<TheSeamNgSelectOptionHarness[]> {\n    const dropdown = await this._getDropdown()\n    if (dropdown === null) {\n      return []\n    }\n\n    return dropdown.getOptions(filters)\n  }\n\n  /**\n   * Clicks an option in the dropdown.\n   * @param optionFilter A filter used to represent which option in the dropdown should be clicked. The\n   *     first matching dropdown option will be clicked.\n   */\n  async clickOption(\n    optionFilter: Omit<TheSeamNgSelectOptionHarnessFilters, 'ancestor'>\n  ): Promise<void> {\n    await this.click()\n    const dropdown = await this._getDropdown()\n    if (dropdown === null) {\n      throw Error(`Could not find dropdown.`)\n    }\n\n    return dropdown.clickOption(optionFilter)\n  }\n\n  /** Whether the ng-select is disabled. */\n  async isDisabled(): Promise<boolean> {\n    const disabled = (await this.host()).getAttribute('disabled')\n    return coerceBooleanProperty(await disabled)\n  }\n\n  /**\n   * Returns the required state of the ng-select.\n   *\n   * @returns true if the ng-select is required, false if not\n   */\n  public async isRequired(): Promise<boolean> {\n    const required = await (await this.host()).getAttribute('required')\n    return required === undefined ? true : coerceBooleanProperty(required)\n  }\n\n  public async click(): Promise<void> {\n    return (await this.getInputElement()).click()\n  }\n\n  /**\n   * Returns the input element of the checkbox.\n   *\n   * @returns the input element of the checkbox\n   */\n  public async getInputElement() {\n    return this.locatorFor('input')()\n  }\n\n  private async _getDropdown(): Promise<TheSeamNgSelectDropdownHarness | null> {\n    const ariaControls = await this.getAriaControls()\n    if (ariaControls) {\n      return this._documentRootLocator.locatorForOptional(\n        TheSeamNgSelectDropdownHarness.with({\n          id: ariaControls,\n        } satisfies TheSeamNgSelectDropdownHarnessFilters),\n      )()\n    }\n    return null\n  }\n}\n"]}

package/esm2020/testing/public-api.mjs

@@ -1,7 +1,10 @@
+export * from './harnesses/ng-select-dropdown.harness';
+export * from './harnesses/ng-select-option.harness';
+export * from './harnesses/ng-select.harness';
 export * from './fake-toastr';
 export * from './render-story';
 export * from './tick-helper';
 export * from './current-tick-time';
 export * from './story-expect';
 export * from './get-harness';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi90ZXN0aW5nL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxlQUFlLENBQUE7QUFDN0IsY0FBYyxnQkFBZ0IsQ0FBQTtBQUM5QixjQUFjLGVBQWUsQ0FBQTtBQUM3QixjQUFjLHFCQUFxQixDQUFBO0FBRW5DLGNBQWMsZ0JBQWdCLENBQUE7QUFDOUIsY0FBYyxlQUFlLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Zha2UtdG9hc3RyJ1xuZXhwb3J0ICogZnJvbSAnLi9yZW5kZXItc3RvcnknXG5leHBvcnQgKiBmcm9tICcuL3RpY2staGVscGVyJ1xuZXhwb3J0ICogZnJvbSAnLi9jdXJyZW50LXRpY2stdGltZSdcblxuZXhwb3J0ICogZnJvbSAnLi9zdG9yeS1leHBlY3QnXG5leHBvcnQgKiBmcm9tICcuL2dldC1oYXJuZXNzJ1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi90ZXN0aW5nL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3Q0FBd0MsQ0FBQTtBQUN0RCxjQUFjLHNDQUFzQyxDQUFBO0FBQ3BELGNBQWMsK0JBQStCLENBQUE7QUFFN0MsY0FBYyxlQUFlLENBQUE7QUFDN0IsY0FBYyxnQkFBZ0IsQ0FBQTtBQUM5QixjQUFjLGVBQWUsQ0FBQTtBQUM3QixjQUFjLHFCQUFxQixDQUFBO0FBRW5DLGNBQWMsZ0JBQWdCLENBQUE7QUFDOUIsY0FBYyxlQUFlLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2hhcm5lc3Nlcy9uZy1zZWxlY3QtZHJvcGRvd24uaGFybmVzcydcbmV4cG9ydCAqIGZyb20gJy4vaGFybmVzc2VzL25nLXNlbGVjdC1vcHRpb24uaGFybmVzcydcbmV4cG9ydCAqIGZyb20gJy4vaGFybmVzc2VzL25nLXNlbGVjdC5oYXJuZXNzJ1xuXG5leHBvcnQgKiBmcm9tICcuL2Zha2UtdG9hc3RyJ1xuZXhwb3J0ICogZnJvbSAnLi9yZW5kZXItc3RvcnknXG5leHBvcnQgKiBmcm9tICcuL3RpY2staGVscGVyJ1xuZXhwb3J0ICogZnJvbSAnLi9jdXJyZW50LXRpY2stdGltZSdcblxuZXhwb3J0ICogZnJvbSAnLi9zdG9yeS1leHBlY3QnXG5leHBvcnQgKiBmcm9tICcuL2dldC1oYXJuZXNzJ1xuIl19

package/esm2020/tiled-select/components/tiled-select/tiled-select.component.mjs

@@ -211,4 +211,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
                 type: ContentChildren,
                 args: [TiledSelectTileOverlayDirective]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tiled-select.component.js","sourceRoot":"","sources":["../../../../../../projects/ui-common/tiled-select/components/tiled-select/tiled-select.component.ts","../../../../../../projects/ui-common/tiled-select/components/tiled-select/tiled-select.component.html"],"names":[],"mappings":";AAAA,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAClH,OAAO,EAAgB,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAEjE,OAAO,EAAqB,SAAS,EAAE,eAAe,EAAc,YAAY,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAwB,MAAM,eAAe,CAAA;AACxJ,OAAO,EAAwB,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAExE,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAEtD,OAAO,EAAE,+BAA+B,EAAE,MAAM,wDAAwD,CAAA;;;;;AAIxG,MAAM,CAAC,MAAM,mBAAmB,GAAG,SAAS,CAAC;IAC3C,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,SAAS,EAAE,mBAAmB,EAAE,CAAC;IACrD,OAAO,CAAC,GAAG,EAAE;QACX,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,SAAS,EAAE,eAAe,EAAE,CAAC,CAAC;KACnE,CAAC;CACH,CAAC,CAAA;AAEF,MAAM,CAAC,MAAM,2BAA2B,GAAQ;IAC9C,OAAO,EAAE,iBAAiB;IAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,2BAA2B,CAAC;IAC1D,KAAK,EAAE,IAAI;CACZ,CAAA;AAkBD,MAAM,OAAO,2BAA2B;IAUtC,IACI,KAAK,KAAK,OAAO,IAAI,CAAC,MAAM,CAAA,CAAC,CAAC;IAClC,IAAI,KAAK,CAAC,KAAyB;QACjC,MAAM,MAAM,GAAG,CAAE,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,CAAE,CAAA;QACnC,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE;YACtB,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,EAAE;gBACzB,IAAI,CAAC,CAAC,IAAI,KAAK,SAAS,EAAE;oBACxB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAA;iBACpE;gBACD,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,IAAI,CAAA;aACjB;SACF;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAA;QACxB,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE;YACjC,IAAI,CAAC,mBAAmB,GAAG,CAAC,IAAI,CAAC,mBAAmB,CAAA;SACrD;aAAM;YACL,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE;gBACtB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,IAAI,CAAC,EAAE;oBACtC,IAAI,CAAC,mBAAmB,GAAG,CAAC,IAAI,CAAC,mBAAmB,CAAA;oBACpD,MAAK;iBACN;aACF;SACF;QAED,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;IACtB,CAAC;IAwBD,YACmB,SAAmB,EACnB,IAAuB,EACvB,SAAoB,EACpB,WAAuB;QAHvB,cAAS,GAAT,SAAS,CAAU;QACnB,SAAI,GAAJ,IAAI,CAAmB;QACvB,cAAS,GAAT,SAAS,CAAW;QACpB,gBAAW,GAAX,WAAW,CAAY;QAvDjC,WAAM,GAAsB,MAAM,CAAA;QA4BnC,WAAM,GAAuB,EAAE,CAAA;QAKd,aAAQ,GAAG,KAAK,CAAA;QAChB,aAAQ,GAAG,KAAK,CAAA;QAChB,wBAAmB,GAAG,IAAI,CAAA;QAC1B,iBAAY,GAAG,KAAK,CAAA;QACpB,qBAAgB,GAAG,IAAI,CAAA;QACvB,uBAAkB,GAAY,IAAI,CAAC,SAAS,CAAC,GAAG,CAAA;QAEzE,4DAA4D;QACzC,WAAM,GAAG,IAAI,YAAY,EAAiC,CAAA;QAE7E,wBAAmB,GAAG,KAAK,CAAA;IAavB,CAAC;IAEL,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,GAAG,CAAA;IACjB,CAAC;IAED,IAAI,KAAK,CAAC,KAAoC;QAC5C,IAAI,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAE,GAAG,CAAC,KAAiB,IAAI,EAAE,CAAC,CAAE,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAA;QAE3E,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,CAAA;QAE7E,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;YACvB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;YAC1B,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAA;SACzB;QACD,IAAI,IAAI,CAAC,SAAS,EAAE;YAAE,IAAI,CAAC,SAAS,EAAE,CAAA;SAAE;IAC1C,CAAC;IAED,UAAU,CAAC,KAAU;QACnB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;IACpB,CAAC;IAED,gBAAgB,CAAC,EAAO;QACtB,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAA;IACpB,CAAC;IAED,iBAAiB,CAAC,EAAO;QACvB,IAAI,CAAC,SAAS,GAAG,EAAE,CAAA;IACrB,CAAC;IAED,gBAAgB,CAAC,UAAmB;QAClC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAA;IAC5B,CAAC;IAED,cAAc,CAAC,KAAiB,EAAE,IAAsB;QACtD,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAA;IAC/B,CAAC;IAEM,UAAU,CAAC,IAAsB;QACtC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAClB,IAAI,IAAI,CAAC,KAAK,KAAK,IAAI,CAAC,KAAK,EAAE;gBAC7B,OAAO,IAAI,CAAA;aACZ;SACF;aAAM;YACL,IAAI,IAAI,CAAC,KAAK,EAAE;gBACd,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE;oBAC1B,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,EAAE;wBACpB,OAAO,IAAI,CAAA;qBACZ;iBACF;aACF;SACF;QAED,OAAO,KAAK,CAAA;IACd,CAAC;IAEM,kBAAkB,CAAC,IAAsB;QAC9C,IAAI,CAAC,IAAI,CAAC,mBAAmB,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YACtD,OAAM;SACP;QAED,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;YACzB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;SACxB;aAAM;YACL,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;SACtB;IACH,CAAC;IAEM,UAAU,CAAC,IAAsB;QACtC,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE;gBAC1B,MAAM,KAAK,GAAa,IAAI,CAAC,KAAiB,IAAI,EAAE,CAAA;gBACpD,IAAI,CAAC,KAAK,GAAG,CAAE,GAAG,WAAW,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,KAAK,CAAE,CAAA;aACnD;SACF;aAAM;YACL,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAA;SACxB;IACH,CAAC;IAEM,YAAY,CAAC,IAAsB;QACxC,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,MAAM,KAAK,GAAa,IAAI,CAAC,KAAiB,IAAI,EAAE,CAAA;YACpD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,CAAA;SACjD;aAAM;YACL,IAAI,CAAC,KAAK,GAAG,SAAS,CAAA;SACvB;IACH,CAAC;IAEM,gBAAgB;QACrB,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;IACnD,CAAC;IAED,aAAa,CAAC,IAAsB;QAClC,+CAA+C;QAC/C,OAAO,CAAC,IAAI,CAAC,WAAW,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,EAAE,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,CAAA;IACzE,CAAC;;wHAjKU,2BAA2B;4GAA3B,2BAA2B,wZAZ3B,CAAE,2BAA2B,CAAE,sDAqEzB,+BAA+B,6BClGlD,kjCA4BA,uvCDKc;QACV,OAAO,CAAC,OAAO,EAAE;YACf,UAAU,CAAC,QAAQ,EAAE;gBACnB,KAAK,CAAC,QAAQ,EAAE,YAAY,CAAC,mBAAmB,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;aACvE,CAAC;SACH,CAAC;KACH;AA4CwB;IAAf,YAAY,EAAE;6DAAiB;AAChB;IAAf,YAAY,EAAE;6DAAiB;AAChB;IAAf,YAAY,EAAE;wEAA2B;AAC1B;IAAf,YAAY,EAAE;iEAAqB;AACpB;IAAf,YAAY,EAAE;qEAAwB;AACvB;IAAf,YAAY,EAAE;uEAAiD;2FA/C9D,2BAA2B;kBAhBvC,SAAS;+BACE,mBAAmB,aAGlB,CAAE,2BAA2B,CAAE,QACpC;wBACJ,oBAAoB,EAAE,gBAAgB;qBACvC,cACW;wBACV,OAAO,CAAC,OAAO,EAAE;4BACf,UAAU,CAAC,QAAQ,EAAE;gCACnB,KAAK,CAAC,QAAQ,EAAE,YAAY,CAAC,mBAAmB,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;6BACvE,CAAC;yBACH,CAAC;qBACH;gLAWQ,MAAM;sBAAd,KAAK;gBAEF,KAAK;sBADR,KAAK;gBA8BU,GAAG;sBAAlB,KAAK;uBAAC,OAAO;gBAEW,QAAQ;sBAAhC,KAAK;gBACmB,QAAQ;sBAAhC,KAAK;gBACmB,mBAAmB;sBAA3C,KAAK;gBACmB,YAAY;sBAApC,KAAK;gBACmB,gBAAgB;sBAAxC,KAAK;gBACmB,kBAAkB;sBAA1C,KAAK;gBAGa,MAAM;sBAAxB,MAAM;gBAQA,WAAW;sBADjB,eAAe;uBAAC,+BAA+B","sourcesContent":["import { animate, animation, query, stagger, style, transition, trigger, useAnimation } from '@angular/animations'\nimport { BooleanInput, coerceArray } from '@angular/cdk/coercion'\nimport { Platform } from '@angular/cdk/platform'\nimport { ChangeDetectorRef, Component, ContentChildren, ElementRef, EventEmitter, forwardRef, Input, Output, QueryList, Renderer2 } from '@angular/core'\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms'\n\nimport { InputBoolean } from '@theseam/ui-common/core'\n\nimport { TiledSelectTileOverlayDirective } from './../../directives/tiled-select-tile-overlay.directive'\n\nimport { ITiledSelectItem, TiledSelectLayout } from '../../tiled-select.models'\n\nexport const slideEnterAnimation = animation([\n  style({ opacity: 0, transform: 'translateX(-15px)' }),\n  stagger(100, [\n    animate('0.5s', style({ opacity: 1, transform: 'translateX(0)' }))\n  ])\n])\n\nexport const TILED_SELECT_VALUE_ACCESSOR: any = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => TheSeamTiledSelectComponent),\n  multi: true,\n}\n\n@Component({\n  selector: 'seam-tiled-select',\n  templateUrl: './tiled-select.component.html',\n  styleUrls: ['./tiled-select.component.scss'],\n  providers: [ TILED_SELECT_VALUE_ACCESSOR ],\n  host: {\n    '[attr.data-testid]': '\"tiled-select\"'\n  },\n  animations: [\n    trigger('tiles', [\n      transition('* => *', [\n        query(':enter', useAnimation(slideEnterAnimation), { optional: true })\n      ])\n    ])\n  ],\n})\nexport class TheSeamTiledSelectComponent implements ControlValueAccessor {\n  static ngAcceptInputType_val: BooleanInput\n  static ngAcceptInputType_disabled: BooleanInput\n  static ngAcceptInputType_multiple: BooleanInput\n  static ngAcceptInputType_selectionToggleable: BooleanInput\n  static ngAcceptInputType_tileBackdrop: BooleanInput\n  static ngAcceptInputType_showSelectedIcon: BooleanInput\n  static ngAcceptInputType_animationsDisabled: BooleanInput\n\n  @Input() layout: TiledSelectLayout = 'grid'\n  @Input()\n  get tiles() { return this._tiles }\n  set tiles(value: ITiledSelectItem[]) {\n    const _value = [ ...(value || []) ]\n    for (const v of _value) {\n      if (v.value === undefined) {\n        if (v.name === undefined) {\n          throw new Error('If value is undefined then name must be defined.')\n        }\n        v.value = v.name\n      }\n    }\n\n    const prev = this._tiles\n    if (prev.length !== _value.length) {\n      this.tilesAnimationState = !this.tilesAnimationState\n    } else {\n      for (const t of _value) {\n        if (!prev.find(p => p.name === t.name)) {\n          this.tilesAnimationState = !this.tilesAnimationState\n          break\n        }\n      }\n    }\n\n    this._tiles = _value\n  }\n  private _tiles: ITiledSelectItem[] = []\n\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('value') val: string | string[] | undefined\n\n  @Input() @InputBoolean() disabled = false\n  @Input() @InputBoolean() multiple = false\n  @Input() @InputBoolean() selectionToggleable = true\n  @Input() @InputBoolean() tileBackdrop = false\n  @Input() @InputBoolean() showSelectedIcon = true\n  @Input() @InputBoolean() animationsDisabled: boolean = this._platform.IOS\n\n  // eslint-disable-next-line @angular-eslint/no-output-native\n  @Output() readonly change = new EventEmitter<string | string[] | undefined>()\n\n  tilesAnimationState = false\n\n  onChange: any\n  onTouched: any\n\n  @ContentChildren(TiledSelectTileOverlayDirective)\n  public overlayTpls?: QueryList<TiledSelectTileOverlayDirective>\n\n  constructor(\n    private readonly _platform: Platform,\n    private readonly _cdr: ChangeDetectorRef,\n    private readonly _renderer: Renderer2,\n    private readonly _elementRef: ElementRef\n  ) { }\n\n  get value(): string | string[] | undefined {\n    return this.val\n  }\n\n  set value(value: string | string[] | undefined) {\n    this.val = (this.multiple) ? [ ...(value as string[] || []) ] : value || ''\n\n    this._renderer.setProperty(this._elementRef.nativeElement, 'value', this.val)\n\n    if (this.onChange) {\n      this.onChange(this.val)\n      this.change.emit(this.val)\n      this._cdr.markForCheck()\n    }\n    if (this.onTouched) { this.onTouched() }\n  }\n\n  writeValue(value: any): void {\n    this.value = value\n  }\n\n  registerOnChange(fn: any): void {\n    this.onChange = fn\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled\n  }\n\n  onTileSelected(event: MouseEvent, tile: ITiledSelectItem) {\n    this.toggleTileSelected(tile)\n  }\n\n  public isSelected(tile: ITiledSelectItem) {\n    if (!this.multiple) {\n      if (this.value === tile.value) {\n        return true\n      }\n    } else {\n      if (this.value) {\n        for (const v of this.value) {\n          if (v === tile.value) {\n            return true\n          }\n        }\n      }\n    }\n\n    return false\n  }\n\n  public toggleTileSelected(tile: ITiledSelectItem): void {\n    if (!this.selectionToggleable && this.isSelected(tile)) {\n      return\n    }\n\n    if (this.isSelected(tile)) {\n      this.unselectTile(tile)\n    } else {\n      this.selectTile(tile)\n    }\n  }\n\n  public selectTile(tile: ITiledSelectItem): void {\n    if (this.multiple) {\n      if (!this.isSelected(tile)) {\n        const value: string[] = this.value as string[] || []\n        this.value = [ ...coerceArray(value), tile.value ]\n      }\n    } else {\n      this.value = tile.value\n    }\n  }\n\n  public unselectTile(tile: ITiledSelectItem): void {\n    if (this.multiple) {\n      const value: string[] = this.value as string[] || []\n      this.value = value.filter(v => v !== tile.value)\n    } else {\n      this.value = undefined\n    }\n  }\n\n  public getSelectedTiles(): ITiledSelectItem[] {\n    return this.tiles.filter(t => this.isSelected(t))\n  }\n\n  getOverlayTpl(tile: ITiledSelectItem): TiledSelectTileOverlayDirective | undefined {\n    // console.log('overlayTpls', this.overlayTpls)\n    return (this.overlayTpls || []).find(t => t.record?.name === tile.name)\n  }\n\n}\n\n/** @deprecated Use `TheSeamTiledSelectComponent`. */\nexport type TiledSelectComponent = TheSeamTiledSelectComponent\n","<div class=\"tiled-select--container\"\n  [class.grid]=\"layout === 'grid'\"\n  [class.list]=\"layout === 'list'\"\n  [@tiles]=\"tilesAnimationState\"\n  [@.disabled]=\"animationsDisabled\">\n  <ng-container *ngFor=\"let tile of tiles; let index = index\">\n    <div class=\"tile-wrapper\" [ngClass]=\"tile.customClass || ''\">\n      <seam-tiled-select-tile\n        class=\"tiled-select-tile\"\n        [ngClass]=\"tile.customClass || ''\"\n        [name]=\"tile.name\"\n        [label]=\"tile.label\"\n        [icon]=\"tile.icon\"\n        [disabled]=\"disabled || tile.disabled\"\n        [attr.hidden]=\"tile.hidden\"\n        [layout]=\"layout\"\n        [selected]=\"isSelected(tile)\"\n        [selectable]=\"true\"\n        [tileBackdrop]=\"tileBackdrop\"\n        [showSelectedIcon]=\"showSelectedIcon\"\n        [overlayTpl]=\"getOverlayTpl(tile)\"\n        (activated)=\"onTileSelected($event, tile)\"\n        [attr.data-tile-index]=\"index\"\n        [attr.data-testid]=\"tile.name\">\n      </seam-tiled-select-tile>\n    </div>\n  </ng-container>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tiled-select.component.js","sourceRoot":"","sources":["../../../../../../projects/ui-common/tiled-select/components/tiled-select/tiled-select.component.ts","../../../../../../projects/ui-common/tiled-select/components/tiled-select/tiled-select.component.html"],"names":[],"mappings":"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","sourcesContent":["import { animate, animation, query, stagger, style, transition, trigger, useAnimation } from '@angular/animations'\nimport { BooleanInput, coerceArray } from '@angular/cdk/coercion'\nimport { Platform } from '@angular/cdk/platform'\nimport { ChangeDetectorRef, Component, ContentChildren, ElementRef, EventEmitter, forwardRef, Input, Output, QueryList, Renderer2 } from '@angular/core'\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms'\n\nimport { InputBoolean } from '@theseam/ui-common/core'\n\nimport { TiledSelectTileOverlayDirective } from './../../directives/tiled-select-tile-overlay.directive'\n\nimport { TiledSelectItem, TiledSelectLayout } from '../../tiled-select.models'\n\nexport const slideEnterAnimation = animation([\n  style({ opacity: 0, transform: 'translateX(-15px)' }),\n  stagger(100, [\n    animate('0.5s', style({ opacity: 1, transform: 'translateX(0)' }))\n  ])\n])\n\nexport const TILED_SELECT_VALUE_ACCESSOR: any = {\n  provide: NG_VALUE_ACCESSOR,\n  useExisting: forwardRef(() => TheSeamTiledSelectComponent),\n  multi: true,\n}\n\n@Component({\n  selector: 'seam-tiled-select',\n  templateUrl: './tiled-select.component.html',\n  styleUrls: ['./tiled-select.component.scss'],\n  providers: [ TILED_SELECT_VALUE_ACCESSOR ],\n  host: {\n    '[attr.data-testid]': '\"tiled-select\"'\n  },\n  animations: [\n    trigger('tiles', [\n      transition('* => *', [\n        query(':enter', useAnimation(slideEnterAnimation), { optional: true })\n      ])\n    ])\n  ],\n})\nexport class TheSeamTiledSelectComponent implements ControlValueAccessor {\n  static ngAcceptInputType_val: BooleanInput\n  static ngAcceptInputType_disabled: BooleanInput\n  static ngAcceptInputType_multiple: BooleanInput\n  static ngAcceptInputType_selectionToggleable: BooleanInput\n  static ngAcceptInputType_tileBackdrop: BooleanInput\n  static ngAcceptInputType_showSelectedIcon: BooleanInput\n  static ngAcceptInputType_animationsDisabled: BooleanInput\n\n  @Input() layout: TiledSelectLayout = 'grid'\n  @Input()\n  get tiles() { return this._tiles }\n  set tiles(value: TiledSelectItem[]) {\n    const _value = [ ...(value || []) ]\n    for (const v of _value) {\n      if (v.value === undefined) {\n        if (v.name === undefined) {\n          throw new Error('If value is undefined then name must be defined.')\n        }\n        v.value = v.name\n      }\n    }\n\n    const prev = this._tiles\n    if (prev.length !== _value.length) {\n      this.tilesAnimationState = !this.tilesAnimationState\n    } else {\n      for (const t of _value) {\n        if (!prev.find(p => p.name === t.name)) {\n          this.tilesAnimationState = !this.tilesAnimationState\n          break\n        }\n      }\n    }\n\n    this._tiles = _value\n  }\n  private _tiles: TiledSelectItem[] = []\n\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('value') val: string | string[] | undefined\n\n  @Input() @InputBoolean() disabled = false\n  @Input() @InputBoolean() multiple = false\n  @Input() @InputBoolean() selectionToggleable = true\n  @Input() @InputBoolean() tileBackdrop = false\n  @Input() @InputBoolean() showSelectedIcon = true\n  @Input() @InputBoolean() animationsDisabled: boolean = this._platform.IOS\n\n  // eslint-disable-next-line @angular-eslint/no-output-native\n  @Output() readonly change = new EventEmitter<string | string[] | undefined>()\n\n  tilesAnimationState = false\n\n  onChange: any\n  onTouched: any\n\n  @ContentChildren(TiledSelectTileOverlayDirective)\n  public overlayTpls?: QueryList<TiledSelectTileOverlayDirective>\n\n  constructor(\n    private readonly _platform: Platform,\n    private readonly _cdr: ChangeDetectorRef,\n    private readonly _renderer: Renderer2,\n    private readonly _elementRef: ElementRef\n  ) { }\n\n  get value(): string | string[] | undefined {\n    return this.val\n  }\n\n  set value(value: string | string[] | undefined) {\n    this.val = (this.multiple) ? [ ...(value as string[] || []) ] : value || ''\n\n    this._renderer.setProperty(this._elementRef.nativeElement, 'value', this.val)\n\n    if (this.onChange) {\n      this.onChange(this.val)\n      this.change.emit(this.val)\n      this._cdr.markForCheck()\n    }\n    if (this.onTouched) { this.onTouched() }\n  }\n\n  writeValue(value: any): void {\n    this.value = value\n  }\n\n  registerOnChange(fn: any): void {\n    this.onChange = fn\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled\n  }\n\n  onTileSelected(event: MouseEvent, tile: TiledSelectItem) {\n    this.toggleTileSelected(tile)\n  }\n\n  public isSelected(tile: TiledSelectItem) {\n    if (!this.multiple) {\n      if (this.value === tile.value) {\n        return true\n      }\n    } else {\n      if (this.value) {\n        for (const v of this.value) {\n          if (v === tile.value) {\n            return true\n          }\n        }\n      }\n    }\n\n    return false\n  }\n\n  public toggleTileSelected(tile: TiledSelectItem): void {\n    if (!this.selectionToggleable && this.isSelected(tile)) {\n      return\n    }\n\n    if (this.isSelected(tile)) {\n      this.unselectTile(tile)\n    } else {\n      this.selectTile(tile)\n    }\n  }\n\n  public selectTile(tile: TiledSelectItem): void {\n    if (this.multiple) {\n      if (!this.isSelected(tile)) {\n        const value: string[] = this.value as string[] || []\n        this.value = [ ...coerceArray(value), tile.value ]\n      }\n    } else {\n      this.value = tile.value\n    }\n  }\n\n  public unselectTile(tile: TiledSelectItem): void {\n    if (this.multiple) {\n      const value: string[] = this.value as string[] || []\n      this.value = value.filter(v => v !== tile.value)\n    } else {\n      this.value = undefined\n    }\n  }\n\n  public getSelectedTiles(): TiledSelectItem[] {\n    return this.tiles.filter(t => this.isSelected(t))\n  }\n\n  getOverlayTpl(tile: TiledSelectItem): TiledSelectTileOverlayDirective | undefined {\n    // console.log('overlayTpls', this.overlayTpls)\n    return (this.overlayTpls || []).find(t => t.record?.name === tile.name)\n  }\n\n}\n\n/** @deprecated Use `TheSeamTiledSelectComponent`. */\nexport type TiledSelectComponent = TheSeamTiledSelectComponent\n","<div class=\"tiled-select--container\"\n  [class.grid]=\"layout === 'grid'\"\n  [class.list]=\"layout === 'list'\"\n  [@tiles]=\"tilesAnimationState\"\n  [@.disabled]=\"animationsDisabled\">\n  <ng-container *ngFor=\"let tile of tiles; let index = index\">\n    <div class=\"tile-wrapper\" [ngClass]=\"tile.customClass || ''\">\n      <seam-tiled-select-tile\n        class=\"tiled-select-tile\"\n        [ngClass]=\"tile.customClass || ''\"\n        [name]=\"tile.name\"\n        [label]=\"tile.label\"\n        [icon]=\"tile.icon\"\n        [disabled]=\"disabled || tile.disabled\"\n        [attr.hidden]=\"tile.hidden\"\n        [layout]=\"layout\"\n        [selected]=\"isSelected(tile)\"\n        [selectable]=\"true\"\n        [tileBackdrop]=\"tileBackdrop\"\n        [showSelectedIcon]=\"showSelectedIcon\"\n        [overlayTpl]=\"getOverlayTpl(tile)\"\n        (activated)=\"onTileSelected($event, tile)\"\n        [attr.data-tile-index]=\"index\"\n        [attr.data-testid]=\"tile.name\">\n      </seam-tiled-select-tile>\n    </div>\n  </ng-container>\n</div>\n"]}

package/fesm2015/theseam-ui-common-buttons.mjs

@@ -1,14 +1,191 @@
+import { __awaiter, __decorate } from 'tslib';
+import { ThemeNames, OutlineThemeNames } from '@theseam/ui-common/models';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { HarnessPredicate, ContentContainerComponentHarness } from '@angular/cdk/testing';
 import * as i0 from '@angular/core';
 import { Component, ChangeDetectionStrategy, Input, HostBinding, forwardRef, EventEmitter, Output, NgModule } from '@angular/core';
 import { mixinSize, mixinTheme, mixinDisabled, InputBoolean, InputNumber } from '@theseam/ui-common/core';
 import * as i1 from '@angular/cdk/a11y';
-import { __decorate } from 'tslib';
 import * as i2 from '@theseam/ui-common/progress';
 import { TheSeamProgressModule } from '@theseam/ui-common/progress';
-import { coerceBooleanProperty } from '@angular/cdk/coercion';
 import { NG_VALUE_ACCESSOR } from '@angular/forms';
 import { CommonModule } from '@angular/common';
 
+const THEME_NAMES$1 = [...ThemeNames, ...OutlineThemeNames];
+const THEME_CLASSES$1 = THEME_NAMES$1.map(t => `btn-${t}`);
+function getButtonThemeClass(classListString) {
+    return ((classListString === null || classListString === void 0 ? void 0 : classListString.split(' ')) || []).find(c => THEME_CLASSES$1.includes(c));
+}
+function createBaseButtonComponentHarnessPredicate(componentHarness, options = {}) {
+    return new HarnessPredicate(componentHarness, options)
+        .addOption('text', options.text, (harness, text) => HarnessPredicate.stringMatches(harness.getText(), text))
+        .addOption('type', options.type, (harness, type) => HarnessPredicate.stringMatches(harness.getType(), type));
+}
+class TheSeamBaseButtonComponentHarness extends ContentContainerComponentHarness {
+    /** Whether the button is disabled. */
+    isDisabled() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const disabled = (yield this.host()).getAttribute('disabled');
+            return coerceBooleanProperty(yield disabled);
+        });
+    }
+    hasDisabledAria() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ariaValue = yield (yield this.host()).getAttribute('aria-disabled');
+            return ariaValue === 'true';
+        });
+    }
+    getType() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).getAttribute('type');
+        });
+    }
+    /** Gets the text of the button item. */
+    getText() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).text();
+        });
+    }
+    /** Gets the theme of the button item. */
+    getTheme() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).getAttribute('class').then(c => { var _a; return ((_a = getButtonThemeClass(c)) === null || _a === void 0 ? void 0 : _a.replace('btn-', '')) || null; });
+        });
+    }
+    click() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).click();
+        });
+    }
+}
+
+const THEME_NAMES = [...ThemeNames, ...OutlineThemeNames];
+const THEME_CLASSES = THEME_NAMES.map(t => `badge-${t}`);
+function getbadgeThemeClass(classListString) {
+    return ((classListString === null || classListString === void 0 ? void 0 : classListString.split(' ')) || []).find(c => THEME_CLASSES.includes(c));
+}
+function createBaseBadgeButtonComponentHarnessPredicate(componentHarness, options = {}) {
+    return createBaseButtonComponentHarnessPredicate(componentHarness, options);
+}
+class TheSeamBaseBadgeButtonComponentHarness extends TheSeamBaseButtonComponentHarness {
+    constructor() {
+        super(...arguments);
+        this._badgeElement = this.locatorFor('.badge');
+    }
+    /** Gets the text of the button item. */
+    getText() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).text({ exclude: '.badge' });
+        });
+    }
+    /** Gets the text of the badge. */
+    getBadgeText() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this._badgeElement()).text();
+        });
+    }
+    /** Gets the theme of the badge. */
+    getBadgeTheme() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this._badgeElement()).getAttribute('class').then(c => { var _a; return ((_a = getbadgeThemeClass(c)) === null || _a === void 0 ? void 0 : _a.replace('badge-', '')) || null; });
+        });
+    }
+}
+
+class TheSeamAnchorBadgeButtonComponentHarness extends TheSeamBaseBadgeButtonComponentHarness {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a button item with specific attributes.
+     * @param options Options for filtering which button item instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return createBaseBadgeButtonComponentHarnessPredicate(this, options);
+    }
+    getTabIndex() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tabIndex = yield (yield this.host()).getAttribute('tabindex');
+            return Number(tabIndex);
+        });
+    }
+}
+/** The selector for the host element of a `TheSeamAnchorBadgeButtonComponent` instance. */
+TheSeamAnchorBadgeButtonComponentHarness.hostSelector = 'a[seamBadgeButton]';
+
+class TheSeamAnchorButtonComponentHarness extends TheSeamBaseButtonComponentHarness {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a button item with specific attributes.
+     * @param options Options for filtering which button item instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return createBaseButtonComponentHarnessPredicate(this, options);
+    }
+    getTabIndex() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tabIndex = yield (yield this.host()).getAttribute('tabindex');
+            return Number(tabIndex);
+        });
+    }
+}
+/** The selector for the host element of a `TheSeamAnchorButtonComponent` instance. */
+TheSeamAnchorButtonComponentHarness.hostSelector = 'a[seamButton]';
+
+class TheSeamBadgeButtonComponentHarness extends TheSeamBaseBadgeButtonComponentHarness {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a button item with specific attributes.
+     * @param options Options for filtering which button item instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return createBaseBadgeButtonComponentHarnessPredicate(this, options);
+    }
+}
+/** The selector for the host element of a `TheSeamBadgeButtonComponent` instance. */
+TheSeamBadgeButtonComponentHarness.hostSelector = 'button[seamBadgeButton]';
+
+// import { TheSeamMenuHarness } from './button.harness'
+// import { animatingWait } from './utils'
+class TheSeamButtonComponentHarness extends TheSeamBaseButtonComponentHarness {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a button item with specific attributes.
+     * @param options Options for filtering which button item instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return createBaseButtonComponentHarnessPredicate(this, options);
+    }
+}
+/** The selector for the host element of a `TheSeamButtonComponent` instance. */
+TheSeamButtonComponentHarness.hostSelector = 'button[seamButton]';
+
+class TheSeamToggleButtonComponentHarness extends TheSeamBaseButtonComponentHarness {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a button item with specific attributes.
+     * @param options Options for filtering which button item instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return createBaseButtonComponentHarnessPredicate(this, options);
+    }
+    /**
+     * Clicks the button.
+     */
+    click() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).click();
+        });
+    }
+    /** Gets the theme of the button item. */
+    isActive() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).getAttribute('class')
+                .then(c => ((c === null || c === void 0 ? void 0 : c.split(' ').indexOf('active')) !== -1) || false);
+        });
+    }
+}
+/** The selector for the host element of a `TheSeamToggleButtonComponent` instance. */
+TheSeamToggleButtonComponentHarness.hostSelector = 'button[seamToggleButton]';
+
 class TheSeamButtonBase {
     constructor(_elementRef, _focusMonitor, _renderer) {
         this._elementRef = _elementRef;
@@ -80,6 +257,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
             type: Component,
             args: [{ selector: 'a[seamButton]', exportAs: 'seamButton,seamButtonBaseAnchor', inputs: ['disabled', 'theme', 'size'], host: {
                         'class': 'btn',
+                        // '[class.disabled]': 'disabled || null',
                         '[attr.tabindex]': 'disabled ? -1 : (tabIndex || 0)',
                         '[attr.disabled]': 'disabled || null',
                         '[attr.aria-disabled]': 'disabled.toString()',
@@ -310,5 +488,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { TOGGLE_BUTTON_VALUE_ACCESSOR, TheSeamAnchorBadgeButtonComponent, TheSeamAnchorButtonComponent, TheSeamBadgeButtonComponent, TheSeamButtonComponent, TheSeamButtonsModule, TheSeamProgressCircleButtonComponent, TheSeamToggleButtonComponent };
+export { TOGGLE_BUTTON_VALUE_ACCESSOR, TheSeamAnchorBadgeButtonComponent, TheSeamAnchorBadgeButtonComponentHarness, TheSeamAnchorButtonComponent, TheSeamAnchorButtonComponentHarness, TheSeamBadgeButtonComponent, TheSeamBadgeButtonComponentHarness, TheSeamButtonComponent, TheSeamButtonComponentHarness, TheSeamButtonsModule, TheSeamProgressCircleButtonComponent, TheSeamToggleButtonComponent, TheSeamToggleButtonComponentHarness };
 //# sourceMappingURL=theseam-ui-common-buttons.mjs.map