@taqwright/taqwright 0.0.24

package/dist/inspector/recorder.js

@@ -0,0 +1,162 @@
+export class Recorder {
+    actions = [];
+    push(a) {
+        this.actions.push(a);
+    }
+    list() {
+        return [...this.actions];
+    }
+    clear() {
+        this.actions.length = 0;
+    }
+    toSpec(testName = 'recorded test') {
+        const lines = [
+            `import { test, expect } from '@taqwright/taqwright';`,
+            ``,
+            `test(${jsString(testName)}, async ({ mobile }) => {`,
+        ];
+        if (this.actions.length === 0) {
+            lines.push(`  // (no actions recorded yet — interact with the device in the inspector)`);
+        }
+        else {
+            for (const a of this.actions) {
+                lines.push('  ' + renderAction(a));
+            }
+        }
+        lines.push(`});`, ``);
+        return lines.join('\n');
+    }
+}
+function renderAction(a) {
+    switch (a.kind) {
+        case 'tap':
+            return `await mobile.click({ x: ${a.x}, y: ${a.y} });`;
+        case 'swipe':
+            return (`await mobile.raw.performActions([{ type: 'pointer', id: 'finger1', ` +
+                `parameters: { pointerType: 'touch' }, actions: [` +
+                `{ type: 'pointerMove', duration: 0, x: ${a.x1}, y: ${a.y1} }, ` +
+                `{ type: 'pointerDown', button: 0 }, ` +
+                `{ type: 'pointerMove', duration: ${a.durationMs}, x: ${a.x2}, y: ${a.y2} }, ` +
+                `{ type: 'pointerUp', button: 0 }] }]);`);
+        case 'sendKeys':
+            return `await mobile.raw.execute('mobile: type', [{ text: ${jsString(a.text)} }]);`;
+        case 'switchContext':
+            return /^NATIVE_APP$/i.test(a.context)
+                ? `await mobile.switchToNative();`
+                : `await mobile.switchToWebView();`;
+        case 'screenScroll': {
+            const fn = a.direction === 'left' || a.direction === 'right' ? 'swipe' : 'scroll';
+            const fromParts = [];
+            if (a.fromX !== undefined)
+                fromParts.push(`x: ${trimNum(a.fromX)}`);
+            if (a.fromY !== undefined)
+                fromParts.push(`y: ${trimNum(a.fromY)}`);
+            const toParts = [];
+            if (a.toX !== undefined)
+                toParts.push(`x: ${trimNum(a.toX)}`);
+            if (a.toY !== undefined)
+                toParts.push(`y: ${trimNum(a.toY)}`);
+            if (fromParts.length === 0 && toParts.length === 0) {
+                return `await mobile.${fn}(${jsString(a.direction)});`;
+            }
+            const optsParts = [];
+            if (fromParts.length)
+                optsParts.push(`from: { ${fromParts.join(', ')} }`);
+            if (toParts.length)
+                optsParts.push(`to: { ${toParts.join(', ')} }`);
+            return `await mobile.${fn}(${jsString(a.direction)}, { ${optsParts.join(', ')} });`;
+        }
+        case 'locatorClick':
+            return `await ${a.code}.click();`;
+        case 'locatorDoubleTap':
+            return `await ${a.code}.doubleTap();`;
+        case 'locatorLongPress':
+            return `await ${a.code}.longPress();`;
+        case 'locatorFill':
+            return `await ${a.code}.fill(${jsString(a.text)});`;
+        case 'locatorClear':
+            return `await ${a.code}.clear();`;
+        case 'assertVisible':
+            return `await expect(${a.code}).toBeVisible();`;
+        case 'assertHidden':
+            return `await expect(${a.code}).toBeHidden();`;
+        case 'assertEnabled':
+            return `await expect(${a.code}).toBeEnabled();`;
+        case 'assertDisabled':
+            return `await expect(${a.code}).toBeDisabled();`;
+        case 'assertText':
+            return a.mode === 'contains'
+                ? `await expect(${a.code}).toContainText(${jsString(a.expected)});`
+                : `await expect(${a.code}).toHaveText(${jsString(a.expected)});`;
+        case 'assertValue':
+            return `await expect(${a.code}).toHaveValue(${jsString(a.expected)});`;
+        case 'locatorSwipe': {
+            const m = 'swipe' + a.direction[0].toUpperCase() + a.direction.slice(1);
+            return `await ${a.code}.${m}();`;
+        }
+        case 'locatorScrollIntoView':
+            return `await ${a.code}.scrollIntoView();`;
+        case 'locatorPinch':
+            return `await ${a.code}.pinch${a.direction === 'in' ? 'In' : 'Out'}();`;
+        case 'locatorDragTo':
+            return `await ${a.code}.dragTo(${a.targetCode});`;
+        case 'locatorCheck':
+            return `await ${a.code}.check();`;
+        case 'locatorUncheck':
+            return `await ${a.code}.uncheck();`;
+        case 'locatorFocus':
+            return `await ${a.code}.focus();`;
+        case 'locatorBlur':
+            return `await ${a.code}.blur();`;
+        case 'assertChecked':
+            return `await expect(${a.code}).toBeChecked();`;
+        case 'assertUnchecked':
+            return `await expect(${a.code}).not.toBeChecked();`;
+        case 'locatorPress':
+            return `await ${a.code}.press(${jsString(a.key)});`;
+        case 'locatorPressSequentially':
+            return a.delay
+                ? `await ${a.code}.pressSequentially(${jsString(a.text)}, { delay: ${a.delay} });`
+                : `await ${a.code}.pressSequentially(${jsString(a.text)});`;
+        case 'locatorSelectOption':
+            return `await ${a.code}.selectOption(${formatSelectOptionInput(a.value)});`;
+        case 'assertEditable':
+            return `await expect(${a.code}).toBeEditable();`;
+        case 'assertReadonly':
+            return `await expect(${a.code}).not.toBeEditable();`;
+        case 'assertFocused':
+            return `await expect(${a.code}).toBeFocused();`;
+        case 'assertAttached':
+            return `await expect(${a.code}).toBeAttached();`;
+        case 'assertEmpty':
+            return `await expect(${a.code}).toBeEmpty();`;
+        case 'assertInViewport':
+            return `await expect(${a.code}).toBeInViewport();`;
+        case 'assertCount':
+            return `await expect(${a.code}).toHaveCount(${a.expected});`;
+        case 'assertAttribute':
+            return `await expect(${a.code}).toHaveAttribute(${jsString(a.name)}, ${jsString(a.expected)});`;
+        case 'comment':
+            return `// ${a.text}`;
+    }
+}
+function formatSelectOptionInput(v) {
+    if (typeof v === 'string')
+        return jsString(v);
+    const parts = [];
+    if (v.label !== undefined)
+        parts.push(`label: ${jsString(v.label)}`);
+    if (v.index !== undefined)
+        parts.push(`index: ${v.index}`);
+    if (v.date !== undefined)
+        parts.push(`date: ${jsString(v.date)}`);
+    if (v.time !== undefined)
+        parts.push(`time: ${jsString(v.time)}`);
+    return `{ ${parts.join(', ')} }`;
+}
+function jsString(s) {
+    return JSON.stringify(s);
+}
+function trimNum(n) {
+    return Number.isInteger(n) ? n.toFixed(0) : Number(n.toFixed(3)).toString();
+}

package/dist/inspector/server.d.ts

@@ -0,0 +1,39 @@
+import { type IncomingMessage } from 'node:http';
+import type { Client as WebDriverClient } from 'webdriver';
+import { Platform, type LocatorDescriptor } from '../types/index.js';
+import { InspectorSession, type InspectorDefaults } from './session.js';
+export interface InspectorServerOptions {
+    defaults: InspectorDefaults;
+    port: number;
+    host: string;
+    attach?: {
+        driver: WebDriverClient;
+        platform: Platform;
+        capabilities?: Record<string, unknown>;
+    };
+}
+export interface InspectorServerHandle {
+    url: string;
+    port: number;
+    session: InspectorSession;
+    close: () => Promise<void>;
+}
+export declare function startInspectorServer(opts: InspectorServerOptions): Promise<InspectorServerHandle>;
+type LocatorTarget = {
+    code: string;
+    descriptor?: LocatorDescriptor;
+    using?: string;
+    value?: string;
+};
+export declare function resolveLocatorDescriptor(body: LocatorTarget): LocatorDescriptor;
+export declare function withTimeout<T>(p: Promise<T>, ms: number, label: string): Promise<T>;
+export declare function readJson<T>(req: IncomingMessage): Promise<T>;
+export interface CloudDevice {
+    provider: 'browserstack' | 'lambdatest';
+    platform: 'android' | 'ios';
+    deviceName: string;
+    osVersion: string;
+    realDevice: boolean;
+}
+export declare function parseLambdatestDevices(raw: unknown): CloudDevice[];
+export {};