haya-select 1.0.116 → 1.0.118

package/README.md

@@ -76,6 +76,20 @@ The callback receives the current `searchValue`, `page`, and optional `values` w
 
 If `totalCount` and `page` are provided, the options list shows pagination controls with previous/next buttons, a page range around the current page, and a "Page X of Y" label that can be clicked to enter a page number manually.
 
+## System test helpers
+
+Browser system-test suites can import helpers from the dedicated test-helper entrypoint:
+
+```js
+import {pickHayaSelectOption} from "haya-select/build/system-test-helpers.js"
+```
+
+The helper entrypoint exports:
+
+- `pickHayaSelectOption(systemTest, testID, {optionText, optionValue, search})`
+- `clickVisibleHayaSelectOption(systemTest, {optionValue})`
+- `expectHayaSelectCurrentOptions(systemTest, testID, expectedTexts)`
+
 ## Mobile options sheet
 
 HayaSelect opens options in a bottom sheet on mobile-sized screens by default. The sheet is used when the window width is 768px or less on web, iOS, and Android. It keeps the options list scrollable inside the sheet and places the search input at the bottom. When pagination is enabled, the pagination controls stay fixed above the search input instead of scrolling with the options.

package/build/system-test-helpers.d.ts

@@ -1,4 +1,28 @@
-/** @typedef {{systemTest: object, testId: string}} HayaSelectSystemTestHelperOptions */
+/**
+ * Selects an option in a HayaSelect instance.
+ * @param {object} systemTest Browser session used by the running spec.
+ * @param {string} testId Wrapper `data-testid` around the select.
+ * @param {PickHayaSelectOptionOptions} options Text/value to choose and whether to type into the search field first.
+ * @returns {Promise<void>} Completes after the matching visible option is clicked.
+ * @rejects {Error} When neither text nor value is supplied.
+ */
+export function pickHayaSelectOption(systemTest: object, testId: string, { optionText, optionValue, search, timeout, useBaseSelector }: PickHayaSelectOptionOptions): Promise<void>;
+/**
+ * Clicks an option in an already-open HayaSelect dropdown.
+ * @param {object} systemTest Browser session used by the running spec.
+ * @param {ClickVisibleHayaSelectOptionOptions} options Option value to choose.
+ * @returns {Promise<void>} Completes after the matching visible option is clicked.
+ */
+export function clickVisibleHayaSelectOption(systemTest: object, { optionValue, timeout }: ClickVisibleHayaSelectOptionOptions): Promise<void>;
+/**
+ * Waits until a HayaSelect renders exactly the expected current-option labels.
+ * @param {object} systemTest Browser session used by the running spec.
+ * @param {string} testId Wrapper `data-testid` around the select.
+ * @param {string[]} expectedTexts Current option text fragments in rendered order.
+ * @param {ExpectHayaSelectCurrentOptionsOptions} [options] Optional Selenium timeout override.
+ * @returns {Promise<void>} Completes after the current options match.
+ */
+export function expectHayaSelectCurrentOptions(systemTest: object, testId: string, expectedTexts: string[], { timeout }?: ExpectHayaSelectCurrentOptionsOptions): Promise<void>;
 /**
  * System test helper for interacting with HayaSelect instances.
  */
@@ -50,4 +74,19 @@ export type HayaSelectSystemTestHelperOptions = {
     systemTest: object;
     testId: string;
 };
+export type PickHayaSelectOptionOptions = {
+    optionText?: string;
+    optionValue?: string | number;
+    search?: boolean;
+    timeout?: number;
+    useBaseSelector?: boolean;
+};
+export type ClickVisibleHayaSelectOptionOptions = {
+    optionValue: string | number;
+    timeout?: number;
+};
+export type ExpectHayaSelectCurrentOptionsOptions = {
+    timeout?: number;
+};
+export type WebElement = any;
 //# sourceMappingURL=system-test-helpers.d.ts.map

package/build/system-test-helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system-test-helpers.d.ts","sourceRoot":"","sources":["../src/system-test-helpers.js"],"names":[],"mappings":"AAGA,wFAAwF;AAExF;;GAEG;AACH;IACE,yDAAyD;IACzD,qBADY,iCAAiC,EAqB5C;IARC,gBAA4B;IAC5B,eAAoB;IACpB,qBAA+C;IAC/C,0BAA2E;IAC3E,iCAAoG;IACpG,gCAAkG;IAClG,4BAA0F;IAC1F,yCAAuF;IAGzF,+BAA+B;IAC/B,QADc,OAAO,CAAC,IAAI,CAAC,CAY1B;IATC,qDAAqC;IAWvC,+BAA+B;IAC/B,SADc,OAAO,CAAC,IAAI,CAAC,CAW1B;IAED,kCAAkC;IAClC,UADc,OAAO,CAAC,OAAO,CAAC,CAS7B;IAED,+BAA+B;IAC/B,wBADc,OAAO,CAAC,IAAI,CAAC,CAK1B;IAED;;;OAGG;IACH,uBAHW,MAAM,GACJ,OAAO,CAAC,KAAK,CAAC,GAAuC,CAAC,CAAC,CAInE;IAED;;;OAGG;IACH,8BAHW,MAAM,GACJ,OAAO,CAAC,KAAK,CAAC,GAAuC,CAAC,CAAC,CAanE;IAED,iCAAiC;IACjC,4BADc,OAAO,CAAC,MAAM,CAAC,CAiB5B;IAED,mCAAmC;IACnC,eADc,OAAO,CAAC,MAAM,EAAE,CAAC,CAM9B;IAED;;;OAGG;IACH,mDAHW;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,GAAC,MAAM,CAAA;KAAC,mBACpD,OAAO,CAAC,IAAI,CAAC,CA6DzB;CACF;gDA9La;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC"}
+{"version":3,"file":"system-test-helpers.d.ts","sourceRoot":"","sources":["../src/system-test-helpers.js"],"names":[],"mappings":"AAWA;;;;;;;GAOG;AACH,iDANW,MAAM,UACN,MAAM,iEACN,2BAA2B,GACzB,OAAO,CAAC,IAAI,CAAC,CA8BzB;AAED;;;;;GAKG;AACH,yDAJW,MAAM,4BACN,mCAAmC,GACjC,OAAO,CAAC,IAAI,CAAC,CAIzB;AAED;;;;;;;GAOG;AACH,2DANW,MAAM,UACN,MAAM,iBACN,MAAM,EAAE,gBACR,qCAAqC,GACnC,OAAO,CAAC,IAAI,CAAC,CAyBzB;AAED;;GAEG;AACH;IACE,yDAAyD;IACzD,qBADY,iCAAiC,EAqB5C;IARC,gBAA4B;IAC5B,eAAoB;IACpB,qBAA0C;IAC1C,0BAA2E;IAC3E,iCAAoG;IACpG,gCAAkG;IAClG,4BAA0F;IAC1F,yCAAuF;IAGzF,+BAA+B;IAC/B,QADc,OAAO,CAAC,IAAI,CAAC,CAY1B;IATC,qDAAqC;IAWvC,+BAA+B;IAC/B,SADc,OAAO,CAAC,IAAI,CAAC,CAW1B;IAED,kCAAkC;IAClC,UADc,OAAO,CAAC,OAAO,CAAC,CAS7B;IAED,+BAA+B;IAC/B,wBADc,OAAO,CAAC,IAAI,CAAC,CAK1B;IAED;;;OAGG;IACH,uBAHW,MAAM,GACJ,OAAO,CAAC,KAAK,CAAC,GAAuC,CAAC,CAAC,CAInE;IAED;;;OAGG;IACH,8BAHW,MAAM,GACJ,OAAO,CAAC,KAAK,CAAC,GAAuC,CAAC,CAAC,CAanE;IAED,iCAAiC;IACjC,4BADc,OAAO,CAAC,MAAM,CAAC,CAW5B;IAED,mCAAmC;IACnC,eADc,OAAO,CAAC,MAAM,EAAE,CAAC,CAM9B;IAED;;;OAGG;IACH,mDAHW;QAAC,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,GAAC,MAAM,CAAA;KAAC,mBACpD,OAAO,CAAC,IAAI,CAAC,CA6DzB;CACF;gDA9Qa;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC;0CACpC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,OAAO,CAAA;CAAC;kDACnH;IAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAC;oDAChD;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAC"}

package/build/system-test-helpers.js

@@ -1,6 +1,75 @@
 import waitFor from "awaitery/build/wait-for.js";
 import { By } from "selenium-webdriver";
 /** @typedef {{systemTest: object, testId: string}} HayaSelectSystemTestHelperOptions */
+/** @typedef {{optionText?: string, optionValue?: string | number, search?: boolean, timeout?: number, useBaseSelector?: boolean}} PickHayaSelectOptionOptions */
+/** @typedef {{optionValue: string | number, timeout?: number}} ClickVisibleHayaSelectOptionOptions */
+/** @typedef {{timeout?: number}} ExpectHayaSelectCurrentOptionsOptions */
+/** @typedef {import("selenium-webdriver").WebElement} WebElement */
+const DEFAULT_TIMEOUT = 5000;
+/**
+ * Selects an option in a HayaSelect instance.
+ * @param {object} systemTest Browser session used by the running spec.
+ * @param {string} testId Wrapper `data-testid` around the select.
+ * @param {PickHayaSelectOptionOptions} options Text/value to choose and whether to type into the search field first.
+ * @returns {Promise<void>} Completes after the matching visible option is clicked.
+ * @rejects {Error} When neither text nor value is supplied.
+ */
+export async function pickHayaSelectOption(systemTest, testId, { optionText, optionValue, search = false, timeout = DEFAULT_TIMEOUT, useBaseSelector = true }) {
+    const helper = new HayaSelectSystemTestHelper({ systemTest, testId });
+    const selectElement = await systemTest.find(helper.selectContainerSelector, { timeout, useBaseSelector });
+    await selectElement.click();
+    if (search) {
+        if (!optionText) {
+            throw new Error(`Expected optionText when searching ${testId}`);
+        }
+        const searchElement = await systemTest.find(helper.searchInputSelector, { timeout, useBaseSelector });
+        await searchElement.sendKeys(optionText);
+    }
+    const optionsContainerSelector = await helper.optionsContainerSelector();
+    if (typeof optionValue !== "undefined") {
+        await clickVisibleSelectOptionByValue(systemTest, optionValue, timeout, optionsContainerSelector);
+        return;
+    }
+    if (optionText) {
+        await clickVisibleSelectOptionByText(systemTest, optionText, timeout, optionsContainerSelector);
+        return;
+    }
+    throw new Error(`Expected optionValue or optionText for ${testId}`);
+}
+/**
+ * Clicks an option in an already-open HayaSelect dropdown.
+ * @param {object} systemTest Browser session used by the running spec.
+ * @param {ClickVisibleHayaSelectOptionOptions} options Option value to choose.
+ * @returns {Promise<void>} Completes after the matching visible option is clicked.
+ */
+export async function clickVisibleHayaSelectOption(systemTest, { optionValue, timeout = DEFAULT_TIMEOUT }) {
+    await clickVisibleSelectOptionByValue(systemTest, optionValue, timeout);
+}
+/**
+ * Waits until a HayaSelect renders exactly the expected current-option labels.
+ * @param {object} systemTest Browser session used by the running spec.
+ * @param {string} testId Wrapper `data-testid` around the select.
+ * @param {string[]} expectedTexts Current option text fragments in rendered order.
+ * @param {ExpectHayaSelectCurrentOptionsOptions} [options] Optional Selenium timeout override.
+ * @returns {Promise<void>} Completes after the current options match.
+ */
+export async function expectHayaSelectCurrentOptions(systemTest, testId, expectedTexts, { timeout = DEFAULT_TIMEOUT } = {}) {
+    const selector = `${testIdSelector(testId)} [data-testid="haya-select/current-option"]`;
+    await systemTest.getDriver().wait(async () => {
+        const elements = await systemTest.getDriver().findElements(By.css(selector));
+        /** @type {string[]} */
+        const visibleTexts = [];
+        for (const element of elements) {
+            if (await element.isDisplayed()) {
+                visibleTexts.push(await element.getText());
+            }
+        }
+        if (visibleTexts.length !== expectedTexts.length) {
+            return false;
+        }
+        return expectedTexts.every((expectedText, index) => visibleTexts[index]?.includes(expectedText));
+    }, timeout, `Timed out waiting for ${testId} current options: ${expectedTexts.join(", ")}`);
+}
 /**
  * System test helper for interacting with HayaSelect instances.
  */
@@ -17,7 +86,7 @@ export default class HayaSelectSystemTestHelper {
         }
         this.systemTest = systemTest;
         this.testId = testId;
-        this.rootSelector = `[data-testid='${testId}']`;
+        this.rootSelector = testIdSelector(testId);
         this.componentSelector = `${this.rootSelector} [data-testid='haya-select']`;
         this.chevronContainerSelector = `${this.rootSelector} [data-testid='haya-select/chevron-container']`;
         this.selectContainerSelector = `${this.rootSelector} [data-testid='haya-select/select-container']`;
@@ -83,14 +152,10 @@ export default class HayaSelectSystemTestHelper {
     async optionsContainerSelector() {
         if (this._optionsContainerSelector)
             return this._optionsContainerSelector;
-        const rootElements = await this.findElements(this.rootSelector);
-        const rootId = rootElements.length > 0 ? await rootElements[0].getAttribute("data-id") : null;
-        let elements = rootElements;
-        if (!rootId) {
-            elements = await this.findElements(this.componentSelector);
-        }
-        const id = rootId || (elements.length > 0 ? await elements[0].getAttribute("data-id") : null);
-        this._optionsContainerSelector = id ? `[data-testid='haya-select/options-container'][data-id='${id}']` : this.optionsContainerSelectorFallback;
+        const openedElements = await this.findElements(`${this.componentSelector}[data-opened='true']`);
+        const componentElements = openedElements.length > 0 ? openedElements : await this.findVisibleElements(this.componentSelector);
+        const id = componentElements.length > 0 ? await componentElements[0].getAttribute("data-id") : null;
+        this._optionsContainerSelector = id ? `[data-testid='haya-select/options-container'][data-id="${cssAttributeValue(id)}"]` : this.optionsContainerSelectorFallback;
         return this._optionsContainerSelector;
     }
     /** @returns {Promise<string[]>} */
@@ -114,7 +179,7 @@ export default class HayaSelectSystemTestHelper {
         if (typeof value != "undefined") {
             await waitFor({ timeout: 5000 }, async () => {
                 const optionsContainerSelector = await this.optionsContainerSelector();
-                const options = await this.findElements(`${optionsContainerSelector} [data-testid='haya-select/option'][data-value='${value}']`);
+                const options = await this.findElements(`${optionsContainerSelector} [data-testid='haya-select/option'][data-value="${cssAttributeValue(value)}"]`);
                 const option = options[0];
                 if (!option) {
                     throw new Error(`No option for value: ${value}`);
@@ -152,4 +217,77 @@ export default class HayaSelectSystemTestHelper {
         throw new Error("Expected value, text, or index when selecting an option");
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"system-test-helpers.js","sourceRoot":"","sources":["../src/system-test-helpers.js"],"names":[],"mappings":"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","sourcesContent":["import waitFor from \"awaitery/build/wait-for.js\"\nimport {By} from \"selenium-webdriver\"\n\n/** @typedef {{systemTest: object, testId: string}} HayaSelectSystemTestHelperOptions */\n\n/**\n * System test helper for interacting with HayaSelect instances.\n */\nexport default class HayaSelectSystemTestHelper {\n  /** @param {HayaSelectSystemTestHelperOptions} options */\n  constructor(options) {\n    if (!options) {\n      throw new Error(`Expected options for HayaSelectSystemTestHelper, got: ${options}`)\n    }\n\n    const {systemTest, testId, ...restArgs} = options\n    const extraKeys = Object.keys(restArgs)\n\n    if (extraKeys.length > 0) {\n      throw new Error(`Unexpected options for HayaSelectSystemTestHelper: ${extraKeys.join(\", \")}`)\n    }\n\n    this.systemTest = systemTest\n    this.testId = testId\n    this.rootSelector = `[data-testid='${testId}']`\n    this.componentSelector = `${this.rootSelector} [data-testid='haya-select']`\n    this.chevronContainerSelector = `${this.rootSelector} [data-testid='haya-select/chevron-container']`\n    this.selectContainerSelector = `${this.rootSelector} [data-testid='haya-select/select-container']`\n    this.searchInputSelector = `${this.rootSelector} [data-testid='haya-select/search-input']`\n    this.optionsContainerSelectorFallback = \"[data-testid='haya-select/options-container']\"\n  }\n\n  /** @returns {Promise<void>} */\n  async open() {\n    await this.clickSelectContainer()\n    this._optionsContainerSelector = null\n\n    await waitFor({timeout: 5000}, async () => {\n      const openedElements = await this.findElements(`${this.componentSelector}[data-opened='true']`)\n\n      if (openedElements.length === 0) {\n        throw new Error(`Expected HayaSelect to open: ${this.testId}`)\n      }\n    })\n  }\n\n  /** @returns {Promise<void>} */\n  async close() {\n    await this.clickSelectContainer()\n\n    await waitFor({timeout: 5000}, async () => {\n      const openedElements = await this.findElements(`${this.componentSelector}[data-opened='true']`)\n\n      if (openedElements.length > 0) {\n        throw new Error(`Expected HayaSelect to close: ${this.testId}`)\n      }\n    })\n  }\n\n  /** @returns {Promise<boolean>} */\n  async isOpen() {\n    const openedElements = await this.findElements(`${this.componentSelector}[data-opened='true']`)\n\n    if (openedElements.length > 0) return true\n\n    const searchInputs = await this.findVisibleElements(this.searchInputSelector)\n\n    return searchInputs.length > 0\n  }\n\n  /** @returns {Promise<void>} */\n  async clickSelectContainer() {\n    const selectContainer = await this.systemTest.find(this.selectContainerSelector, {timeout: 5000})\n\n    await selectContainer.click()\n  }\n\n  /**\n   * @param {string} selector\n   * @returns {Promise<Array<import(\"selenium-webdriver\").WebElement>>}\n   */\n  async findElements(selector) {\n    return await this.systemTest.getDriver().findElements(By.css(selector))\n  }\n\n  /**\n   * @param {string} selector\n   * @returns {Promise<Array<import(\"selenium-webdriver\").WebElement>>}\n   */\n  async findVisibleElements(selector) {\n    const elements = await this.findElements(selector)\n    const visibleElements = []\n\n    for (const element of elements) {\n      if (await element.isDisplayed()) {\n        visibleElements.push(element)\n      }\n    }\n\n    return visibleElements\n  }\n\n  /** @returns {Promise<string>} */\n  async optionsContainerSelector() {\n    if (this._optionsContainerSelector) return this._optionsContainerSelector\n\n    const rootElements = await this.findElements(this.rootSelector)\n    const rootId = rootElements.length > 0 ? await rootElements[0].getAttribute(\"data-id\") : null\n    let elements = rootElements\n\n    if (!rootId) {\n      elements = await this.findElements(this.componentSelector)\n    }\n\n    const id = rootId || (elements.length > 0 ? await elements[0].getAttribute(\"data-id\") : null)\n\n    this._optionsContainerSelector = id ? `[data-testid='haya-select/options-container'][data-id='${id}']` : this.optionsContainerSelectorFallback\n\n    return this._optionsContainerSelector\n  }\n\n  /** @returns {Promise<string[]>} */\n  async optionTexts() {\n    const optionsContainerSelector = await this.optionsContainerSelector()\n    const options = await this.findElements(`${optionsContainerSelector} [data-testid='haya-select/option']`)\n\n    return await Promise.all(options.map(async (option) => (await option.getText()).trim()))\n  }\n\n  /**\n   * @param {{index?: number, text?: string, value?: string|number}} criteria\n   * @returns {Promise<void>}\n   */\n  async selectOption({index, text, value, ...restArgs} = {}) {\n    if (arguments.length === 0) {\n      throw new Error(\"Expected criteria for selectOption, got: undefined\")\n    }\n\n    const extraKeys = Object.keys(restArgs)\n\n    if (extraKeys.length > 0) {\n      throw new Error(`Unexpected selectOption criteria: ${extraKeys.join(\", \")}`)\n    }\n\n    if (typeof value != \"undefined\") {\n      await waitFor({timeout: 5000}, async () => {\n        const optionsContainerSelector = await this.optionsContainerSelector()\n        const options = await this.findElements(`${optionsContainerSelector} [data-testid='haya-select/option'][data-value='${value}']`)\n        const option = options[0]\n\n        if (!option) {\n          throw new Error(`No option for value: ${value}`)\n        }\n\n        await option.click()\n      })\n      return\n    }\n\n    if (typeof index == \"number\") {\n      await waitFor({timeout: 5000}, async () => {\n        const optionsContainerSelector = await this.optionsContainerSelector()\n        const options = await this.findElements(`${optionsContainerSelector} [data-testid='haya-select/option']`)\n        const option = options[index]\n\n        if (!option) throw new Error(`No option at index: ${index}`)\n\n        await option.click()\n      })\n      return\n    }\n\n    if (text) {\n      await waitFor({timeout: 5000}, async () => {\n        const optionsContainerSelector = await this.optionsContainerSelector()\n        const options = await this.findElements(`${optionsContainerSelector} [data-testid='haya-select/option']`)\n\n        for (const option of options) {\n          const optionText = (await option.getText()).trim()\n\n          if (optionText === text) {\n            await option.click()\n            return\n          }\n        }\n\n        throw new Error(`No option found with text: ${text}`)\n      })\n      return\n    }\n\n    throw new Error(\"Expected value, text, or index when selecting an option\")\n  }\n}\n"]}
+/**
+ * Clicks a visible HayaSelect option by backend value.
+ * @param {object} systemTest Browser session used by the running spec.
+ * @param {string | number} optionValue Backend value stored in `data-value`.
+ * @param {number} timeout Maximum wait in milliseconds.
+ * @param {string} [optionsContainerSelector] Options container selector to scope the lookup.
+ * @returns {Promise<void>} Completes after the matching visible option is clicked.
+ */
+async function clickVisibleSelectOptionByValue(systemTest, optionValue, timeout, optionsContainerSelector = "") {
+    const selector = `${optionsContainerSelector ? `${optionsContainerSelector} ` : ""}[data-testid="haya-select/option"][data-value="${cssAttributeValue(optionValue)}"]`;
+    const element = await findVisibleElement(systemTest, selector, timeout);
+    await element.click();
+}
+/**
+ * Clicks a visible HayaSelect option by displayed text.
+ * @param {object} systemTest Browser session used by the running spec.
+ * @param {string} expectedText Visible fragment rendered by the option.
+ * @param {number} timeout Maximum wait in milliseconds.
+ * @param {string} [optionsContainerSelector] Options container selector to scope the lookup.
+ * @returns {Promise<void>} Completes after the matching visible option is clicked.
+ */
+async function clickVisibleSelectOptionByText(systemTest, expectedText, timeout, optionsContainerSelector = "") {
+    const element = /** @type {WebElement} */ (await systemTest.getDriver().wait(async () => {
+        const selector = `${optionsContainerSelector ? `${optionsContainerSelector} ` : ""}[data-testid='haya-select/option']`;
+        const optionElements = await systemTest.getDriver().findElements(By.css(selector));
+        for (const optionElement of optionElements) {
+            if (!(await optionElement.isDisplayed())) {
+                continue;
+            }
+            const actualText = await optionElement.getText();
+            if (actualText.includes(expectedText)) {
+                return optionElement;
+            }
+        }
+        return false;
+    }, timeout, `Timed out waiting for visible select option text ${expectedText}`));
+    await element.click();
+}
+/**
+ * Finds a visible element by CSS selector.
+ * @param {object} systemTest Browser session used by the running spec.
+ * @param {string} selector CSS query that can match one or more nodes.
+ * @param {number} timeout Maximum wait in milliseconds.
+ * @returns {Promise<WebElement>} First displayed match.
+ */
+async function findVisibleElement(systemTest, selector, timeout) {
+    const element = await systemTest.getDriver().wait(async () => {
+        const elements = await systemTest.getDriver().findElements(By.css(selector));
+        for (const element of elements) {
+            if (await element.isDisplayed()) {
+                return element;
+            }
+        }
+        return false;
+    }, timeout, `Timed out waiting for visible selector ${selector}`);
+    return /** @type {WebElement} */ (element);
+}
+/**
+ * Builds a data-testid CSS selector.
+ * @param {string} testId Raw value from the component's `testID` prop.
+ * @returns {string} Attribute selector for the value.
+ */
+function testIdSelector(testId) {
+    return `[data-testid="${cssAttributeValue(testId)}"]`;
+}
+/**
+ * Escapes a value for use inside a double-quoted CSS attribute selector.
+ * @param {string | number} value Raw attribute value to interpolate.
+ * @returns {string} String safe for a double-quoted attribute selector.
+ */
+function cssAttributeValue(value) {
+    return String(value).replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"system-test-helpers.js","sourceRoot":"","sources":["../src/system-test-helpers.js"],"names":[],"mappings":"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","sourcesContent":["import waitFor from \"awaitery/build/wait-for.js\"\nimport {By} from \"selenium-webdriver\"\n\n/** @typedef {{systemTest: object, testId: string}} HayaSelectSystemTestHelperOptions */\n/** @typedef {{optionText?: string, optionValue?: string | number, search?: boolean, timeout?: number, useBaseSelector?: boolean}} PickHayaSelectOptionOptions */\n/** @typedef {{optionValue: string | number, timeout?: number}} ClickVisibleHayaSelectOptionOptions */\n/** @typedef {{timeout?: number}} ExpectHayaSelectCurrentOptionsOptions */\n/** @typedef {import(\"selenium-webdriver\").WebElement} WebElement */\n\nconst DEFAULT_TIMEOUT = 5000\n\n/**\n * Selects an option in a HayaSelect instance.\n * @param {object} systemTest Browser session used by the running spec.\n * @param {string} testId Wrapper `data-testid` around the select.\n * @param {PickHayaSelectOptionOptions} options Text/value to choose and whether to type into the search field first.\n * @returns {Promise<void>} Completes after the matching visible option is clicked.\n * @rejects {Error} When neither text nor value is supplied.\n */\nexport async function pickHayaSelectOption(systemTest, testId, {optionText, optionValue, search = false, timeout = DEFAULT_TIMEOUT, useBaseSelector = true}) {\n  const helper = new HayaSelectSystemTestHelper({systemTest, testId})\n  const selectElement = await systemTest.find(helper.selectContainerSelector, {timeout, useBaseSelector})\n  await selectElement.click()\n\n  if (search) {\n    if (!optionText) {\n      throw new Error(`Expected optionText when searching ${testId}`)\n    }\n\n    const searchElement = await systemTest.find(helper.searchInputSelector, {timeout, useBaseSelector})\n    await searchElement.sendKeys(optionText)\n  }\n\n  const optionsContainerSelector = await helper.optionsContainerSelector()\n\n  if (typeof optionValue !== \"undefined\") {\n    await clickVisibleSelectOptionByValue(systemTest, optionValue, timeout, optionsContainerSelector)\n    return\n  }\n\n  if (optionText) {\n    await clickVisibleSelectOptionByText(systemTest, optionText, timeout, optionsContainerSelector)\n    return\n  }\n\n  throw new Error(`Expected optionValue or optionText for ${testId}`)\n}\n\n/**\n * Clicks an option in an already-open HayaSelect dropdown.\n * @param {object} systemTest Browser session used by the running spec.\n * @param {ClickVisibleHayaSelectOptionOptions} options Option value to choose.\n * @returns {Promise<void>} Completes after the matching visible option is clicked.\n */\nexport async function clickVisibleHayaSelectOption(systemTest, {optionValue, timeout = DEFAULT_TIMEOUT}) {\n  await clickVisibleSelectOptionByValue(systemTest, optionValue, timeout)\n}\n\n/**\n * Waits until a HayaSelect renders exactly the expected current-option labels.\n * @param {object} systemTest Browser session used by the running spec.\n * @param {string} testId Wrapper `data-testid` around the select.\n * @param {string[]} expectedTexts Current option text fragments in rendered order.\n * @param {ExpectHayaSelectCurrentOptionsOptions} [options] Optional Selenium timeout override.\n * @returns {Promise<void>} Completes after the current options match.\n */\nexport async function expectHayaSelectCurrentOptions(systemTest, testId, expectedTexts, {timeout = DEFAULT_TIMEOUT} = {}) {\n  const selector = `${testIdSelector(testId)} [data-testid=\"haya-select/current-option\"]`\n  await systemTest.getDriver().wait(\n    async () => {\n      const elements = await systemTest.getDriver().findElements(By.css(selector))\n      /** @type {string[]} */\n      const visibleTexts = []\n\n      for (const element of elements) {\n        if (await element.isDisplayed()) {\n          visibleTexts.push(await element.getText())\n        }\n      }\n\n      if (visibleTexts.length !== expectedTexts.length) {\n        return false\n      }\n\n      return expectedTexts.every((expectedText, index) => visibleTexts[index]?.includes(expectedText))\n    },\n    timeout,\n    `Timed out waiting for ${testId} current options: ${expectedTexts.join(\", \")}`\n  )\n}\n\n/**\n * System test helper for interacting with HayaSelect instances.\n */\nexport default class HayaSelectSystemTestHelper {\n  /** @param {HayaSelectSystemTestHelperOptions} options */\n  constructor(options) {\n    if (!options) {\n      throw new Error(`Expected options for HayaSelectSystemTestHelper, got: ${options}`)\n    }\n\n    const {systemTest, testId, ...restArgs} = options\n    const extraKeys = Object.keys(restArgs)\n\n    if (extraKeys.length > 0) {\n      throw new Error(`Unexpected options for HayaSelectSystemTestHelper: ${extraKeys.join(\", \")}`)\n    }\n\n    this.systemTest = systemTest\n    this.testId = testId\n    this.rootSelector = testIdSelector(testId)\n    this.componentSelector = `${this.rootSelector} [data-testid='haya-select']`\n    this.chevronContainerSelector = `${this.rootSelector} [data-testid='haya-select/chevron-container']`\n    this.selectContainerSelector = `${this.rootSelector} [data-testid='haya-select/select-container']`\n    this.searchInputSelector = `${this.rootSelector} [data-testid='haya-select/search-input']`\n    this.optionsContainerSelectorFallback = \"[data-testid='haya-select/options-container']\"\n  }\n\n  /** @returns {Promise<void>} */\n  async open() {\n    await this.clickSelectContainer()\n    this._optionsContainerSelector = null\n\n    await waitFor({timeout: 5000}, async () => {\n      const openedElements = await this.findElements(`${this.componentSelector}[data-opened='true']`)\n\n      if (openedElements.length === 0) {\n        throw new Error(`Expected HayaSelect to open: ${this.testId}`)\n      }\n    })\n  }\n\n  /** @returns {Promise<void>} */\n  async close() {\n    await this.clickSelectContainer()\n\n    await waitFor({timeout: 5000}, async () => {\n      const openedElements = await this.findElements(`${this.componentSelector}[data-opened='true']`)\n\n      if (openedElements.length > 0) {\n        throw new Error(`Expected HayaSelect to close: ${this.testId}`)\n      }\n    })\n  }\n\n  /** @returns {Promise<boolean>} */\n  async isOpen() {\n    const openedElements = await this.findElements(`${this.componentSelector}[data-opened='true']`)\n\n    if (openedElements.length > 0) return true\n\n    const searchInputs = await this.findVisibleElements(this.searchInputSelector)\n\n    return searchInputs.length > 0\n  }\n\n  /** @returns {Promise<void>} */\n  async clickSelectContainer() {\n    const selectContainer = await this.systemTest.find(this.selectContainerSelector, {timeout: 5000})\n\n    await selectContainer.click()\n  }\n\n  /**\n   * @param {string} selector\n   * @returns {Promise<Array<import(\"selenium-webdriver\").WebElement>>}\n   */\n  async findElements(selector) {\n    return await this.systemTest.getDriver().findElements(By.css(selector))\n  }\n\n  /**\n   * @param {string} selector\n   * @returns {Promise<Array<import(\"selenium-webdriver\").WebElement>>}\n   */\n  async findVisibleElements(selector) {\n    const elements = await this.findElements(selector)\n    const visibleElements = []\n\n    for (const element of elements) {\n      if (await element.isDisplayed()) {\n        visibleElements.push(element)\n      }\n    }\n\n    return visibleElements\n  }\n\n  /** @returns {Promise<string>} */\n  async optionsContainerSelector() {\n    if (this._optionsContainerSelector) return this._optionsContainerSelector\n\n    const openedElements = await this.findElements(`${this.componentSelector}[data-opened='true']`)\n    const componentElements = openedElements.length > 0 ? openedElements : await this.findVisibleElements(this.componentSelector)\n    const id = componentElements.length > 0 ? await componentElements[0].getAttribute(\"data-id\") : null\n\n    this._optionsContainerSelector = id ? `[data-testid='haya-select/options-container'][data-id=\"${cssAttributeValue(id)}\"]` : this.optionsContainerSelectorFallback\n\n    return this._optionsContainerSelector\n  }\n\n  /** @returns {Promise<string[]>} */\n  async optionTexts() {\n    const optionsContainerSelector = await this.optionsContainerSelector()\n    const options = await this.findElements(`${optionsContainerSelector} [data-testid='haya-select/option']`)\n\n    return await Promise.all(options.map(async (option) => (await option.getText()).trim()))\n  }\n\n  /**\n   * @param {{index?: number, text?: string, value?: string|number}} criteria\n   * @returns {Promise<void>}\n   */\n  async selectOption({index, text, value, ...restArgs} = {}) {\n    if (arguments.length === 0) {\n      throw new Error(\"Expected criteria for selectOption, got: undefined\")\n    }\n\n    const extraKeys = Object.keys(restArgs)\n\n    if (extraKeys.length > 0) {\n      throw new Error(`Unexpected selectOption criteria: ${extraKeys.join(\", \")}`)\n    }\n\n    if (typeof value != \"undefined\") {\n      await waitFor({timeout: 5000}, async () => {\n        const optionsContainerSelector = await this.optionsContainerSelector()\n        const options = await this.findElements(`${optionsContainerSelector} [data-testid='haya-select/option'][data-value=\"${cssAttributeValue(value)}\"]`)\n        const option = options[0]\n\n        if (!option) {\n          throw new Error(`No option for value: ${value}`)\n        }\n\n        await option.click()\n      })\n      return\n    }\n\n    if (typeof index == \"number\") {\n      await waitFor({timeout: 5000}, async () => {\n        const optionsContainerSelector = await this.optionsContainerSelector()\n        const options = await this.findElements(`${optionsContainerSelector} [data-testid='haya-select/option']`)\n        const option = options[index]\n\n        if (!option) throw new Error(`No option at index: ${index}`)\n\n        await option.click()\n      })\n      return\n    }\n\n    if (text) {\n      await waitFor({timeout: 5000}, async () => {\n        const optionsContainerSelector = await this.optionsContainerSelector()\n        const options = await this.findElements(`${optionsContainerSelector} [data-testid='haya-select/option']`)\n\n        for (const option of options) {\n          const optionText = (await option.getText()).trim()\n\n          if (optionText === text) {\n            await option.click()\n            return\n          }\n        }\n\n        throw new Error(`No option found with text: ${text}`)\n      })\n      return\n    }\n\n    throw new Error(\"Expected value, text, or index when selecting an option\")\n  }\n}\n\n/**\n * Clicks a visible HayaSelect option by backend value.\n * @param {object} systemTest Browser session used by the running spec.\n * @param {string | number} optionValue Backend value stored in `data-value`.\n * @param {number} timeout Maximum wait in milliseconds.\n * @param {string} [optionsContainerSelector] Options container selector to scope the lookup.\n * @returns {Promise<void>} Completes after the matching visible option is clicked.\n */\nasync function clickVisibleSelectOptionByValue(systemTest, optionValue, timeout, optionsContainerSelector = \"\") {\n  const selector = `${optionsContainerSelector ? `${optionsContainerSelector} ` : \"\"}[data-testid=\"haya-select/option\"][data-value=\"${cssAttributeValue(optionValue)}\"]`\n  const element = await findVisibleElement(systemTest, selector, timeout)\n  await element.click()\n}\n\n/**\n * Clicks a visible HayaSelect option by displayed text.\n * @param {object} systemTest Browser session used by the running spec.\n * @param {string} expectedText Visible fragment rendered by the option.\n * @param {number} timeout Maximum wait in milliseconds.\n * @param {string} [optionsContainerSelector] Options container selector to scope the lookup.\n * @returns {Promise<void>} Completes after the matching visible option is clicked.\n */\nasync function clickVisibleSelectOptionByText(systemTest, expectedText, timeout, optionsContainerSelector = \"\") {\n  const element = /** @type {WebElement} */ (\n    await systemTest.getDriver().wait(\n      async () => {\n        const selector = `${optionsContainerSelector ? `${optionsContainerSelector} ` : \"\"}[data-testid='haya-select/option']`\n        const optionElements = await systemTest.getDriver().findElements(By.css(selector))\n\n        for (const optionElement of optionElements) {\n          if (!(await optionElement.isDisplayed())) {\n            continue\n          }\n\n          const actualText = await optionElement.getText()\n          if (actualText.includes(expectedText)) {\n            return optionElement\n          }\n        }\n\n        return false\n      },\n      timeout,\n      `Timed out waiting for visible select option text ${expectedText}`\n    )\n  )\n\n  await element.click()\n}\n\n/**\n * Finds a visible element by CSS selector.\n * @param {object} systemTest Browser session used by the running spec.\n * @param {string} selector CSS query that can match one or more nodes.\n * @param {number} timeout Maximum wait in milliseconds.\n * @returns {Promise<WebElement>} First displayed match.\n */\nasync function findVisibleElement(systemTest, selector, timeout) {\n  const element = await systemTest.getDriver().wait(\n    async () => {\n      const elements = await systemTest.getDriver().findElements(By.css(selector))\n\n      for (const element of elements) {\n        if (await element.isDisplayed()) {\n          return element\n        }\n      }\n\n      return false\n    },\n    timeout,\n    `Timed out waiting for visible selector ${selector}`\n  )\n\n  return /** @type {WebElement} */ (element)\n}\n\n/**\n * Builds a data-testid CSS selector.\n * @param {string} testId Raw value from the component's `testID` prop.\n * @returns {string} Attribute selector for the value.\n */\nfunction testIdSelector(testId) {\n  return `[data-testid=\"${cssAttributeValue(testId)}\"]`\n}\n\n/**\n * Escapes a value for use inside a double-quoted CSS attribute selector.\n * @param {string | number} value Raw attribute value to interpolate.\n * @returns {string} String safe for a double-quoted attribute selector.\n */\nfunction cssAttributeValue(value) {\n  return String(value).replaceAll(\"\\\\\", \"\\\\\\\\\").replaceAll('\"', '\\\\\"')\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "haya-select",
-  "version": "1.0.116",
+  "version": "1.0.118",
   "description": "Just another select component for React Native + Web.",
   "files": [
     "build/**"