@samsara-dev/appwright 0.2.0

package/dist/reporter.js

@@ -0,0 +1,216 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const providers_1 = require("./providers");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+const ffmpeg_1 = __importDefault(require("@ffmpeg-installer/ffmpeg"));
+const logger_1 = require("./logger");
+const utils_1 = require("./utils");
+const workerInfo_1 = require("./fixture/workerInfo");
+class VideoDownloader {
+    downloadPromises = [];
+    onBegin() {
+        if (fs_1.default.existsSync((0, utils_1.basePath)())) {
+            fs_1.default.rmSync((0, utils_1.basePath)(), {
+                recursive: true,
+            });
+        }
+    }
+    onTestBegin(test, result) {
+        logger_1.logger.log(`Starting test: ${test.title} on worker ${result.workerIndex}`);
+        const workerInfoStore = new workerInfo_1.WorkerInfoStore();
+        void workerInfoStore.saveTestStartTime(result.workerIndex, test.title, new Date());
+    }
+    onTestEnd(test, result) {
+        logger_1.logger.log(`Ending test: ${test.title} on worker ${result.workerIndex}`);
+        const sessionIdAnnotation = test.annotations.find(({ type }) => type === "sessionId");
+        const providerNameAnnotation = test.annotations.find(({ type }) => type === "providerName");
+        // Check if test ran on `device` or on `persistentDevice`
+        const isTestUsingDevice = sessionIdAnnotation && providerNameAnnotation;
+        if (isTestUsingDevice) {
+            // This is a test that ran with the `device` fixture
+            const sessionId = sessionIdAnnotation.description;
+            const providerName = providerNameAnnotation.description;
+            const provider = (0, providers_1.getProviderClass)(providerName);
+            this.downloadAndAttachDeviceVideo(test, result, provider, sessionId);
+            const otherAnnotations = test.annotations.filter(({ type }) => type !== "sessionId" && type !== "providerName");
+            test.annotations = otherAnnotations;
+        }
+        else {
+            // This is a test that ran on `persistentDevice` fixture
+            const { workerIndex, duration } = result;
+            if (duration <= 0) {
+                // Skipped tests
+                return;
+            }
+            test.annotations.push({
+                type: "workerInfo",
+                description: `Ran on worker #${workerIndex}.`,
+            });
+            const expectedVideoPath = path_1.default.join((0, utils_1.basePath)(), `worker-${workerIndex}-video.mp4`);
+            // The `onTestEnd` is method is called before the worker ends and
+            // the worker's `endTime` is saved to disk. We add a 5 secs delay
+            // to prevent a harmful race condition.
+            const workerDownload = waitFiveSeconds()
+                .then(() => getWorkerInfo(workerIndex))
+                .then(async (workerInfo) => {
+                if (!workerInfo) {
+                    throw new Error(`Worker info not found for idx: ${workerIndex}`);
+                }
+                const { providerName, sessionId, endTime } = workerInfo;
+                if (!providerName || !sessionId) {
+                    throw new Error(`Provider name or session id not found for worker: ${workerIndex}`);
+                }
+                if (!this.providerSupportsVideo(providerName)) {
+                    return; // Nothing to do here
+                }
+                if (endTime) {
+                    // This is the last test in the worker, so let's download the video
+                    const provider = (0, providers_1.getProviderClass)(providerName);
+                    const downloaded = await provider.downloadVideo(sessionId, (0, utils_1.basePath)(), `worker-${workerIndex}-video`);
+                    if (!downloaded) {
+                        return;
+                    }
+                    return this.trimAndAttachPersistentDeviceVideo(test, result, downloaded.path);
+                }
+                else {
+                    // This is an intermediate test in the worker, so let's wait for the
+                    // video file to be found on disk. Once it is, we trim and attach it.
+                    await waitFor(() => fs_1.default.existsSync(expectedVideoPath));
+                    return this.trimAndAttachPersistentDeviceVideo(test, result, expectedVideoPath);
+                }
+            })
+                .catch((e) => {
+                logger_1.logger.error("Failed to get worker end time:", e);
+            });
+            this.downloadPromises.push(workerDownload);
+        }
+    }
+    async onEnd() {
+        logger_1.logger.log(`Triggered onEnd`);
+        await Promise.allSettled(this.downloadPromises);
+    }
+    async trimAndAttachPersistentDeviceVideo(test, result, workerVideoPath) {
+        const workerIdx = result.workerIndex;
+        const workerStart = await getWorkerStartTime(workerIdx);
+        let pathToAttach = workerVideoPath;
+        const testStart = result.startTime;
+        if (testStart.getTime() < workerStart.getTime()) {
+            // This is the first test for the worker
+            // The startTime for the first test in the worker tends to be
+            // before worker (session) start time. This would have been manageable
+            // if the `duration` included the worker setup time, but the duration only
+            // covers the test method execution time.
+            // So in this case, we are not going to trim.
+            // TODO: We can use the startTime of the second test in the worker
+            pathToAttach = workerVideoPath;
+        }
+        else {
+            const trimSkipPoint = (testStart.getTime() - workerStart.getTime()) / 1000;
+            const trimmedFileName = `worker-${workerIdx}-trimmed-${test.id}.mp4`;
+            try {
+                pathToAttach = await trimVideo({
+                    originalVideoPath: workerVideoPath,
+                    startSecs: trimSkipPoint,
+                    durationSecs: result.duration / 1000,
+                    outputPath: trimmedFileName,
+                });
+            }
+            catch (e) {
+                logger_1.logger.error("Failed to trim video:", e);
+                test.annotations.push({
+                    type: "videoError",
+                    description: `Unable to trim video, attaching full video instead. Test starts at ${trimSkipPoint} secs.`,
+                });
+            }
+        }
+        result.attachments.push({
+            path: pathToAttach,
+            contentType: "video/mp4",
+            name: "video",
+        });
+    }
+    downloadAndAttachDeviceVideo(test, result, providerClass, sessionId) {
+        const videoFileName = `${test.id}`;
+        if (!providerClass.downloadVideo) {
+            return;
+        }
+        const downloadPromise = providerClass
+            .downloadVideo(sessionId, (0, utils_1.basePath)(), videoFileName)
+            .then((downloadedVideo) => {
+            if (!downloadedVideo) {
+                return;
+            }
+            result.attachments.push({
+                ...downloadedVideo,
+                name: "video",
+            });
+            return downloadedVideo;
+        });
+        this.downloadPromises.push(downloadPromise);
+    }
+    providerSupportsVideo(providerName) {
+        const provider = (0, providers_1.getProviderClass)(providerName);
+        return !!provider.downloadVideo;
+    }
+}
+function waitFor(condition, timeout = 60 * 60 * 1000) {
+    return new Promise((resolve, reject) => {
+        let interval;
+        const timeoutId = setTimeout(() => {
+            clearInterval(interval);
+            reject(new Error("Timed out waiting for condition"));
+        }, timeout);
+        interval = setInterval(() => {
+            if (condition()) {
+                clearInterval(interval);
+                clearTimeout(timeoutId);
+                resolve();
+            }
+        }, 500);
+    });
+}
+function trimVideo({ originalVideoPath, startSecs, durationSecs, outputPath, }) {
+    logger_1.logger.log(`Attemping to trim video: ${originalVideoPath} at start: ${startSecs} and duration: ${durationSecs} to ${outputPath}`);
+    const copyName = `draft-for-${outputPath}`;
+    const dirPath = path_1.default.dirname(originalVideoPath);
+    const copyFullPath = path_1.default.join(dirPath, copyName);
+    const fullOutputPath = path_1.default.join(dirPath, outputPath);
+    fs_1.default.copyFileSync(originalVideoPath, copyFullPath);
+    return new Promise((resolve, reject) => {
+        let stdErrs = "";
+        (0, fluent_ffmpeg_1.default)(copyFullPath)
+            .setFfmpegPath(ffmpeg_1.default.path)
+            .setStartTime(startSecs)
+            .setDuration(durationSecs)
+            .output(fullOutputPath)
+            .on("end", () => {
+            logger_1.logger.log(`Trimmed video saved at: ${fullOutputPath}`);
+            fs_1.default.unlinkSync(copyFullPath);
+            resolve(fullOutputPath);
+        })
+            .on("stderr", (stderrLine) => {
+            stdErrs += stderrLine + "\n";
+        })
+            .on("error", (err) => {
+            logger_1.logger.error("ffmpeg error:", err);
+            logger_1.logger.error("ffmpeg stderr:", stdErrs);
+            reject(err);
+        })
+            .run();
+    });
+}
+async function getWorkerStartTime(idx) {
+    const workerInfoStore = new workerInfo_1.WorkerInfoStore();
+    return workerInfoStore.getWorkerStartTime(idx);
+}
+async function getWorkerInfo(idx) {
+    const workerInfoStore = new workerInfo_1.WorkerInfoStore();
+    return workerInfoStore.getWorkerFromDisk(idx);
+}
+const waitFiveSeconds = () => new Promise((resolve) => setTimeout(resolve, 5000));
+exports.default = VideoDownloader;

package/dist/tests/locator.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=locator.spec.d.ts.map

package/dist/tests/locator.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locator.spec.d.ts","sourceRoot":"","sources":["../../src/tests/locator.spec.ts"],"names":[],"mappings":""}

package/dist/tests/locator.spec.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const locator_1 = require("../locator");
+const errors_1 = require("../types/errors");
+(0, vitest_1.test)("isVisible on unknown element", async () => {
+    const mockFindElements = vitest_1.vi.fn().mockResolvedValue([]);
+    //@ts-ignore
+    const wdClientMock = {
+        findElements: mockFindElements,
+    };
+    const locator = new locator_1.Locator(wdClientMock, { expectTimeout: 1_000 }, "//unknown-selector", "xpath");
+    const isVisible = await locator.isVisible();
+    (0, vitest_1.expect)(isVisible).toBe(false);
+    (0, vitest_1.expect)(mockFindElements).toHaveBeenCalledTimes(2);
+});
+(0, vitest_1.test)("isVisible on element that is found but fails displayed check", async () => {
+    const mockFindElements = vitest_1.vi.fn().mockResolvedValue([
+        {
+            "element-6066-11e4-a52e-4f735466cecf": "element-id",
+        },
+    ]);
+    const mockIsElementDisplayed = vitest_1.vi.fn().mockResolvedValue(false);
+    //@ts-ignore
+    const wdClientMock = {
+        findElements: mockFindElements,
+        isElementDisplayed: mockIsElementDisplayed,
+    };
+    const locator = new locator_1.Locator(wdClientMock, { expectTimeout: 1_000 }, "//known-but-hidden-element", "xpath");
+    const isVisible = await locator.isVisible();
+    (0, vitest_1.expect)(isVisible).toBe(false);
+    (0, vitest_1.expect)(mockFindElements).toHaveBeenCalledTimes(2);
+    (0, vitest_1.expect)(mockIsElementDisplayed).toHaveBeenCalledTimes(2);
+    (0, vitest_1.expect)(mockIsElementDisplayed).toHaveBeenCalledWith("element-id");
+});
+(0, vitest_1.test)("isVisible on element that throws stale element reference", async () => {
+    const mockFindElements = vitest_1.vi.fn().mockResolvedValue([
+        {
+            "element-6066-11e4-a52e-4f735466cecf": "element-id",
+        },
+    ]);
+    const mockIsElementDisplayed = vitest_1.vi.fn().mockImplementation(() => {
+        class WebDriverInteralError extends Error {
+            constructor(name, ...args) {
+                super(...args);
+                this.name = name;
+            }
+        }
+        throw new WebDriverInteralError(`random stale element reference random`);
+    });
+    //@ts-ignore
+    const wdClientMock = {
+        findElements: mockFindElements,
+        isElementDisplayed: mockIsElementDisplayed,
+    };
+    const locator = new locator_1.Locator(wdClientMock, { expectTimeout: 1_000 }, "//known-element-that-keeps-throwing-stale-element-reference", "xpath");
+    const isVisible = await locator.isVisible();
+    (0, vitest_1.expect)(isVisible).toBe(false);
+    (0, vitest_1.expect)(mockFindElements).toHaveBeenCalledTimes(2);
+    (0, vitest_1.expect)(mockIsElementDisplayed).toHaveBeenCalledTimes(2);
+    (0, vitest_1.expect)(mockIsElementDisplayed).toHaveBeenCalledWith("element-id");
+});
+(0, vitest_1.test)("waitFor attached state works for hidden element", async () => {
+    const mockFindElements = vitest_1.vi.fn().mockResolvedValue([
+        {
+            "element-6066-11e4-a52e-4f735466cecf": "element-id",
+        },
+    ]);
+    const mockIsElementDisplayed = vitest_1.vi.fn().mockResolvedValue(false);
+    //@ts-ignore
+    const wdClientMock = {
+        findElements: mockFindElements,
+        isElementDisplayed: mockIsElementDisplayed,
+    };
+    const locator = new locator_1.Locator(wdClientMock, { expectTimeout: 1_000 }, "//attached-hidden-element", "xpath");
+    (0, vitest_1.expect)(await locator.waitFor("attached")).toBe(true);
+    (0, vitest_1.expect)(mockFindElements).toHaveBeenCalledTimes(1);
+    (0, vitest_1.expect)(mockIsElementDisplayed).toHaveBeenCalledTimes(0);
+});
+(0, vitest_1.test)("waitFor attached state throws TimeoutError", async () => {
+    const mockFindElements = vitest_1.vi.fn().mockResolvedValue([]);
+    //@ts-ignore
+    const wdClientMock = {
+        findElements: mockFindElements,
+    };
+    const locator = new locator_1.Locator(wdClientMock, { expectTimeout: 1_000 }, "//attached-hidden-element", "xpath");
+    await (0, vitest_1.expect)(locator.waitFor("attached")).rejects.toThrowError(errors_1.TimeoutError);
+    (0, vitest_1.expect)(mockFindElements).toHaveBeenCalledTimes(2);
+});

package/dist/tests/regex.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=regex.spec.d.ts.map

package/dist/tests/regex.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex.spec.d.ts","sourceRoot":"","sources":["../../src/tests/regex.spec.ts"],"names":[],"mappings":""}

package/dist/tests/regex.spec.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const utils_1 = require("../utils");
+(0, vitest_1.test)("longest deterministic group with one group", () => {
+    const pattern = /.*(Copy to clipboard)$/;
+    const substring = (0, utils_1.longestDeterministicGroup)(pattern);
+    (0, vitest_1.expect)(substring).toBe("Copy to clipboard");
+});
+(0, vitest_1.test)("longest deterministic group with no groups", () => {
+    const pattern = /.*Copy to clipboard$/;
+    const substring = (0, utils_1.longestDeterministicGroup)(pattern);
+    (0, vitest_1.expect)(substring).toBe(undefined);
+});
+(0, vitest_1.test)("longest deterministic group with group that has special chars", () => {
+    const pattern = /.*(Copy .* to clipboard)$/;
+    const substring = (0, utils_1.longestDeterministicGroup)(pattern);
+    (0, vitest_1.expect)(substring).toBe(undefined);
+});

package/dist/tests/vitest.config.d.mts

@@ -0,0 +1,3 @@
+declare const _default: import("vite").UserConfig;
+export default _default;
+//# sourceMappingURL=vitest.config.d.mts.map

package/dist/tests/vitest.config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.config.d.mts","sourceRoot":"","sources":["../../src/tests/vitest.config.mts"],"names":[],"mappings":";AAEA,wBAIG"}

package/dist/tests/vitest.config.mjs

@@ -0,0 +1,6 @@
+import { defineConfig } from "vitest/config";
+export default defineConfig({
+    test: {
+        exclude: ["example/**", "node_modules/**", "dist/**"],
+    },
+});

package/dist/types/errors.d.ts

@@ -0,0 +1,7 @@
+export declare class RetryableError extends Error {
+    constructor(message: string);
+}
+export declare class TimeoutError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/types/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/types/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,cAAe,SAAQ,KAAK;gBAC3B,OAAO,EAAE,MAAM;CAG5B;AAED,qBAAa,YAAa,SAAQ,KAAK;gBACzB,OAAO,EAAE,MAAM;CAG5B"}

package/dist/types/errors.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutError = exports.RetryableError = void 0;
+class RetryableError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.RetryableError = RetryableError;
+class TimeoutError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.TimeoutError = TimeoutError;

package/dist/types/index.d.ts

@@ -0,0 +1,234 @@
+import { Device } from "../device";
+import { z } from "zod";
+export type ExtractType<T> = T extends z.ZodType ? z.infer<T> : never;
+export type ActionOptions = {
+    timeout: number;
+};
+export type TimeoutOptions = {
+    /**
+     * The maximum amount of time (in milliseconds) to wait for the condition to be met.
+     */
+    expectTimeout: number;
+};
+export interface DeviceProvider {
+    /**
+     * Identifier for the Appium session. Can be undefined if the session was not created.
+     */
+    sessionId?: string;
+    /**
+     * Global setup validates the configuration.
+     */
+    globalSetup?(): Promise<void>;
+    /**
+     * Returns a device instance.
+     */
+    getDevice(): Promise<Device>;
+    /**
+     * Updates test details and test status.
+     *
+     * @param status of the test
+     * @param reason for the test status
+     * @param name of the test
+     */
+    syncTestDetails?: (details: {
+        status?: string;
+        reason?: string;
+        name?: string;
+    }) => Promise<void>;
+}
+export type AppwrightConfig = {
+    platform: Platform;
+    device: DeviceConfig;
+    buildPath: string;
+    appBundleId: string;
+    expectTimeout: number;
+};
+export type DeviceConfig = BrowserStackConfig | LambdaTestConfig | LocalDeviceConfig | EmulatorConfig;
+/**
+ * Configuration for devices running on Browserstack.
+ */
+export type BrowserStackConfig = {
+    provider: "browserstack";
+    /**
+     * The name of the device to be used on Browserstack.
+     * Checkout the list of devices supported by BrowserStack: https://www.browserstack.com/list-of-browsers-and-platforms/app_automate
+     * Example: "iPhone 15 Pro Max", "Samsung Galaxy S23 Ultra".
+     */
+    name: string;
+    /**
+     * The operating system version of the device to be used on Browserstack.
+     * Checkout the list of OS versions supported by BrowserStack: https://www.browserstack.com/list-of-browsers-and-platforms/app_automate
+     * Example: "14.0", "15.0".
+     */
+    osVersion: string;
+    /**
+     * The orientation of the device on Browserstack.
+     * Default orientation is "portrait".
+     */
+    orientation?: DeviceOrientation;
+    /**
+     * Whether to enable camera injection on the device.
+     * Default is false.
+     */
+    enableCameraImageInjection?: boolean;
+    /**
+     * Appium server version to request on BrowserStack.
+     * Defaults to Appium 3.1.0. Override if your account requires a different version.
+     */
+    appiumVersion?: string;
+};
+export type LambdaTestConfig = {
+    provider: "lambdatest";
+    /**
+     * The name of the device to be used on LambdaTest.
+     * Checkout the list of devices supported by LambdaTest: https://www.lambdatest.com/list-of-real-devices
+     * Example: "iPhone 15 Pro Max", "Galaxy S23 Ultra".
+     */
+    name: string;
+    /**
+     * The operating system version of the device to be used on LambdaTest.
+     * Checkout the list of OS versions supported by LambdaTest: https://www.lambdatest.com/list-of-real-devices
+     * Example: "14.0", "15.0".
+     */
+    osVersion: string;
+    /**
+     * The orientation of the device on LambdaTest.
+     * Default orientation is "portrait".
+     */
+    orientation?: DeviceOrientation;
+    /**
+     * Whether to enable camera injection on the device.
+     * Default is false.
+     */
+    enableCameraImageInjection?: boolean;
+    /**
+     * Appium server version to request on LambdaTest.
+     * Defaults to Appium 3.1.0. Override if your account requires a different version.
+     */
+    appiumVersion?: string;
+};
+/**
+ * Configuration for locally connected physical devices.
+ */
+export type LocalDeviceConfig = {
+    provider: "local-device";
+    name?: string;
+    /**
+     * The unique device identifier (UDID) of the connected local device.
+     */
+    udid?: string;
+    /**
+     * The orientation of the device.
+     * Default orientation is "portrait".
+     */
+    orientation?: DeviceOrientation;
+};
+/**
+ * Configuration for running tests on an Android or iOS emulator.
+ */
+export type EmulatorConfig = {
+    provider: "emulator";
+    name?: string;
+    osVersion?: string;
+    /**
+     * The unique device identifier (UDID) of the emulator.
+     */
+    udid?: string;
+    /**
+     * The orientation of the emulator.
+     * Default orientation is "portrait".
+     */
+    orientation?: DeviceOrientation;
+};
+export declare enum Platform {
+    ANDROID = "android",
+    IOS = "ios"
+}
+export declare enum DeviceOrientation {
+    PORTRAIT = "portrait",
+    LANDSCAPE = "landscape"
+}
+export declare enum ScrollDirection {
+    UP = "up",
+    DOWN = "down"
+}
+export interface AppwrightLocator {
+    /**
+     * Taps (clicks) on the element. This method waits for the element to be visible before clicking it.
+     *
+     * **Usage:**
+     * ```js
+     * await device.getByText("Submit").tap();
+     * ```
+     *
+     * @param options Use this to override the timeout for this action
+     */
+    tap(options?: ActionOptions): Promise<void>;
+    /**
+     * Fills the input element with the given value. This method waits for the element to be visible before filling it.
+     *
+     * **Usage:**
+     * ```js
+     * await device.getByText("Search").fill("My query");
+     * ```
+     *
+     * @param value The value to fill in the input field
+     * @param options Use this to override the timeout for this action
+     */
+    fill(value: string, options?: ActionOptions): Promise<void>;
+    /**
+     * Sends key strokes to the element. This method waits for the element to be visible before sending the key strokes.
+     *
+     * **Usage:**
+     * ```js
+     * await device.getByText("Search").sendKeyStrokes("My query");
+     * ```
+     *
+     * @param value The string to send as key strokes.
+     * @param options Use this to override the timeout for this action
+     */
+    sendKeyStrokes(value: string, options?: ActionOptions): Promise<void>;
+    /**
+     * Wait for the element to be visible or attached, while attempting for the `timeout` duration.
+     * Throws TimeoutError if element is not found within the timeout.
+     *
+     * **Usage:**
+     * ```js
+     * await device.getByText("Search").waitFor({ state: "visible" });
+     * ```
+     *
+     * @param state The state to wait for
+     * @param options Use this to override the timeout for this action
+     */
+    waitFor(state: "attached" | "visible", options?: ActionOptions): Promise<void>;
+    /**
+     * Waits for the element to be visible, while attempting for the `timeout` duration.
+     * Returns boolean based on the visibility of the element.
+     *
+     * **Usage:**
+     * ```js
+     * const isVisible = await device.getByText("Search").isVisible();
+     * ```
+     *
+     * @param options Use this to override the timeout for this action
+     */
+    isVisible(options?: ActionOptions): Promise<boolean>;
+    /**
+     * Returns the text content of the element. This method waits for the element to be visible before getting the text.
+     *
+     * **Usage:**
+     * ```js
+     * const textContent = await device.getByText("Search").getText();
+     * ```
+     *
+     * @param options Use this to override the timeout for this action
+     */
+    getText(options?: ActionOptions): Promise<string>;
+    scroll(direction: ScrollDirection): Promise<void>;
+}
+export declare enum WebDriverErrors {
+    StaleElementReferenceError = "stale element reference"
+}
+export type ElementReference = Record<ElementReferenceId, string>;
+export type ElementReferenceId = "element-6066-11e4-a52e-4f735466cecf";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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"}

package/dist/types/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebDriverErrors = exports.ScrollDirection = exports.DeviceOrientation = exports.Platform = void 0;
+var Platform;
+(function (Platform) {
+    Platform["ANDROID"] = "android";
+    Platform["IOS"] = "ios";
+})(Platform || (exports.Platform = Platform = {}));
+var DeviceOrientation;
+(function (DeviceOrientation) {
+    DeviceOrientation["PORTRAIT"] = "portrait";
+    DeviceOrientation["LANDSCAPE"] = "landscape";
+})(DeviceOrientation || (exports.DeviceOrientation = DeviceOrientation = {}));
+var ScrollDirection;
+(function (ScrollDirection) {
+    ScrollDirection["UP"] = "up";
+    ScrollDirection["DOWN"] = "down";
+})(ScrollDirection || (exports.ScrollDirection = ScrollDirection = {}));
+var WebDriverErrors;
+(function (WebDriverErrors) {
+    WebDriverErrors["StaleElementReferenceError"] = "stale element reference";
+})(WebDriverErrors || (exports.WebDriverErrors = WebDriverErrors = {}));

package/dist/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function boxedStep(target: Function, context: ClassMethodDecoratorContext): (this: {
+    selector: string | RegExp;
+}, ...args: any) => Promise<any>;
+export declare function validateBuildPath(buildPath: string | undefined, expectedExtension: string): void;
+export declare function getLatestBuildToolsVersions(versions: string[]): string | undefined;
+export declare function longestDeterministicGroup(pattern: RegExp): string | undefined;
+export declare function basePath(): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAIA,wBAAgB,SAAS,CACvB,MAAM,EAAE,QAAQ,EAChB,OAAO,EAAE,2BAA2B,UAG5B;IACJ,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;CAC3B,WACQ,GAAG,kBAmBf;AAED,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,iBAAiB,EAAE,MAAM,QAoB1B;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAAE,GACjB,MAAM,GAAG,SAAS,CAEpB;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAuB7E;AAED,wBAAgB,QAAQ,WAEvB"}