system-testing 1.0.78 → 1.0.79

package/build/browser.js

@@ -0,0 +1,358 @@
+// @ts-check
+import fs from "node:fs/promises";
+import moment from "moment";
+import { prettify } from "htmlfy";
+import timeout from "awaitery/build/timeout.js";
+import SeleniumDriver from "./drivers/selenium-driver.js";
+import AppiumDriver from "./drivers/appium-driver.js";
+/**
+ * @typedef {object} BrowserArgs
+ * @property {boolean} [debug] Enable debug logging.
+ * @property {BrowserDriverConfig} [driver] Driver configuration.
+ * @property {import("./system-test-communicator.js").default} [communicator] Optional command communicator for helper-driven navigation.
+ * @property {string} [screenshotsPath] Directory used for saved screenshots and browser artifacts.
+ */
+/**
+ * @typedef {object} BrowserDriverConfig
+ * @property {"selenium"|"appium"} [type] Driver implementation to use.
+ * @property {Record<string, any>} [options] Driver-specific options.
+ */
+/** Generic browser session wrapper around the configured driver. */
+export default class Browser {
+    /** @param {BrowserArgs} [args] */
+    constructor({ debug = false, driver, communicator, screenshotsPath = `${process.cwd()}/tmp/screenshots`, ...restArgs } = {}) {
+        /** @type {import("selenium-webdriver").WebDriver | undefined} */
+        this.driver = undefined;
+        /** @type {import("./drivers/webdriver-driver.js").default | undefined} */
+        this.driverAdapter = undefined;
+        this._debug = false;
+        /** @type {BrowserDriverConfig | undefined} */
+        this._driverConfig = undefined;
+        /** @type {Error | undefined} */
+        this._httpServerError = undefined;
+        /**
+         * @param {Error} error
+         * @returns {void}
+         */
+        this.onHttpServerError = (error) => {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this._httpServerError = error instanceof Error ? error : new Error(errorMessage);
+            console.error(`HTTP server error: ${errorMessage}`);
+        };
+        const restArgsKeys = Object.keys(restArgs);
+        if (restArgsKeys.length > 0) {
+            throw new Error(`Unknown browser arguments: ${restArgsKeys.join(", ")}`);
+        }
+        this._debug = debug;
+        this._driverConfig = driver;
+        this._screenshotsPath = screenshotsPath;
+        this.communicator = communicator;
+        this.driverAdapter = this.createDriver(driver);
+    }
+    /**
+     * @param {BrowserDriverConfig} [driverConfig]
+     * @returns {import("./drivers/webdriver-driver.js").default}
+     */
+    createDriver(driverConfig = {}) {
+        const { type = "selenium", options, ...restArgs } = driverConfig;
+        const restArgsKeys = Object.keys(restArgs);
+        if (restArgsKeys.length > 0) {
+            throw new Error(`Unknown driver args: ${restArgsKeys.join(", ")}`);
+        }
+        if (type === "selenium") {
+            return new SeleniumDriver({ browser: this, options });
+        }
+        if (type === "appium") {
+            return new AppiumDriver({ browser: this, options });
+        }
+        throw new Error(`Unsupported driver type: ${type}`);
+    }
+    /**
+     * @param {import("./system-test-communicator.js").default | undefined} communicator
+     * @returns {void}
+     */
+    setCommunicator(communicator) {
+        this.communicator = communicator;
+    }
+    /** @returns {boolean} */
+    communicatorExists() {
+        return Boolean(this.communicator);
+    }
+    /**
+     * @param {string} baseSelector
+     * @returns {void}
+     */
+    setBaseSelector(baseSelector) { this._baseSelector = baseSelector; }
+    /** @returns {string | undefined} */
+    getBaseSelector() { return this._baseSelector; }
+    /**
+     * @param {string} selector
+     * @returns {string}
+     */
+    getSelector(selector) {
+        return this.getBaseSelector() ? `${this.getBaseSelector()} ${selector}` : selector;
+    }
+    /**
+     * @param {...any} args
+     * @returns {void}
+     */
+    debugError(...args) {
+        console.error("[Browser error]", ...args);
+    }
+    /**
+     * @param {...any} args
+     * @returns {void}
+     */
+    debugLog(...args) {
+        if (this._debug) {
+            console.log("[Browser debug]", ...args);
+        }
+    }
+    /** @returns {void} */
+    throwIfHttpServerError() {
+        if (this._httpServerError) {
+            throw new Error(`HTTP server error: ${this._httpServerError.message}`);
+        }
+    }
+    /** @returns {import("selenium-webdriver").WebDriver} */
+    getDriver() {
+        return this.getDriverAdapter().getWebDriver();
+    }
+    /** @returns {import("./drivers/webdriver-driver.js").default} */
+    getDriverAdapter() {
+        if (!this.driverAdapter) {
+            throw new Error("Driver hasn't been initialized yet");
+        }
+        return this.driverAdapter;
+    }
+    /** @returns {number} */
+    getTimeouts() { return this.getDriverAdapter().getTimeouts(); }
+    /** @returns {Promise<void>} */
+    async restoreTimeouts() {
+        await this.getDriverAdapter().restoreTimeouts();
+    }
+    /**
+     * @param {number} newTimeout
+     * @returns {Promise<void>}
+     */
+    async driverSetTimeouts(newTimeout) {
+        await this.getDriverAdapter().driverSetTimeouts(newTimeout);
+    }
+    /**
+     * @param {number} newTimeout
+     * @returns {Promise<void>}
+     */
+    async setTimeouts(newTimeout) {
+        await this.getDriverAdapter().setTimeouts(newTimeout);
+    }
+    /** @returns {Promise<string[]>} */
+    async getBrowserLogs() {
+        return await this.getDriverAdapter().getBrowserLogs();
+    }
+    /** @returns {Promise<string>} */
+    async getCurrentUrl() {
+        return await this.getDriverAdapter().getCurrentUrl();
+    }
+    /**
+     * @param {string} selector
+     * @param {import("./system-test.js").FindArgs} [args]
+     * @returns {Promise<import("selenium-webdriver").WebElement[]>}
+     */
+    async all(selector, args = {}) {
+        return await this.getDriverAdapter().all(selector, args);
+    }
+    /**
+     * @param {string} selector
+     * @param {import("./system-test.js").FindArgs} [args]
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    async find(selector, args = {}) {
+        return await this.getDriverAdapter().find(selector, args);
+    }
+    /**
+     * @param {string} testID
+     * @param {import("./system-test.js").FindArgs} [args]
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    async findByTestID(testID, args) {
+        return await this.getDriverAdapter().findByTestID(testID, args);
+    }
+    /**
+     * @param {string} selector
+     * @param {import("./system-test.js").FindArgs} [args]
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    async findNoWait(selector, args = {}) {
+        return await this.getDriverAdapter().findNoWait(selector, args);
+    }
+    /**
+     * @param {string | import("selenium-webdriver").WebElement} elementOrIdentifier
+     * @param {import("./system-test.js").FindArgs} [args]
+     * @returns {Promise<void>}
+     */
+    async click(elementOrIdentifier, args) {
+        await this.getDriverAdapter().click(elementOrIdentifier, args);
+    }
+    /**
+     * @param {import("selenium-webdriver").WebElement|string|{selector: string} & import("./system-test.js").FindArgs} elementOrIdentifier
+     * @param {string} methodName
+     * @param {...any} args
+     * @returns {Promise<any>}
+     */
+    async interact(elementOrIdentifier, methodName, ...args) {
+        return await this.getDriverAdapter().interact(elementOrIdentifier, methodName, ...args);
+    }
+    /**
+     * @param {string} selector
+     * @param {import("./system-test.js").WaitForNoSelectorArgs} [args]
+     * @returns {Promise<void>}
+     */
+    async waitForNoSelector(selector, args = {}) {
+        await this.getDriverAdapter().waitForNoSelector(selector, args);
+    }
+    /**
+     * @param {string} selector
+     * @param {import("./system-test.js").FindArgs} [args]
+     * @returns {Promise<void>}
+     */
+    async expectNoElement(selector, args = {}) {
+        let found = false;
+        try {
+            await this.findNoWait(selector, args);
+            found = true;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.startsWith("Element couldn't be found after ")) {
+                // Ignore
+            }
+            else {
+                throw error;
+            }
+        }
+        if (found) {
+            throw new Error(`Expected not to find: ${selector}`);
+        }
+    }
+    /** @returns {Promise<string>} */
+    async getHTML() {
+        return await this.getDriverAdapter().getHTML();
+    }
+    /**
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    async driverVisit(path) {
+        await this.getDriverAdapter().driverVisit(path);
+    }
+    /**
+     * @param {string} type
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    async sendBrowserCommand(type, path) {
+        if (!this.communicator) {
+            throw new Error("Communicator hasn't been initialized yet");
+        }
+        await timeout({ timeout: this.getTimeouts(), errorMessage: `timeout while sending browser command ${type}: ${path}` }, async () => await this.communicator.sendCommand({ type, path }));
+    }
+    /**
+     * Visits a path using the injected browser helper when available, otherwise navigates directly with the driver.
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    async visit(path) {
+        if (this.communicatorExists()) {
+            await this.sendBrowserCommand("visit", path);
+        }
+        else {
+            await timeout({ timeout: this.getTimeouts(), errorMessage: `timeout while visiting path: ${path}` }, async () => await this.driverVisit(path));
+        }
+    }
+    /**
+     * Dismisses to a path via the injected browser helper when available, otherwise navigates directly with the driver.
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    async dismissTo(path) {
+        if (this.communicatorExists()) {
+            await this.sendBrowserCommand("dismissTo", path);
+        }
+        else {
+            await timeout({ timeout: this.getTimeouts(), errorMessage: `timeout while dismissing to path: ${path}` }, async () => await this.driverVisit(path));
+        }
+    }
+    /**
+     * Formats browser logs for console output and truncates overly long output.
+     * @param {string[]} logs
+     * @param {number} [maxLines]
+     * @returns {string[]}
+     */
+    formatBrowserLogsForConsole(logs, maxLines = 200) {
+        if (!Array.isArray(logs) || logs.length === 0) {
+            return ["(no browser logs)"];
+        }
+        if (logs.length <= maxLines) {
+            return logs;
+        }
+        const keptLogs = logs.slice(logs.length - maxLines);
+        const hiddenCount = logs.length - maxLines;
+        return [`(showing last ${maxLines} of ${logs.length} browser logs, ${hiddenCount} omitted)`, ...keptLogs];
+    }
+    /**
+     * @param {string[]} logs
+     * @returns {void}
+     */
+    printBrowserLogsForFailure(logs) {
+        console.log("Browser logs:");
+        for (const line of this.formatBrowserLogsForConsole(logs)) {
+            console.log(line);
+        }
+    }
+    /**
+     * Takes a screenshot, writes HTML/browser logs to disk, and returns the collected artifacts.
+     * @returns {Promise<{currentUrl: string, html: string, htmlPath: string, logs: string[], logsPath: string, screenshotPath: string}>}
+     */
+    async takeScreenshot() {
+        this.debugLog("Getting path for screenshots");
+        const path = this._screenshotsPath;
+        this.debugLog(`Creating dir with recursive: ${path}`);
+        await fs.mkdir(path, { recursive: true });
+        this.debugLog("Getting screenshot image content");
+        const imageContent = await timeout({ timeout: 5000, errorMessage: "timeout while taking screenshot" }, async () => await this.getDriverAdapter().takeScreenshot());
+        this.debugLog("Generating date variables");
+        const now = new Date();
+        const timestamp = moment(now).format("YYYY-MM-DD-HH-MM-SS");
+        const screenshotPath = `${path}/${timestamp}.png`;
+        const htmlPath = `${path}/${timestamp}.html`;
+        const logsPath = `${path}/${timestamp}.logs.txt`;
+        this.debugLog("Getting browser logs");
+        const logs = await timeout({ timeout: 5000, errorMessage: "timeout while reading browser logs" }, async () => await this.getBrowserLogs());
+        const html = await timeout({ timeout: 5000, errorMessage: "timeout while reading page HTML" }, async () => await this.getHTML());
+        const htmlPretty = prettify(html);
+        this.printBrowserLogsForFailure(logs);
+        this.debugLog("Writing files");
+        await fs.writeFile(htmlPath, htmlPretty);
+        await fs.writeFile(logsPath, logs.join("\n"));
+        await fs.writeFile(screenshotPath, imageContent, "base64");
+        const currentUrl = await this.getCurrentUrl();
+        console.log("Current URL:", currentUrl);
+        console.log("Logs:", logsPath);
+        console.log("Screenshot:", screenshotPath);
+        console.log("HTML:", htmlPath);
+        return {
+            currentUrl,
+            html,
+            htmlPath,
+            logs,
+            logsPath,
+            screenshotPath
+        };
+    }
+    /** @returns {Promise<void>} */
+    async stopDriver() {
+        if (this.driverAdapter) {
+            await this.driverAdapter.stop();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"browser.js","sourceRoot":"","sources":["../src/browser.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAE,MAAM,kBAAkB,CAAA;AACjC,OAAO,MAAM,MAAM,QAAQ,CAAA;AAC3B,OAAO,EAAC,QAAQ,EAAC,MAAM,QAAQ,CAAA;AAC/B,OAAO,OAAO,MAAM,2BAA2B,CAAA;AAC/C,OAAO,cAAc,MAAM,8BAA8B,CAAA;AACzD,OAAO,YAAY,MAAM,4BAA4B,CAAA;AAErD;;;;;;GAMG;AACH;;;;GAIG;AAEH,oEAAoE;AACpE,MAAM,CAAC,OAAO,OAAO,OAAO;IAa1B,kCAAkC;IAClC,YAAY,EAAC,KAAK,GAAG,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,eAAe,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,kBAAkB,EAAE,GAAG,QAAQ,EAAC,GAAG,EAAE;QAbzH,iEAAiE;QACjE,WAAM,GAAG,SAAS,CAAA;QAElB,0EAA0E;QAC1E,kBAAa,GAAG,SAAS,CAAA;QAEzB,WAAM,GAAG,KAAK,CAAA;QACd,8CAA8C;QAC9C,kBAAa,GAAG,SAAS,CAAA;QACzB,gCAAgC;QAChC,qBAAgB,GAAG,SAAS,CAAA;QA+F5B;;;WAGG;QACH,sBAAiB,GAAG,CAAC,KAAK,EAAE,EAAE;YAC5B,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;YAE3E,IAAI,CAAC,gBAAgB,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,YAAY,CAAC,CAAA;YAChF,OAAO,CAAC,KAAK,CAAC,sBAAsB,YAAY,EAAE,CAAC,CAAA;QACrD,CAAC,CAAA;QApGC,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QAE1C,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,8BAA8B,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QAC1E,CAAC;QAED,IAAI,CAAC,MAAM,GAAG,KAAK,CAAA;QACnB,IAAI,CAAC,aAAa,GAAG,MAAM,CAAA;QAC3B,IAAI,CAAC,gBAAgB,GAAG,eAAe,CAAA;QACvC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAA;QAChC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,CAAA;IAChD,CAAC;IAED;;;OAGG;IACH,YAAY,CAAC,YAAY,GAAG,EAAE;QAC5B,MAAM,EAAC,IAAI,GAAG,UAAU,EAAE,OAAO,EAAE,GAAG,QAAQ,EAAC,GAAG,YAAY,CAAA;QAC9D,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QAE1C,IAAI,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,wBAAwB,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QACpE,CAAC;QAED,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;YACxB,OAAO,IAAI,cAAc,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAC,CAAC,CAAA;QACrD,CAAC;QAED,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;YACtB,OAAO,IAAI,YAAY,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,OAAO,EAAC,CAAC,CAAA;QACnD,CAAC;QAED,MAAM,IAAI,KAAK,CAAC,4BAA4B,IAAI,EAAE,CAAC,CAAA;IACrD,CAAC;IAED;;;OAGG;IACH,eAAe,CAAC,YAAY;QAC1B,IAAI,CAAC,YAAY,GAAG,YAAY,CAAA;IAClC,CAAC;IAED,yBAAyB;IACzB,kBAAkB;QAChB,OAAO,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,CAAA;IACnC,CAAC;IAED;;;OAGG;IACH,eAAe,CAAC,YAAY,IAAI,IAAI,CAAC,aAAa,GAAG,YAAY,CAAA,CAAC,CAAC;IAEnE,oCAAoC;IACpC,eAAe,KAAK,OAAO,IAAI,CAAC,aAAa,CAAA,CAAC,CAAC;IAE/C;;;OAGG;IACH,WAAW,CAAC,QAAQ;QAClB,OAAO,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,eAAe,EAAE,IAAI,QAAQ,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAA;IACpF,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,GAAG,IAAI;QAChB,OAAO,CAAC,KAAK,CAAC,iBAAiB,EAAE,GAAG,IAAI,CAAC,CAAA;IAC3C,CAAC;IAED;;;OAGG;IACH,QAAQ,CAAC,GAAG,IAAI;QACd,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO,CAAC,GAAG,CAAC,iBAAiB,EAAE,GAAG,IAAI,CAAC,CAAA;QACzC,CAAC;IACH,CAAC;IAED,sBAAsB;IACtB,sBAAsB;QACpB,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,sBAAsB,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC,CAAA;QACxE,CAAC;IACH,CAAC;IAaD,wDAAwD;IACxD,SAAS;QACP,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC,YAAY,EAAE,CAAA;IAC/C,CAAC;IAED,iEAAiE;IACjE,gBAAgB;QACd,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAA;QACvD,CAAC;QAED,OAAO,IAAI,CAAC,aAAa,CAAA;IAC3B,CAAC;IAED,wBAAwB;IACxB,WAAW,KAAK,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC,WAAW,EAAE,CAAA,CAAC,CAAC;IAE9D,+BAA+B;IAC/B,KAAK,CAAC,eAAe;QACnB,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,eAAe,EAAE,CAAA;IACjD,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,iBAAiB,CAAC,UAAU;QAChC,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAA;IAC7D,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,WAAW,CAAC,UAAU;QAC1B,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,WAAW,CAAC,UAAU,CAAC,CAAA;IACvD,CAAC;IAED,mCAAmC;IACnC,KAAK,CAAC,cAAc;QAClB,OAAO,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,cAAc,EAAE,CAAA;IACvD,CAAC;IAED,iCAAiC;IACjC,KAAK,CAAC,aAAa;QACjB,OAAO,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,aAAa,EAAE,CAAA;IACtD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,GAAG,EAAE;QAC3B,OAAO,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAA;IAC1D,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,GAAG,EAAE;QAC5B,OAAO,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAA;IAC3D,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI;QAC7B,OAAO,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IACjE,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,GAAG,EAAE;QAClC,OAAO,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAA;IACjE,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,KAAK,CAAC,mBAAmB,EAAE,IAAI;QACnC,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,KAAK,CAAC,mBAAmB,EAAE,IAAI,CAAC,CAAA;IAChE,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,QAAQ,CAAC,mBAAmB,EAAE,UAAU,EAAE,GAAG,IAAI;QACrD,OAAO,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,QAAQ,CAAC,mBAAmB,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,CAAA;IACzF,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,iBAAiB,CAAC,QAAQ,EAAE,IAAI,GAAG,EAAE;QACzC,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,iBAAiB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAA;IACjE,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,eAAe,CAAC,QAAQ,EAAE,IAAI,GAAG,EAAE;QACvC,IAAI,KAAK,GAAG,KAAK,CAAA;QAEjB,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAA;YACrC,KAAK,GAAG,IAAI,CAAA;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,kCAAkC,CAAC,EAAE,CAAC;gBAC3F,SAAS;YACX,CAAC;iBAAM,CAAC;gBACN,MAAM,KAAK,CAAA;YACb,CAAC;QACH,CAAC;QAED,IAAI,KAAK,EAAE,CAAC;YACV,MAAM,IAAI,KAAK,CAAC,yBAAyB,QAAQ,EAAE,CAAC,CAAA;QACtD,CAAC;IACH,CAAC;IAED,iCAAiC;IACjC,KAAK,CAAC,OAAO;QACX,OAAO,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,OAAO,EAAE,CAAA;IAChD,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,WAAW,CAAC,IAAI;QACpB,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,CAAA;IACjD,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,kBAAkB,CAAC,IAAI,EAAE,IAAI;QACjC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAA;QAC7D,CAAC;QAED,MAAM,OAAO,CACX,EAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE,YAAY,EAAE,yCAAyC,IAAI,KAAK,IAAI,EAAE,EAAC,EACrG,KAAK,IAAI,EAAE,CAAC,MAAM,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,EAAC,IAAI,EAAE,IAAI,EAAC,CAAC,CAC9D,CAAA;IACH,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,KAAK,CAAC,IAAI;QACd,IAAI,IAAI,CAAC,kBAAkB,EAAE,EAAE,CAAC;YAC9B,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;QAC9C,CAAC;aAAM,CAAC;YACN,MAAM,OAAO,CACX,EAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE,YAAY,EAAE,gCAAgC,IAAI,EAAE,EAAC,EACnF,KAAK,IAAI,EAAE,CAAC,MAAM,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CACzC,CAAA;QACH,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,SAAS,CAAC,IAAI;QAClB,IAAI,IAAI,CAAC,kBAAkB,EAAE,EAAE,CAAC;YAC9B,MAAM,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,IAAI,CAAC,CAAA;QAClD,CAAC;aAAM,CAAC;YACN,MAAM,OAAO,CACX,EAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE,YAAY,EAAE,qCAAqC,IAAI,EAAE,EAAC,EACxF,KAAK,IAAI,EAAE,CAAC,MAAM,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CACzC,CAAA;QACH,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,2BAA2B,CAAC,IAAI,EAAE,QAAQ,GAAG,GAAG;QAC9C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9C,OAAO,CAAC,mBAAmB,CAAC,CAAA;QAC9B,CAAC;QAED,IAAI,IAAI,CAAC,MAAM,IAAI,QAAQ,EAAE,CAAC;YAC5B,OAAO,IAAI,CAAA;QACb,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAA;QACnD,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAA;QAE1C,OAAO,CAAC,iBAAiB,QAAQ,OAAO,IAAI,CAAC,MAAM,kBAAkB,WAAW,WAAW,EAAE,GAAG,QAAQ,CAAC,CAAA;IAC3G,CAAC;IAED;;;OAGG;IACH,0BAA0B,CAAC,IAAI;QAC7B,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAA;QAE5B,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,2BAA2B,CAAC,IAAI,CAAC,EAAE,CAAC;YAC1D,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QACnB,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,cAAc;QAClB,IAAI,CAAC,QAAQ,CAAC,8BAA8B,CAAC,CAAA;QAC7C,MAAM,IAAI,GAAG,IAAI,CAAC,gBAAgB,CAAA;QAElC,IAAI,CAAC,QAAQ,CAAC,gCAAgC,IAAI,EAAE,CAAC,CAAA;QACrD,MAAM,EAAE,CAAC,KAAK,CAAC,IAAI,EAAE,EAAC,SAAS,EAAE,IAAI,EAAC,CAAC,CAAA;QAEvC,IAAI,CAAC,QAAQ,CAAC,kCAAkC,CAAC,CAAA;QACjD,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,iCAAiC,EAAC,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC,cAAc,EAAE,CAAC,CAAA;QAEhK,IAAI,CAAC,QAAQ,CAAC,2BAA2B,CAAC,CAAA;QAC1C,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAA;QACtB,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAA;QAC3D,MAAM,cAAc,GAAG,GAAG,IAAI,IAAI,SAAS,MAAM,CAAA;QACjD,MAAM,QAAQ,GAAG,GAAG,IAAI,IAAI,SAAS,OAAO,CAAA;QAC5C,MAAM,QAAQ,GAAG,GAAG,IAAI,IAAI,SAAS,WAAW,CAAA;QAEhD,IAAI,CAAC,QAAQ,CAAC,sBAAsB,CAAC,CAAA;QACrC,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,oCAAoC,EAAC,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC,CAAA;QACxI,MAAM,IAAI,GAAG,MAAM,OAAO,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,iCAAiC,EAAC,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC,CAAA;QAC9H,MAAM,UAAU,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAA;QACjC,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,CAAA;QAErC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAA;QAC9B,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAA;QACxC,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAA;QAC7C,MAAM,EAAE,CAAC,SAAS,CAAC,cAAc,EAAE,YAAY,EAAE,QAAQ,CAAC,CAAA;QAE1D,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,aAAa,EAAE,CAAA;QAE7C,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,UAAU,CAAC,CAAA;QACvC,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;QAC9B,OAAO,CAAC,GAAG,CAAC,aAAa,EAAE,cAAc,CAAC,CAAA;QAC1C,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;QAE9B,OAAO;YACL,UAAU;YACV,IAAI;YACJ,QAAQ;YACR,IAAI;YACJ,QAAQ;YACR,cAAc;SACf,CAAA;IACH,CAAC;IAED,+BAA+B;IAC/B,KAAK,CAAC,UAAU;QACd,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAA;QACjC,CAAC;IACH,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport fs from \"node:fs/promises\"\nimport moment from \"moment\"\nimport {prettify} from \"htmlfy\"\nimport timeout from \"awaitery/build/timeout.js\"\nimport SeleniumDriver from \"./drivers/selenium-driver.js\"\nimport AppiumDriver from \"./drivers/appium-driver.js\"\n\n/**\n * @typedef {object} BrowserArgs\n * @property {boolean} [debug] Enable debug logging.\n * @property {BrowserDriverConfig} [driver] Driver configuration.\n * @property {import(\"./system-test-communicator.js\").default} [communicator] Optional command communicator for helper-driven navigation.\n * @property {string} [screenshotsPath] Directory used for saved screenshots and browser artifacts.\n */\n/**\n * @typedef {object} BrowserDriverConfig\n * @property {\"selenium\"|\"appium\"} [type] Driver implementation to use.\n * @property {Record<string, any>} [options] Driver-specific options.\n */\n\n/** Generic browser session wrapper around the configured driver. */\nexport default class Browser {\n  /** @type {import(\"selenium-webdriver\").WebDriver | undefined} */\n  driver = undefined\n\n  /** @type {import(\"./drivers/webdriver-driver.js\").default | undefined} */\n  driverAdapter = undefined\n\n  _debug = false\n  /** @type {BrowserDriverConfig | undefined} */\n  _driverConfig = undefined\n  /** @type {Error | undefined} */\n  _httpServerError = undefined\n\n  /** @param {BrowserArgs} [args] */\n  constructor({debug = false, driver, communicator, screenshotsPath = `${process.cwd()}/tmp/screenshots`, ...restArgs} = {}) {\n    const restArgsKeys = Object.keys(restArgs)\n\n    if (restArgsKeys.length > 0) {\n      throw new Error(`Unknown browser arguments: ${restArgsKeys.join(\", \")}`)\n    }\n\n    this._debug = debug\n    this._driverConfig = driver\n    this._screenshotsPath = screenshotsPath\n    this.communicator = communicator\n    this.driverAdapter = this.createDriver(driver)\n  }\n\n  /**\n   * @param {BrowserDriverConfig} [driverConfig]\n   * @returns {import(\"./drivers/webdriver-driver.js\").default}\n   */\n  createDriver(driverConfig = {}) {\n    const {type = \"selenium\", options, ...restArgs} = driverConfig\n    const restArgsKeys = Object.keys(restArgs)\n\n    if (restArgsKeys.length > 0) {\n      throw new Error(`Unknown driver args: ${restArgsKeys.join(\", \")}`)\n    }\n\n    if (type === \"selenium\") {\n      return new SeleniumDriver({browser: this, options})\n    }\n\n    if (type === \"appium\") {\n      return new AppiumDriver({browser: this, options})\n    }\n\n    throw new Error(`Unsupported driver type: ${type}`)\n  }\n\n  /**\n   * @param {import(\"./system-test-communicator.js\").default | undefined} communicator\n   * @returns {void}\n   */\n  setCommunicator(communicator) {\n    this.communicator = communicator\n  }\n\n  /** @returns {boolean} */\n  communicatorExists() {\n    return Boolean(this.communicator)\n  }\n\n  /**\n   * @param {string} baseSelector\n   * @returns {void}\n   */\n  setBaseSelector(baseSelector) { this._baseSelector = baseSelector }\n\n  /** @returns {string | undefined} */\n  getBaseSelector() { return this._baseSelector }\n\n  /**\n   * @param {string} selector\n   * @returns {string}\n   */\n  getSelector(selector) {\n    return this.getBaseSelector() ? `${this.getBaseSelector()} ${selector}` : selector\n  }\n\n  /**\n   * @param {...any} args\n   * @returns {void}\n   */\n  debugError(...args) {\n    console.error(\"[Browser error]\", ...args)\n  }\n\n  /**\n   * @param {...any} args\n   * @returns {void}\n   */\n  debugLog(...args) {\n    if (this._debug) {\n      console.log(\"[Browser debug]\", ...args)\n    }\n  }\n\n  /** @returns {void} */\n  throwIfHttpServerError() {\n    if (this._httpServerError) {\n      throw new Error(`HTTP server error: ${this._httpServerError.message}`)\n    }\n  }\n\n  /**\n   * @param {Error} error\n   * @returns {void}\n   */\n  onHttpServerError = (error) => {\n    const errorMessage = error instanceof Error ? error.message : String(error)\n\n    this._httpServerError = error instanceof Error ? error : new Error(errorMessage)\n    console.error(`HTTP server error: ${errorMessage}`)\n  }\n\n  /** @returns {import(\"selenium-webdriver\").WebDriver} */\n  getDriver() {\n    return this.getDriverAdapter().getWebDriver()\n  }\n\n  /** @returns {import(\"./drivers/webdriver-driver.js\").default} */\n  getDriverAdapter() {\n    if (!this.driverAdapter) {\n      throw new Error(\"Driver hasn't been initialized yet\")\n    }\n\n    return this.driverAdapter\n  }\n\n  /** @returns {number} */\n  getTimeouts() { return this.getDriverAdapter().getTimeouts() }\n\n  /** @returns {Promise<void>} */\n  async restoreTimeouts() {\n    await this.getDriverAdapter().restoreTimeouts()\n  }\n\n  /**\n   * @param {number} newTimeout\n   * @returns {Promise<void>}\n   */\n  async driverSetTimeouts(newTimeout) {\n    await this.getDriverAdapter().driverSetTimeouts(newTimeout)\n  }\n\n  /**\n   * @param {number} newTimeout\n   * @returns {Promise<void>}\n   */\n  async setTimeouts(newTimeout) {\n    await this.getDriverAdapter().setTimeouts(newTimeout)\n  }\n\n  /** @returns {Promise<string[]>} */\n  async getBrowserLogs() {\n    return await this.getDriverAdapter().getBrowserLogs()\n  }\n\n  /** @returns {Promise<string>} */\n  async getCurrentUrl() {\n    return await this.getDriverAdapter().getCurrentUrl()\n  }\n\n  /**\n   * @param {string} selector\n   * @param {import(\"./system-test.js\").FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement[]>}\n   */\n  async all(selector, args = {}) {\n    return await this.getDriverAdapter().all(selector, args)\n  }\n\n  /**\n   * @param {string} selector\n   * @param {import(\"./system-test.js\").FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async find(selector, args = {}) {\n    return await this.getDriverAdapter().find(selector, args)\n  }\n\n  /**\n   * @param {string} testID\n   * @param {import(\"./system-test.js\").FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async findByTestID(testID, args) {\n    return await this.getDriverAdapter().findByTestID(testID, args)\n  }\n\n  /**\n   * @param {string} selector\n   * @param {import(\"./system-test.js\").FindArgs} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async findNoWait(selector, args = {}) {\n    return await this.getDriverAdapter().findNoWait(selector, args)\n  }\n\n  /**\n   * @param {string | import(\"selenium-webdriver\").WebElement} elementOrIdentifier\n   * @param {import(\"./system-test.js\").FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async click(elementOrIdentifier, args) {\n    await this.getDriverAdapter().click(elementOrIdentifier, args)\n  }\n\n  /**\n   * @param {import(\"selenium-webdriver\").WebElement|string|{selector: string} & import(\"./system-test.js\").FindArgs} elementOrIdentifier\n   * @param {string} methodName\n   * @param {...any} args\n   * @returns {Promise<any>}\n   */\n  async interact(elementOrIdentifier, methodName, ...args) {\n    return await this.getDriverAdapter().interact(elementOrIdentifier, methodName, ...args)\n  }\n\n  /**\n   * @param {string} selector\n   * @param {import(\"./system-test.js\").WaitForNoSelectorArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async waitForNoSelector(selector, args = {}) {\n    await this.getDriverAdapter().waitForNoSelector(selector, args)\n  }\n\n  /**\n   * @param {string} selector\n   * @param {import(\"./system-test.js\").FindArgs} [args]\n   * @returns {Promise<void>}\n   */\n  async expectNoElement(selector, args = {}) {\n    let found = false\n\n    try {\n      await this.findNoWait(selector, args)\n      found = true\n    } catch (error) {\n      if (error instanceof Error && error.message.startsWith(\"Element couldn't be found after \")) {\n        // Ignore\n      } else {\n        throw error\n      }\n    }\n\n    if (found) {\n      throw new Error(`Expected not to find: ${selector}`)\n    }\n  }\n\n  /** @returns {Promise<string>} */\n  async getHTML() {\n    return await this.getDriverAdapter().getHTML()\n  }\n\n  /**\n   * @param {string} path\n   * @returns {Promise<void>}\n   */\n  async driverVisit(path) {\n    await this.getDriverAdapter().driverVisit(path)\n  }\n\n  /**\n   * @param {string} type\n   * @param {string} path\n   * @returns {Promise<void>}\n   */\n  async sendBrowserCommand(type, path) {\n    if (!this.communicator) {\n      throw new Error(\"Communicator hasn't been initialized yet\")\n    }\n\n    await timeout(\n      {timeout: this.getTimeouts(), errorMessage: `timeout while sending browser command ${type}: ${path}`},\n      async () => await this.communicator.sendCommand({type, path})\n    )\n  }\n\n  /**\n   * Visits a path using the injected browser helper when available, otherwise navigates directly with the driver.\n   * @param {string} path\n   * @returns {Promise<void>}\n   */\n  async visit(path) {\n    if (this.communicatorExists()) {\n      await this.sendBrowserCommand(\"visit\", path)\n    } else {\n      await timeout(\n        {timeout: this.getTimeouts(), errorMessage: `timeout while visiting path: ${path}`},\n        async () => await this.driverVisit(path)\n      )\n    }\n  }\n\n  /**\n   * Dismisses to a path via the injected browser helper when available, otherwise navigates directly with the driver.\n   * @param {string} path\n   * @returns {Promise<void>}\n   */\n  async dismissTo(path) {\n    if (this.communicatorExists()) {\n      await this.sendBrowserCommand(\"dismissTo\", path)\n    } else {\n      await timeout(\n        {timeout: this.getTimeouts(), errorMessage: `timeout while dismissing to path: ${path}`},\n        async () => await this.driverVisit(path)\n      )\n    }\n  }\n\n  /**\n   * Formats browser logs for console output and truncates overly long output.\n   * @param {string[]} logs\n   * @param {number} [maxLines]\n   * @returns {string[]}\n   */\n  formatBrowserLogsForConsole(logs, maxLines = 200) {\n    if (!Array.isArray(logs) || logs.length === 0) {\n      return [\"(no browser logs)\"]\n    }\n\n    if (logs.length <= maxLines) {\n      return logs\n    }\n\n    const keptLogs = logs.slice(logs.length - maxLines)\n    const hiddenCount = logs.length - maxLines\n\n    return [`(showing last ${maxLines} of ${logs.length} browser logs, ${hiddenCount} omitted)`, ...keptLogs]\n  }\n\n  /**\n   * @param {string[]} logs\n   * @returns {void}\n   */\n  printBrowserLogsForFailure(logs) {\n    console.log(\"Browser logs:\")\n\n    for (const line of this.formatBrowserLogsForConsole(logs)) {\n      console.log(line)\n    }\n  }\n\n  /**\n   * Takes a screenshot, writes HTML/browser logs to disk, and returns the collected artifacts.\n   * @returns {Promise<{currentUrl: string, html: string, htmlPath: string, logs: string[], logsPath: string, screenshotPath: string}>}\n   */\n  async takeScreenshot() {\n    this.debugLog(\"Getting path for screenshots\")\n    const path = this._screenshotsPath\n\n    this.debugLog(`Creating dir with recursive: ${path}`)\n    await fs.mkdir(path, {recursive: true})\n\n    this.debugLog(\"Getting screenshot image content\")\n    const imageContent = await timeout({timeout: 5000, errorMessage: \"timeout while taking screenshot\"}, async () => await this.getDriverAdapter().takeScreenshot())\n\n    this.debugLog(\"Generating date variables\")\n    const now = new Date()\n    const timestamp = moment(now).format(\"YYYY-MM-DD-HH-MM-SS\")\n    const screenshotPath = `${path}/${timestamp}.png`\n    const htmlPath = `${path}/${timestamp}.html`\n    const logsPath = `${path}/${timestamp}.logs.txt`\n\n    this.debugLog(\"Getting browser logs\")\n    const logs = await timeout({timeout: 5000, errorMessage: \"timeout while reading browser logs\"}, async () => await this.getBrowserLogs())\n    const html = await timeout({timeout: 5000, errorMessage: \"timeout while reading page HTML\"}, async () => await this.getHTML())\n    const htmlPretty = prettify(html)\n    this.printBrowserLogsForFailure(logs)\n\n    this.debugLog(\"Writing files\")\n    await fs.writeFile(htmlPath, htmlPretty)\n    await fs.writeFile(logsPath, logs.join(\"\\n\"))\n    await fs.writeFile(screenshotPath, imageContent, \"base64\")\n\n    const currentUrl = await this.getCurrentUrl()\n\n    console.log(\"Current URL:\", currentUrl)\n    console.log(\"Logs:\", logsPath)\n    console.log(\"Screenshot:\", screenshotPath)\n    console.log(\"HTML:\", htmlPath)\n\n    return {\n      currentUrl,\n      html,\n      htmlPath,\n      logs,\n      logsPath,\n      screenshotPath\n    }\n  }\n\n  /** @returns {Promise<void>} */\n  async stopDriver() {\n    if (this.driverAdapter) {\n      await this.driverAdapter.stop()\n    }\n  }\n}\n"]}

package/build/cli-helpers.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @param {string[]} argv
+ * @returns {{_: string[], flags: Record<string, any>}}
+ */
+export function parseArgv(argv: string[]): {
+    _: string[];
+    flags: Record<string, any>;
+};
+/**
+ * @param {Record<string, any>} flags
+ * @returns {{command: string, args: Record<string, any>}}
+ */
+export function resolveBrowserCommand(flags: Record<string, any>): {
+    command: string;
+    args: Record<string, any>;
+};

package/build/cli-helpers.js

@@ -0,0 +1,141 @@
+/**
+ * @param {string[]} argv
+ * @returns {{_: string[], flags: Record<string, any>}}
+ */
+export function parseArgv(argv) {
+    const result = { _: [], flags: {} };
+    const setFlag = (key, value) => {
+        if (!(key in result.flags)) {
+            result.flags[key] = value;
+            return;
+        }
+        if (!Array.isArray(result.flags[key])) {
+            result.flags[key] = [result.flags[key]];
+        }
+        result.flags[key].push(value);
+    };
+    for (let index = 0; index < argv.length; index++) {
+        const value = argv[index];
+        if (!value.startsWith("--")) {
+            result._.push(value);
+            continue;
+        }
+        const flag = value.slice(2);
+        if (flag.includes("=")) {
+            const [key, ...rest] = flag.split("=");
+            setFlag(key, rest.join("="));
+            continue;
+        }
+        const nextValue = argv[index + 1];
+        if (nextValue && !nextValue.startsWith("--")) {
+            setFlag(flag, nextValue);
+            index += 1;
+        }
+        else {
+            setFlag(flag, true);
+        }
+    }
+    return result;
+}
+/**
+ * @param {Record<string, any>} flags
+ * @returns {{command: string, args: Record<string, any>}}
+ */
+export function resolveBrowserCommand(flags) {
+    if (flags.visit) {
+        return { args: { url: flags.visit }, command: "visit" };
+    }
+    if (flags["dismiss-to"]) {
+        return { args: { path: flags["dismiss-to"] }, command: "dismissTo" };
+    }
+    if (flags["find-by-test-id"]) {
+        return {
+            args: {
+                testID: flags["find-by-test-id"],
+                timeout: flags.timeout,
+                useBaseSelector: flags["use-base-selector"],
+                visible: flags.visible
+            },
+            command: "findByTestID"
+        };
+    }
+    if (flags.find) {
+        return {
+            args: {
+                selector: flags.find,
+                timeout: flags.timeout,
+                useBaseSelector: flags["use-base-selector"],
+                visible: flags.visible
+            },
+            command: "find"
+        };
+    }
+    if (flags.click) {
+        return {
+            args: {
+                selector: flags.click,
+                timeout: flags.timeout,
+                useBaseSelector: flags["use-base-selector"],
+                visible: flags.visible
+            },
+            command: "click"
+        };
+    }
+    if (flags["wait-for-no-selector"]) {
+        return {
+            args: {
+                selector: flags["wait-for-no-selector"],
+                useBaseSelector: flags["use-base-selector"]
+            },
+            command: "waitForNoSelector"
+        };
+    }
+    if (flags["expect-no-element"]) {
+        return {
+            args: {
+                selector: flags["expect-no-element"],
+                useBaseSelector: flags["use-base-selector"]
+            },
+            command: "expectNoElement"
+        };
+    }
+    if (flags["set-base-selector"]) {
+        return { args: { selector: flags["set-base-selector"] }, command: "setBaseSelector" };
+    }
+    if (flags["get-html"]) {
+        return { args: {}, command: "getHTML" };
+    }
+    if (flags["get-browser-logs"]) {
+        return { args: {}, command: "getBrowserLogs" };
+    }
+    if (flags["get-current-url"]) {
+        return { args: {}, command: "getCurrentUrl" };
+    }
+    if (flags["take-screenshot"]) {
+        return { args: {}, command: "takeScreenshot" };
+    }
+    if (flags.command) {
+        const args = {};
+        if (flags.url)
+            args.url = flags.url;
+        if (flags.path)
+            args.path = flags.path;
+        if (flags.selector)
+            args.selector = flags.selector;
+        if (flags["test-id"])
+            args.testID = flags["test-id"];
+        if (flags.method)
+            args.methodName = flags.method;
+        if (flags.arg)
+            args.args = Array.isArray(flags.arg) ? flags.arg : [flags.arg];
+        if (flags.timeout)
+            args.timeout = flags.timeout;
+        if (flags.visible !== undefined)
+            args.visible = flags.visible;
+        if (flags["use-base-selector"] !== undefined)
+            args.useBaseSelector = flags["use-base-selector"];
+        return { args, command: flags.command };
+    }
+    throw new Error("No browser command was given");
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli-helpers.js","sourceRoot":"","sources":["../src/cli-helpers.js"],"names":[],"mappings":"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","sourcesContent":["/**\n * @param {string[]} argv\n * @returns {{_: string[], flags: Record<string, any>}}\n */\nexport function parseArgv(argv) {\n  const result = {_: [], flags: {}}\n  const setFlag = (key, value) => {\n    if (!(key in result.flags)) {\n      result.flags[key] = value\n      return\n    }\n\n    if (!Array.isArray(result.flags[key])) {\n      result.flags[key] = [result.flags[key]]\n    }\n\n    result.flags[key].push(value)\n  }\n\n  for (let index = 0; index < argv.length; index++) {\n    const value = argv[index]\n\n    if (!value.startsWith(\"--\")) {\n      result._.push(value)\n      continue\n    }\n\n    const flag = value.slice(2)\n\n    if (flag.includes(\"=\")) {\n      const [key, ...rest] = flag.split(\"=\")\n\n      setFlag(key, rest.join(\"=\"))\n      continue\n    }\n\n    const nextValue = argv[index + 1]\n\n    if (nextValue && !nextValue.startsWith(\"--\")) {\n      setFlag(flag, nextValue)\n      index += 1\n    } else {\n      setFlag(flag, true)\n    }\n  }\n\n  return result\n}\n\n/**\n * @param {Record<string, any>} flags\n * @returns {{command: string, args: Record<string, any>}}\n */\nexport function resolveBrowserCommand(flags) {\n  if (flags.visit) {\n    return {args: {url: flags.visit}, command: \"visit\"}\n  }\n\n  if (flags[\"dismiss-to\"]) {\n    return {args: {path: flags[\"dismiss-to\"]}, command: \"dismissTo\"}\n  }\n\n  if (flags[\"find-by-test-id\"]) {\n    return {\n      args: {\n        testID: flags[\"find-by-test-id\"],\n        timeout: flags.timeout,\n        useBaseSelector: flags[\"use-base-selector\"],\n        visible: flags.visible\n      },\n      command: \"findByTestID\"\n    }\n  }\n\n  if (flags.find) {\n    return {\n      args: {\n        selector: flags.find,\n        timeout: flags.timeout,\n        useBaseSelector: flags[\"use-base-selector\"],\n        visible: flags.visible\n      },\n      command: \"find\"\n    }\n  }\n\n  if (flags.click) {\n    return {\n      args: {\n        selector: flags.click,\n        timeout: flags.timeout,\n        useBaseSelector: flags[\"use-base-selector\"],\n        visible: flags.visible\n      },\n      command: \"click\"\n    }\n  }\n\n  if (flags[\"wait-for-no-selector\"]) {\n    return {\n      args: {\n        selector: flags[\"wait-for-no-selector\"],\n        useBaseSelector: flags[\"use-base-selector\"]\n      },\n      command: \"waitForNoSelector\"\n    }\n  }\n\n  if (flags[\"expect-no-element\"]) {\n    return {\n      args: {\n        selector: flags[\"expect-no-element\"],\n        useBaseSelector: flags[\"use-base-selector\"]\n      },\n      command: \"expectNoElement\"\n    }\n  }\n\n  if (flags[\"set-base-selector\"]) {\n    return {args: {selector: flags[\"set-base-selector\"]}, command: \"setBaseSelector\"}\n  }\n\n  if (flags[\"get-html\"]) {\n    return {args: {}, command: \"getHTML\"}\n  }\n\n  if (flags[\"get-browser-logs\"]) {\n    return {args: {}, command: \"getBrowserLogs\"}\n  }\n\n  if (flags[\"get-current-url\"]) {\n    return {args: {}, command: \"getCurrentUrl\"}\n  }\n\n  if (flags[\"take-screenshot\"]) {\n    return {args: {}, command: \"takeScreenshot\"}\n  }\n\n  if (flags.command) {\n    const args = {}\n\n    if (flags.url) args.url = flags.url\n    if (flags.path) args.path = flags.path\n    if (flags.selector) args.selector = flags.selector\n    if (flags[\"test-id\"]) args.testID = flags[\"test-id\"]\n    if (flags.method) args.methodName = flags.method\n    if (flags.arg) args.args = Array.isArray(flags.arg) ? flags.arg : [flags.arg]\n    if (flags.timeout) args.timeout = flags.timeout\n    if (flags.visible !== undefined) args.visible = flags.visible\n    if (flags[\"use-base-selector\"] !== undefined) args.useBaseSelector = flags[\"use-base-selector\"]\n\n    return {args, command: flags.command}\n  }\n\n  throw new Error(\"No browser command was given\")\n}\n"]}

package/build/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};