@taqwright/taqwright 0.0.24

package/dist/providers/appium.js

@@ -0,0 +1,288 @@
+import { spawn, exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { Platform } from '../types/index.js';
+import { logger } from '../logger.js';
+import { getLatestBuildToolsVersions } from '../utils.js';
+import { androidEnvForAvd } from '../setup/avd.js';
+import { spawnTool } from '../setup/spawn-tool.js';
+const execP = promisify(exec);
+export async function installDriver(driverName, opts = {}) {
+    const env = opts.env ?? process.env;
+    const cmd = opts.appiumPath ?? 'npx';
+    const prefix = opts.appiumPath ? [] : ['appium'];
+    await new Promise((resolve) => {
+        const p = spawnTool(cmd, [...prefix, 'driver', 'uninstall', driverName], {
+            stdio: 'pipe',
+            env,
+        });
+        p.on('exit', () => resolve());
+        p.on('error', () => resolve());
+    });
+    await new Promise((resolve, reject) => {
+        const p = spawnTool(cmd, [...prefix, 'driver', 'install', driverName], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env,
+        });
+        let out = '';
+        const cap = (d) => {
+            out += d.toString();
+        };
+        p.stdout?.on('data', cap);
+        p.stderr?.on('data', cap);
+        p.on('exit', (code) => code === 0
+            ? resolve()
+            : reject(new Error(`appium driver install ${driverName} exited ${code}` +
+                (out.trim() ? `\n${lastLines(out, 30)}` : ''))));
+        p.on('error', reject);
+    });
+}
+function lastLines(s, n) {
+    return s.trimEnd().split('\n').slice(-n).join('\n');
+}
+export async function startAppiumServer(provider, opts = {}, avdName) {
+    const args = [];
+    if (opts.host)
+        args.push('--address', opts.host);
+    if (opts.port !== undefined)
+        args.push('--port', String(opts.port));
+    if (opts.basePath && opts.basePath !== '/')
+        args.push('--base-path', opts.basePath);
+    args.push('--allow-insecure=*:chromedriver_autodownload');
+    const env = { ...process.env, ...((await androidEnvForAvd(avdName)) ?? {}) };
+    return spawnAppium('appium', args, provider, env, avdName).catch((err) => {
+        if (err.code === 'ENOENT') {
+            return spawnAppium('npx', ['appium', ...args], provider, env, avdName);
+        }
+        throw err;
+    });
+}
+function spawnAppium(cmd, args, provider, env, avdName) {
+    let emulatorStartRequested = false;
+    return new Promise((resolve, reject) => {
+        const proc = spawnTool(cmd, args, { stdio: 'pipe', env });
+        let settled = false;
+        let stderrText = '';
+        proc.stderr?.on('data', (data) => {
+            const text = data.toString();
+            stderrText += text;
+            logger.warn(text.trimEnd());
+        });
+        proc.on('exit', (code) => {
+            if (settled)
+                return;
+            settled = true;
+            const err = new Error(`Appium server "${cmd}" exited with code ${code ?? 'null'} before starting.`);
+            if (/not recognized|not found|ENOENT/i.test(stderrText))
+                err.code = 'ENOENT';
+            reject(err);
+        });
+        proc.stdout?.on('data', async (data) => {
+            const output = data.toString();
+            logger.log(output.trimEnd());
+            if (output.includes('Error: listen EADDRINUSE')) {
+                settled = true;
+                reject(new Error('Appium server is already running on this port. Stop it before running tests.'));
+                return;
+            }
+            if (output.includes('Could not find online devices')) {
+                if (!emulatorStartRequested && provider === 'emulator') {
+                    emulatorStartRequested = true;
+                    await startAndroidEmulator(avdName, env.ANDROID_HOME).catch((err) => logger.error(err));
+                }
+            }
+            if (output.includes('Appium REST http interface listener started')) {
+                settled = true;
+                logger.log('Appium server is up and running.');
+                resolve(proc);
+            }
+        });
+        proc.on('error', (err) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(err);
+        });
+        process.on('exit', () => proc.kill());
+    });
+}
+export function stopAppiumServer() {
+    return new Promise((resolve, reject) => {
+        exec('pkill -f appium', (err, stdout) => {
+            if (err)
+                return reject(err);
+            resolve(stdout);
+        });
+    });
+}
+async function getListenerPids(port) {
+    try {
+        const { stdout } = await execP(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t`);
+        return stdout
+            .trim()
+            .split('\n')
+            .map((l) => Number.parseInt(l.trim(), 10))
+            .filter((pid) => Number.isInteger(pid) && pid > 0);
+    }
+    catch {
+        return [];
+    }
+}
+async function isAppiumProcess(pid) {
+    try {
+        const { stdout } = await execP(`ps -p ${pid} -o command=`);
+        return /appium/i.test(stdout);
+    }
+    catch {
+        return false;
+    }
+}
+export async function killAppiumOnPort(port) {
+    let killed = false;
+    try {
+        const pids = await getListenerPids(port);
+        for (const pid of pids) {
+            if (!(await isAppiumProcess(pid)))
+                continue;
+            try {
+                process.kill(pid, 'SIGTERM');
+            }
+            catch {
+                continue;
+            }
+            killed = true;
+            await new Promise((r) => setTimeout(r, 500));
+            try {
+                process.kill(pid, 0);
+                process.kill(pid, 'SIGKILL');
+            }
+            catch {
+            }
+        }
+    }
+    catch (err) {
+        logger.warn(`Failed to kill Appium on port ${port}: ${String(err)}`);
+    }
+    return killed;
+}
+export function isEmulatorInstalled(platform) {
+    return new Promise((resolve, reject) => {
+        if (platform !== Platform.ANDROID) {
+            return resolve(true);
+        }
+        const androidHome = process.env.ANDROID_HOME;
+        if (!androidHome) {
+            return reject(new Error('ANDROID_HOME is not set.'));
+        }
+        const emulatorPath = path.join(androidHome, 'emulator', 'emulator');
+        exec(`${emulatorPath} -list-avds`, (err, stdout) => {
+            if (err) {
+                return reject(new Error('Could not list emulators. Install one via Android Studio AVD Manager.'));
+            }
+            const lines = stdout
+                .trim()
+                .split('\n')
+                .filter((l) => l.trim() && !l.startsWith('INFO') && !l.includes('/tmp/'));
+            if (lines.length === 0) {
+                return reject(new Error('No installed emulators found. Create one via Android Studio AVD Manager.'));
+            }
+            resolve(true);
+        });
+    });
+}
+export async function startAndroidEmulator(avdName, androidHome = process.env.ANDROID_HOME) {
+    if (!androidHome)
+        throw new Error('ANDROID_HOME is not set.');
+    const emulatorPath = path.join(androidHome, 'emulator', 'emulator');
+    const { stdout } = await execP(`${emulatorPath} -list-avds`);
+    const avds = stdout
+        .trim()
+        .split('\n')
+        .filter((l) => l.trim() && !l.startsWith('INFO') && !l.includes('/tmp/'));
+    if (avds.length === 0) {
+        throw new Error('No installed emulators found.');
+    }
+    const avd = avdName && avds.includes(avdName) ? avdName : avds[0];
+    logger.log(`Starting emulator: ${avd}`);
+    const child = spawn(emulatorPath, ['-avd', avd], { stdio: 'pipe' });
+    await new Promise((resolve, reject) => {
+        child.stdout?.on('data', (data) => {
+            const out = data.toString();
+            logger.log(`Emulator: ${out.trimEnd()}`);
+            if (out.includes("Successfully loaded snapshot 'default_boot'")) {
+                resolve();
+            }
+        });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code !== 0)
+                reject(new Error(`Emulator exited with code ${code}`));
+        });
+        process.on('exit', () => child.kill());
+    });
+}
+export function getAppBundleId(buildPath) {
+    return new Promise((resolve, reject) => {
+        exec(`osascript -e 'id of app "${buildPath}"'`, (err, stdout, stderr) => {
+            if (err)
+                return reject(err);
+            if (stderr)
+                return reject(new Error(stderr));
+            const id = stdout.trim();
+            if (!id)
+                return reject(new Error('Bundle ID not found'));
+            resolve(id);
+        });
+    });
+}
+export async function getConnectedIOSDeviceUDID() {
+    const { stdout } = await execP('xcrun xctrace list devices');
+    const realDevices = stdout
+        .split('\n')
+        .filter((l) => l.includes('iPhone') && !l.includes('Simulator'));
+    if (realDevices.length === 0) {
+        throw new Error('No connected iPhone detected. Make sure the device is plugged in and trusted.');
+    }
+    const m = realDevices[0].match(/\(([\da-fA-F-]+)\)$/);
+    if (!m || !m[1]) {
+        throw new Error('Could not parse UDID from xctrace output.');
+    }
+    return m[1];
+}
+export async function getActiveAndroidDevices() {
+    const { stdout } = await execP('adb devices');
+    return stdout
+        .trim()
+        .split('\n')
+        .filter((l) => l.includes('\tdevice')).length;
+}
+async function getLatestBuildToolsVersion() {
+    const androidHome = process.env.ANDROID_HOME;
+    if (!androidHome)
+        throw new Error('ANDROID_HOME is not set.');
+    const buildToolsPath = path.join(androidHome, 'build-tools');
+    const files = await readdir(buildToolsPath);
+    const versions = files.filter((f) => /^\d+\.\d+\.\d+(-rc\d+)?$/.test(f));
+    const latest = getLatestBuildToolsVersions(versions);
+    if (!latest) {
+        throw new Error(`No valid build-tools found in ${buildToolsPath}. Install via Android Studio SDK Manager.`);
+    }
+    return latest;
+}
+export async function getApkDetails(buildPath) {
+    const androidHome = process.env.ANDROID_HOME;
+    if (!androidHome)
+        throw new Error('ANDROID_HOME is not set.');
+    const buildTools = await getLatestBuildToolsVersion();
+    const aapt = path.join(androidHome, 'build-tools', buildTools, 'aapt');
+    const { stdout, stderr } = await execP(`${aapt} dump badging "${buildPath}"`);
+    if (stderr)
+        logger.warn(`aapt: ${stderr.trim()}`);
+    const pkg = stdout.match(/package: name='(\S+)'/);
+    const activity = stdout.match(/launchable-activity: name='(\S+)'/);
+    if (!pkg || !activity) {
+        throw new Error(`Unable to parse package / launchable-activity from APK: ${buildPath}`);
+    }
+    return { packageName: pkg[1], launchableActivity: activity[1] };
+}

package/dist/providers/browserstack/index.d.ts

@@ -0,0 +1,5 @@
+import { type TaqwrightUseOptions } from '../../types/index.js';
+import { CloudProvider } from '../cloud.js';
+export declare class BrowserStackDeviceProvider extends CloudProvider {
+    constructor(use: TaqwrightUseOptions, appBundleId: string | undefined, projectName?: string);
+}

package/dist/providers/browserstack/index.js

@@ -0,0 +1,77 @@
+import { Platform, } from '../../types/index.js';
+import { CloudProvider } from '../cloud.js';
+const APP_AUTOMATE = 'https://api-cloud.browserstack.com/app-automate';
+function buildCapabilities(use, projectName, appUrl) {
+    const platform = use.platform;
+    const device = use.device;
+    const userCaps = { ...(use.capabilities ?? {}) };
+    const userBstack = userCaps['bstack:options'] ?? {};
+    delete userCaps['bstack:options'];
+    const ciLabel = process.env.GITHUB_ACTIONS === 'true' ? `CI ${process.env.GITHUB_RUN_ID}` : process.env.USER;
+    return {
+        platformName: platform === Platform.IOS ? 'iOS' : 'Android',
+        'bstack:options': {
+            debug: true,
+            interactiveDebugging: true,
+            networkLogs: true,
+            enableCameraImageInjection: device.enableCameraImageInjection,
+            idleTimeout: 180,
+            deviceName: device.name,
+            osVersion: device.osVersion,
+            deviceOrientation: device.orientation,
+            buildName: `${projectName} ${platform}`,
+            sessionName: `${projectName} ${platform} test`,
+            buildIdentifier: ciLabel,
+            ...userBstack,
+        },
+        'appium:deviceName': device.name,
+        'appium:platformVersion': device.osVersion,
+        'appium:automationName': platform === Platform.IOS ? 'XCUITest' : 'UiAutomator2',
+        'appium:autoGrantPermissions': true,
+        'appium:app': appUrl,
+        'appium:autoAcceptAlerts': true,
+        'appium:fullReset': true,
+        ...(platform === Platform.IOS ? { 'appium:settings[snapshotMaxDepth]': 62 } : {}),
+        ...userCaps,
+    };
+}
+const browserStackSpec = {
+    provider: 'browserstack',
+    credentialEnv: ['BROWSERSTACK_USERNAME', 'BROWSERSTACK_ACCESS_KEY'],
+    prebuiltScheme: 'bs://',
+    appUrlEnvVar: (projectName) => `BROWSERSTACK_APP_URL_${projectName.toUpperCase()}`,
+    upload: {
+        endpoint: `${APP_AUTOMATE}/upload`,
+        urlBody: (buildPath) => new URLSearchParams({ url: buildPath }),
+        fileBody: (file, fileName) => {
+            const form = new FormData();
+            form.append('file', new Blob([new Uint8Array(file)]), fileName);
+            return form;
+        },
+    },
+    hub: { hostname: 'hub.browserstack.com', port: 443, path: '/wd/hub', protocol: 'https' },
+    buildCapabilities: ({ use, projectName, appUrl }) => buildCapabilities(use, projectName, appUrl),
+    syncRequest: (sessionId, details) => ({
+        url: `${APP_AUTOMATE}/sessions/${sessionId}.json`,
+        method: 'PUT',
+        body: details.status
+            ? JSON.stringify({ status: details.status, reason: details.reason })
+            : JSON.stringify({ name: details.name }),
+    }),
+    strictSync: true,
+    resolveBundleId: async (sessionId, authHeader) => {
+        const res = await fetch(`${APP_AUTOMATE}/sessions/${sessionId}.json`, {
+            headers: { Authorization: authHeader },
+        });
+        if (!res.ok) {
+            throw new Error(`Error fetching session details: ${res.statusText}`);
+        }
+        const data = (await res.json());
+        return data.automation_session?.app_details?.app_name ?? '';
+    },
+};
+export class BrowserStackDeviceProvider extends CloudProvider {
+    constructor(use, appBundleId, projectName) {
+        super(browserStackSpec, use, appBundleId, projectName);
+    }
+}

package/dist/providers/browserstack/utils.d.ts

@@ -0,0 +1 @@
+export declare function getAuthHeader(): string;

package/dist/providers/browserstack/utils.js

@@ -0,0 +1,6 @@
+export function getAuthHeader() {
+    const userName = process.env.BROWSERSTACK_USERNAME;
+    const accessKey = process.env.BROWSERSTACK_ACCESS_KEY;
+    const key = Buffer.from(`${userName}:${accessKey}`).toString('base64');
+    return `Basic ${key}`;
+}

package/dist/providers/cloud.d.ts

@@ -0,0 +1,53 @@
+import { type TaqwrightUseOptions, type DeviceHandle, type DeviceProvider } from '../types/index.js';
+export interface CloudSpec {
+    readonly provider: 'browserstack' | 'lambdatest';
+    readonly credentialEnv: readonly [string, string];
+    readonly prebuiltScheme: string;
+    appUrlEnvVar(projectName: string): string;
+    readonly upload: {
+        readonly endpoint: string;
+        urlBody(buildPath: string, projectName: string): URLSearchParams;
+        fileBody(file: Buffer, fileName: string, projectName: string): FormData;
+    };
+    readonly hub: {
+        readonly hostname: string;
+        readonly port: number;
+        readonly path: string;
+        readonly protocol: 'https';
+    };
+    buildCapabilities(args: {
+        use: TaqwrightUseOptions;
+        projectName: string;
+        appUrl: string;
+    }): Record<string, unknown>;
+    syncRequest(sessionId: string, details: {
+        status?: string;
+        reason?: string;
+        name?: string;
+    }): {
+        url: string;
+        method: string;
+        body: string;
+    };
+    readonly strictSync: boolean;
+    resolveBundleId?(sessionId: string, authHeader: string): Promise<string | undefined>;
+    readonly requireBundleId?: boolean;
+}
+export declare function basicAuth(user: string | undefined, key: string | undefined): string;
+export declare class CloudProvider implements DeviceProvider {
+    private readonly spec;
+    protected readonly use: TaqwrightUseOptions;
+    protected readonly appBundleId: string | undefined;
+    sessionId?: string;
+    protected readonly projectName: string;
+    constructor(spec: CloudSpec, use: TaqwrightUseOptions, appBundleId: string | undefined, projectName?: string);
+    private authHeader;
+    globalSetup(): Promise<void>;
+    private resolveAppUrl;
+    getDevice(): Promise<DeviceHandle>;
+    syncTestDetails(details: {
+        status?: string;
+        reason?: string;
+        name?: string;
+    }): Promise<void>;
+}

package/dist/providers/cloud.js

@@ -0,0 +1,117 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { logger } from '../logger.js';
+export function basicAuth(user, key) {
+    return `Basic ${Buffer.from(`${user}:${key}`).toString('base64')}`;
+}
+export class CloudProvider {
+    spec;
+    use;
+    appBundleId;
+    sessionId;
+    projectName;
+    constructor(spec, use, appBundleId, projectName) {
+        this.spec = spec;
+        this.use = use;
+        this.appBundleId = appBundleId;
+        if (use.device.provider !== spec.provider) {
+            throw new Error(`${spec.provider} provider received device.provider='${use.device.provider}'.`);
+        }
+        if (spec.requireBundleId && !appBundleId) {
+            throw new Error(`appBundleId is required for the ${spec.provider} provider — set it on the project.`);
+        }
+        this.projectName = projectName ?? path.basename(process.cwd());
+    }
+    authHeader() {
+        const [userVar, keyVar] = this.spec.credentialEnv;
+        return basicAuth(process.env[userVar], process.env[keyVar]);
+    }
+    async globalSetup() {
+        if (!this.use.buildPath) {
+            throw new Error('Build path not found. Set `buildPath` in your taqwright config.');
+        }
+        const [userVar, keyVar] = this.spec.credentialEnv;
+        if (!(process.env[userVar] && process.env[keyVar])) {
+            throw new Error(`${userVar} and ${keyVar} are required for the ${this.spec.provider} provider.`);
+        }
+        const appUrl = await this.resolveAppUrl(this.use.buildPath);
+        process.env[this.spec.appUrlEnvVar(this.projectName)] = appUrl;
+    }
+    async resolveAppUrl(buildPath) {
+        if (buildPath.startsWith(this.spec.prebuiltScheme)) {
+            return buildPath;
+        }
+        let body;
+        if (buildPath.startsWith('http')) {
+            body = this.spec.upload.urlBody(buildPath, this.projectName);
+        }
+        else {
+            if (!fs.existsSync(buildPath)) {
+                throw new Error(`Build file not found: ${buildPath}`);
+            }
+            const bytes = await fs.promises.readFile(buildPath);
+            body = this.spec.upload.fileBody(bytes, path.basename(buildPath), this.projectName);
+        }
+        logger.log(`Uploading: ${buildPath}`);
+        const res = await fetch(this.spec.upload.endpoint, {
+            method: 'POST',
+            headers: { Authorization: this.authHeader() },
+            body,
+        });
+        const data = (await res.json());
+        if (!data.app_url) {
+            logger.error('Build upload did not return an app URL:', data);
+        }
+        return data.app_url;
+    }
+    async getDevice() {
+        const device = this.use.device;
+        if (!device.name || !device.osVersion) {
+            throw new Error(`device.name and device.osVersion are required for the ${this.spec.provider} provider.`);
+        }
+        const envVar = this.spec.appUrlEnvVar(this.projectName);
+        const appUrl = process.env[envVar];
+        if (!appUrl) {
+            throw new Error(`process.env.${envVar} is not set — did the build upload run?`);
+        }
+        const [userVar, keyVar] = this.spec.credentialEnv;
+        const connection = {
+            ...this.spec.hub,
+            logLevel: 'warn',
+            connectionRetryTimeout: this.use.appium?.connectionTimeout ?? 300_000,
+            user: process.env[userVar],
+            key: process.env[keyVar],
+            capabilities: this.spec.buildCapabilities({
+                use: this.use,
+                projectName: this.projectName,
+                appUrl,
+            }),
+        };
+        const WebDriver = (await import('webdriver')).default;
+        const driver = await WebDriver.newSession(connection);
+        this.sessionId = driver.sessionId;
+        const bundleId = this.spec.resolveBundleId
+            ? await this.spec.resolveBundleId(this.sessionId, this.authHeader())
+            : this.appBundleId;
+        return {
+            driver,
+            bundleId,
+            options: { expectTimeout: this.use.expectTimeout ?? 30_000 },
+            provider: this.spec.provider,
+        };
+    }
+    async syncTestDetails(details) {
+        if (!this.sessionId) {
+            return;
+        }
+        const { url, method, body } = this.spec.syncRequest(this.sessionId, details);
+        const res = await fetch(url, {
+            method,
+            headers: { Authorization: this.authHeader(), 'Content-Type': 'application/json' },
+            body,
+        });
+        if (!res.ok && this.spec.strictSync) {
+            throw new Error(`Failed to sync ${this.spec.provider} session details: ${res.statusText}`);
+        }
+    }
+}

package/dist/providers/emulator/index.d.ts

@@ -0,0 +1,8 @@
+import { type TaqwrightUseOptions, type DeviceHandle, type DeviceProvider } from '../../types/index.js';
+export declare class EmulatorProvider implements DeviceProvider {
+    private readonly use;
+    sessionId?: string;
+    constructor(use: TaqwrightUseOptions, appBundleId?: string);
+    globalSetup(): Promise<void>;
+    getDevice(): Promise<DeviceHandle>;
+}

package/dist/providers/emulator/index.js

@@ -0,0 +1,47 @@
+import { Platform, } from '../../types/index.js';
+import { isEmulatorInstalled } from '../appium.js';
+import { buildLocalCapabilities, makeHandle, openLocalSession, resolveAndroidApp, } from '../local-session.js';
+import { validateBuildPath } from '../../utils.js';
+import { logger } from '../../logger.js';
+export class EmulatorProvider {
+    use;
+    sessionId;
+    constructor(use, appBundleId) {
+        this.use = use;
+        if (use.device.provider !== 'emulator') {
+            throw new Error(`emulator provider received device.provider='${use.device.provider}'.`);
+        }
+        if (appBundleId) {
+            logger.log(`Bundle id (${appBundleId}) ignored for emulator provider — resolved from the build at runtime.`);
+        }
+    }
+    async globalSetup() {
+        const android = this.use.platform === Platform.ANDROID;
+        validateBuildPath(this.use.buildPath, android ? '.apk' : '.app');
+        if (android) {
+            if (!process.env.ANDROID_HOME) {
+                throw new Error('ANDROID_HOME is not set. Required to locate the Android SDK.');
+            }
+            if (!process.env.JAVA_HOME) {
+                throw new Error('JAVA_HOME is not set.');
+            }
+            await isEmulatorInstalled(this.use.platform);
+        }
+    }
+    async getDevice() {
+        const device = this.use.device;
+        const { appPackage, appActivity } = await resolveAndroidApp(this.use);
+        const capabilities = buildLocalCapabilities(this.use, device, {
+            appPackage,
+            appActivity,
+            udid: device.udid,
+            extraCaps: {
+                'appium:platformVersion': device.osVersion,
+                'appium:wdaLaunchTimeout': 300_000,
+            },
+        });
+        const driver = await openLocalSession(this.use, capabilities);
+        this.sessionId = driver.sessionId;
+        return makeHandle(this.use, driver, undefined);
+    }
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,10 @@
+import { type TaqwrightUseOptions, type DeviceProvider } from '../types/index.js';
+export { EmulatorProvider } from './emulator/index.js';
+export { LocalDeviceProvider } from './local/index.js';
+export { BrowserStackDeviceProvider } from './browserstack/index.js';
+export { LambdaTestDeviceProvider } from './lambdatest/index.js';
+export type { DeviceHandle } from '../types/index.js';
+type ProviderConstructor = new (use: TaqwrightUseOptions, appBundleId: string | undefined, projectName?: string) => DeviceProvider;
+export declare function isCloudProvider(provider: string | undefined): boolean;
+export declare function getProviderClass(provider: string): ProviderConstructor;
+export declare function createDeviceProvider(use: TaqwrightUseOptions, projectName?: string): DeviceProvider;

package/dist/providers/index.js

@@ -0,0 +1,33 @@
+import { EmulatorProvider } from './emulator/index.js';
+import { LocalDeviceProvider } from './local/index.js';
+import { BrowserStackDeviceProvider } from './browserstack/index.js';
+import { LambdaTestDeviceProvider } from './lambdatest/index.js';
+export { EmulatorProvider } from './emulator/index.js';
+export { LocalDeviceProvider } from './local/index.js';
+export { BrowserStackDeviceProvider } from './browserstack/index.js';
+export { LambdaTestDeviceProvider } from './lambdatest/index.js';
+const REGISTRY = {
+    emulator: EmulatorProvider,
+    'local-device': LocalDeviceProvider,
+    browserstack: BrowserStackDeviceProvider,
+    lambdatest: LambdaTestDeviceProvider,
+};
+const CLOUD_PROVIDERS = new Set(['browserstack', 'lambdatest']);
+export function isCloudProvider(provider) {
+    return provider !== undefined && CLOUD_PROVIDERS.has(provider);
+}
+export function getProviderClass(provider) {
+    const ctor = REGISTRY[provider];
+    if (!ctor) {
+        throw new Error(`No device provider registered for "${provider}".`);
+    }
+    return ctor;
+}
+export function createDeviceProvider(use, projectName) {
+    const provider = use.device?.provider;
+    if (!provider) {
+        throw new Error('device.provider is not set — add it to your taqwright config.');
+    }
+    const ProviderClass = getProviderClass(provider);
+    return new ProviderClass(use, use.appBundleId, projectName);
+}