@taqwright/taqwright 0.0.24

package/dist/tracer/proxy.js

@@ -0,0 +1,60 @@
+import { Locator } from '../locator/index.js';
+const CHAIN_METHODS = new Set(['filter', 'first', 'last', 'nth', 'locator', 'and', 'or']);
+const MOBILE_PASS_THROUGH = new Set(['raw', 'getPlatform']);
+export function wrapForTracing(mobile, tracer) {
+    return new Proxy(mobile, {
+        get(target, prop, receiver) {
+            const orig = Reflect.get(target, prop, receiver);
+            const name = String(prop);
+            if (MOBILE_PASS_THROUGH.has(name) || typeof orig !== 'function') {
+                return orig;
+            }
+            const fn = orig;
+            return (...args) => {
+                const result = fn.apply(target, args);
+                if (result instanceof Locator) {
+                    return wrapLocator(result, tracer);
+                }
+                if (isPromise(result)) {
+                    return tracer.record(`mobile.${name}`, args, () => result);
+                }
+                return result;
+            };
+        },
+    });
+}
+function wrapLocator(loc, tracer) {
+    return new Proxy(loc, {
+        get(target, prop, receiver) {
+            const orig = Reflect.get(target, prop, receiver);
+            if (typeof orig !== 'function')
+                return orig;
+            const name = String(prop);
+            const fn = orig;
+            if (CHAIN_METHODS.has(name)) {
+                return (...args) => {
+                    const r = fn.apply(target, args);
+                    return r instanceof Locator ? wrapLocator(r, tracer) : r;
+                };
+            }
+            return (...args) => {
+                const r = fn.apply(target, args);
+                if (isPromise(r)) {
+                    return tracer
+                        .record(`locator.${name}`, args, () => r)
+                        .then((resolved) => wrapResolved(resolved, tracer));
+                }
+                return r;
+            };
+        },
+    });
+}
+function wrapResolved(value, tracer) {
+    if (Array.isArray(value) && value.every((v) => v instanceof Locator)) {
+        return value.map((l) => wrapLocator(l, tracer));
+    }
+    return value;
+}
+function isPromise(v) {
+    return (v !== null && typeof v === 'object' && typeof v.then === 'function');
+}

package/dist/types/index.d.ts

@@ -0,0 +1,189 @@
+import type { Client as WebDriverClient } from 'webdriver';
+export declare enum Platform {
+    ANDROID = "android",
+    IOS = "ios"
+}
+export type ScrollDirection = 'up' | 'down' | 'left' | 'right';
+export type SwipeDirection = 'up' | 'down' | 'left' | 'right';
+export type HardwareButton = 'HOME' | 'BACK' | 'POWER' | 'VOLUME_UP' | 'VOLUME_DOWN' | 'ENTER';
+export type DeviceOrientation = 'portrait' | 'landscape';
+export interface DevicePoolEntry {
+    udid: string;
+    name?: string;
+    osVersion?: string;
+}
+export interface EmulatorDeviceConfig {
+    provider: 'emulator';
+    name?: string | RegExp;
+    osVersion?: string;
+    udid?: string;
+    orientation?: DeviceOrientation;
+    pool?: DevicePoolEntry[];
+    autoDiscover?: boolean;
+}
+export interface LocalDeviceConfig {
+    provider: 'local-device';
+    name?: string | RegExp;
+    udid?: string;
+    osVersion?: string;
+    orientation?: DeviceOrientation;
+    pool?: DevicePoolEntry[];
+    autoDiscover?: boolean;
+}
+interface CloudDeviceConfigBase {
+    name: string;
+    osVersion: string;
+    orientation?: DeviceOrientation;
+    enableCameraImageInjection?: boolean;
+}
+export interface BrowserStackDeviceConfig extends CloudDeviceConfigBase {
+    provider: 'browserstack';
+}
+export interface LambdaTestDeviceConfig extends CloudDeviceConfigBase {
+    provider: 'lambdatest';
+}
+export type DeviceConfig = EmulatorDeviceConfig | LocalDeviceConfig | BrowserStackDeviceConfig | LambdaTestDeviceConfig;
+export interface DeviceHandle {
+    driver: WebDriverClient;
+    bundleId?: string;
+    options: {
+        expectTimeout: number;
+    };
+    provider: string;
+}
+export interface DeviceProvider {
+    globalSetup?(): Promise<void>;
+    getDevice(): Promise<DeviceHandle>;
+    syncTestDetails?(details: {
+        status?: string;
+        reason?: string;
+        name?: string;
+    }): Promise<void>;
+}
+export interface AppiumServerConfig {
+    host?: string;
+    port?: number;
+    path?: string;
+    newCommandTimeout?: number;
+    connectionTimeout?: number;
+    logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'silent';
+    autoStart?: boolean;
+    autoStartDevice?: boolean;
+}
+interface TaqwrightUseOptionsBase {
+    platform: Platform;
+    device: DeviceConfig;
+    buildPath?: string;
+    appBundleId?: string;
+    expectTimeout?: number;
+    appium?: AppiumServerConfig;
+    capabilities?: Record<string, unknown>;
+    trace?: TraceMode;
+    video?: VideoMode;
+    network?: NetworkMode;
+}
+export type TraceMode = 'off' | 'on' | 'on-failure' | 'retain-on-failure';
+export type VideoMode = 'off' | 'on' | 'on-failure' | 'retain-on-failure';
+export type NetworkMode = 'off' | 'on' | 'on-failure' | 'retain-on-failure';
+export type TaqwrightUseOptions = TaqwrightUseOptionsBase & ({
+    resetBetweenTests?: false;
+} | {
+    resetBetweenTests: true;
+    buildPath: string;
+    appBundleId: string;
+});
+interface TestRunnerOptions {
+    testDir?: string;
+    testMatch?: string | RegExp | Array<string | RegExp>;
+    testIgnore?: string | RegExp | Array<string | RegExp>;
+    timeout?: number;
+    retries?: number;
+    outputDir?: string;
+}
+export interface TaqwrightProjectConfig extends TestRunnerOptions {
+    name: string;
+    use: TaqwrightUseOptions;
+    grep?: RegExp | Array<RegExp>;
+    grepInvert?: RegExp | Array<RegExp>;
+    dependencies?: string[];
+    workers?: number;
+}
+export interface TaqwrightConfig extends TestRunnerOptions {
+    projects: TaqwrightProjectConfig[];
+    expectTimeout?: number;
+    workers?: number;
+    fullyParallel?: boolean;
+    forbidOnly?: boolean;
+    reporter?: 'list' | 'html' | 'json' | 'junit' | 'line' | 'dot' | Array<[string] | [string, unknown]>;
+    globalSetup?: string | string[];
+    globalTeardown?: string | string[];
+}
+export interface BoundingBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface ScreenSize {
+    width: number;
+    height: number;
+}
+export interface GesturePointer {
+    x: number;
+    y: number;
+    time: number;
+}
+export interface GestureOptions {
+    pointers: GesturePointer[][];
+}
+export interface LocatorStrategy {
+    using: 'accessibility id' | 'id' | 'class name' | 'xpath' | 'name' | 'css selector' | '-android uiautomator' | '-ios predicate string' | '-ios class chain';
+    value: string;
+    textFilter?: string | RegExp;
+}
+export declare const W3C_ELEMENT_KEY: "element-6066-11e4-a52e-4f735466cecf";
+export type ElementRef = Record<typeof W3C_ELEMENT_KEY, string>;
+export type SerializedText = string | {
+    regex: string;
+    flags: string;
+};
+export type LocatorDescriptor = {
+    kind: 'leaf';
+    using: LocatorStrategy['using'];
+    value: string;
+    textFilter?: SerializedText;
+} | {
+    kind: 'first';
+    on: LocatorDescriptor;
+} | {
+    kind: 'last';
+    on: LocatorDescriptor;
+} | {
+    kind: 'nth';
+    on: LocatorDescriptor;
+    n: number;
+} | {
+    kind: 'filter';
+    on: LocatorDescriptor;
+    filter: SerializedFilter;
+} | {
+    kind: 'child';
+    parent: LocatorDescriptor;
+    child: LocatorDescriptor;
+} | {
+    kind: 'and';
+    left: LocatorDescriptor;
+    right: LocatorDescriptor;
+} | {
+    kind: 'or';
+    left: LocatorDescriptor;
+    right: LocatorDescriptor;
+};
+export interface SerializedFilter {
+    has?: LocatorDescriptor;
+    hasNot?: LocatorDescriptor;
+    hasText?: SerializedText;
+    hasNotText?: SerializedText;
+    visible?: boolean;
+}
+export {};

package/dist/types/index.js

@@ -0,0 +1,6 @@
+export var Platform;
+(function (Platform) {
+    Platform["ANDROID"] = "android";
+    Platform["IOS"] = "ios";
+})(Platform || (Platform = {}));
+export const W3C_ELEMENT_KEY = 'element-6066-11e4-a52e-4f735466cecf';

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function validateBuildPath(buildPath: string | undefined, expectedExt: string): void;
+export declare function getLatestBuildToolsVersions(versions: string[]): string | undefined;

package/dist/utils.js

@@ -0,0 +1,37 @@
+import { existsSync } from 'node:fs';
+import { extname } from 'node:path';
+export function validateBuildPath(buildPath, expectedExt) {
+    if (!buildPath) {
+        throw new Error('Build path not found. Please set `buildPath` in your taqwright config.');
+    }
+    const isUrl = buildPath.startsWith('http') || buildPath.startsWith('bs://') || buildPath.startsWith('lt://');
+    if (!isUrl) {
+        if (!existsSync(buildPath)) {
+            throw new Error(`Build file not found: ${buildPath}`);
+        }
+        const ext = extname(buildPath).toLowerCase();
+        if (ext !== expectedExt.toLowerCase()) {
+            throw new Error(`Build path "${buildPath}" must end in ${expectedExt}, got ${ext || '(no extension)'}`);
+        }
+    }
+}
+export function getLatestBuildToolsVersions(versions) {
+    if (versions.length === 0)
+        return undefined;
+    const cmp = (a, b) => {
+        const pa = a.split('-')[0].split('.').map(Number);
+        const pb = b.split('-')[0].split('.').map(Number);
+        for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+            const av = pa[i] ?? 0;
+            const bv = pb[i] ?? 0;
+            if (av !== bv)
+                return av - bv;
+        }
+        const aRc = a.includes('-rc');
+        const bRc = b.includes('-rc');
+        if (aRc !== bRc)
+            return aRc ? -1 : 1;
+        return 0;
+    };
+    return [...versions].sort(cmp).pop();
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@taqwright/taqwright",
+  "version": "0.0.24",
+  "description": "E2E mobile testing on the Playwright runner",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/taqelah/taqwright.git"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "taqwright": "dist/bin/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=24.0.0 <26.0.0"
+  },
+  "overrides": {
+    "@wdio/config": {
+      "glob": "^13"
+    }
+  },
+  "scripts": {
+    "build": "tsc --build && node scripts/copy-assets.mjs",
+    "clean": "tsc --build --clean",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "npm run build && node --test test/*.test.js",
+    "test:watch": "node --test --watch test/*.test.js",
+    "test:coverage": "npm run build && node --test --experimental-test-coverage test/*.test.js",
+    "prepare": "npm run build",
+    "prepublishOnly": "npm run build",
+    "version": "node scripts/sync-readme-version.mjs && git add README.md"
+  },
+  "keywords": [
+    "e2e",
+    "automation",
+    "ios",
+    "android",
+    "mobile",
+    "testing",
+    "playwright",
+    "appium"
+  ],
+  "dependencies": {
+    "@playwright/test": "^1.60.0",
+    "commander": "^15.0.0",
+    "node-forge": "^1.3.1",
+    "webdriver": "^9.27.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.9.2",
+    "@types/node-forge": "^1.3.11",
+    "eslint": "^10.4.1",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.6.0",
+    "prettier": "^3.8.4",
+    "typescript": "^5.4.0",
+    "typescript-eslint": "^8.61.0"
+  }
+}