@testspectra/cli 1.0.70 → 1.1.0-rc.0

package/dist/reporter/__tests__/semantic-formatter.test.js

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest';
+import { formatAction, formatAssertion } from '../semantic-formatter.js';
+describe('semantic-formatter', () => {
+    describe('formatAction', () => {
+        it('formats click', () => expect(formatAction('click', 'LoginPage.submitButton')).toBe('Click on element "LoginPage.submitButton"'));
+        it('formats doubleClick', () => expect(formatAction('doubleClick', 'targetBtn')).toBe('Double-click on element "targetBtn"'));
+        it('formats rightClick', () => expect(formatAction('rightClick', 'targetBtn')).toBe('Right-click on element "targetBtn"'));
+        it('formats type', () => expect(formatAction('type', 'LoginPage.emailInput', { text: 'admin@testspectra.dev' })).toBe('Type "admin@testspectra.dev" into element "LoginPage.emailInput"'));
+        it('formats clear', () => expect(formatAction('clear', 'input')).toBe('Clear text in element "input"'));
+        it('formats select', () => expect(formatAction('select', 'dropdown', { option: 'Option A' })).toBe('Select option "Option A" in element "dropdown"'));
+        it('formats hover', () => expect(formatAction('hover', 'menu')).toBe('Hover over element "menu"'));
+        it('formats dragDrop', () => expect(formatAction('dragDrop', 'source', { dest: 'dest' })).toBe('Drag element "source" and drop onto element "dest"'));
+        it('formats scrollIntoView', () => expect(formatAction('scrollIntoView', 'footer')).toBe('Scroll element "footer" into view'));
+        it('formats longPress', () => expect(formatAction('longPress', 'btn', { durationMs: 1500 })).toBe('Long-press on element "btn" for 1500ms'));
+        it('formats waitForElement', () => expect(formatAction('waitForElement', 'modal')).toBe('Wait for element "modal" to be displayed'));
+        it('formats navigate', () => expect(formatAction('navigate', undefined, { url: '/login' })).toBe('Navigate to "/login"'));
+        it('formats back', () => expect(formatAction('back')).toBe('Navigate back in browser'));
+        it('formats forward', () => expect(formatAction('forward')).toBe('Navigate forward in browser'));
+        it('formats refresh', () => expect(formatAction('refresh')).toBe('Refresh current page'));
+        it('formats setViewport', () => expect(formatAction('setViewport', undefined, { width: 1920, height: 1080 })).toBe('Set viewport to 1920x1080'));
+        it('formats wait', () => expect(formatAction('wait', undefined, { ms: 1000 })).toBe('Wait for 1000ms'));
+        it('formats pressKey', () => expect(formatAction('pressKey', undefined, { key: 'Enter' })).toBe('Press keyboard key "Enter"'));
+        it('formats scroll', () => expect(formatAction('scroll', undefined, { direction: 'down', pixels: 400 })).toBe('Scroll down by 400px'));
+        it('formats swipe', () => expect(formatAction('swipe', undefined, { direction: 'left', distance: 300 })).toBe('Swipe left by 300px'));
+        it('formats intercept', () => expect(formatAction('intercept', undefined, { method: 'GET', url: '/api/data' })).toBe('Intercept GET "/api/data" mock rule registered'));
+        it('formats clearCookies', () => expect(formatAction('clearCookies')).toBe('Clear all browser cookies'));
+        it('formats clearLocalStorage', () => expect(formatAction('clearLocalStorage')).toBe('Clear browser localStorage'));
+    });
+    describe('formatAssertion', () => {
+        // 38 assertions
+        it('formats be.visible', () => expect(formatAssertion('be.visible', 'DashboardPage.header')).toBe('Expect element "DashboardPage.header" to be visible'));
+        it('formats not.be.visible', () => expect(formatAssertion('not.be.visible', 'DashboardPage.header')).toBe('Expect element "DashboardPage.header" not to be visible'));
+        it('formats exist', () => expect(formatAssertion('exist', 'DashboardPage.header')).toBe('Expect element "DashboardPage.header" to exist in DOM'));
+        it('formats not.exist', () => expect(formatAssertion('not.exist', 'DashboardPage.header')).toBe('Expect element "DashboardPage.header" not to exist in DOM'));
+        it('formats be.clickable', () => expect(formatAssertion('be.clickable', 'btn')).toBe('Expect element "btn" to be clickable'));
+        it('formats not.be.clickable', () => expect(formatAssertion('not.be.clickable', 'btn')).toBe('Expect element "btn" not to be clickable'));
+        it('formats be.enabled', () => expect(formatAssertion('be.enabled', 'btn')).toBe('Expect element "btn" to be enabled'));
+        it('formats be.disabled', () => expect(formatAssertion('be.disabled', 'btn')).toBe('Expect element "btn" to be disabled'));
+        it('formats be.checked', () => expect(formatAssertion('be.checked', 'checkbox')).toBe('Expect element "checkbox" to be checked'));
+        it('formats not.be.checked', () => expect(formatAssertion('not.be.checked', 'checkbox')).toBe('Expect element "checkbox" not to be checked'));
+        it('formats be.selected', () => expect(formatAssertion('be.selected', 'radio')).toBe('Expect element "radio" to be selected'));
+        it('formats not.be.selected', () => expect(formatAssertion('not.be.selected', 'radio')).toBe('Expect element "radio" not to be selected'));
+        it('formats be.focused', () => expect(formatAssertion('be.focused', 'input')).toBe('Expect element "input" to be focused'));
+        it('formats not.be.focused', () => expect(formatAssertion('not.be.focused', 'input')).toBe('Expect element "input" not to be focused'));
+        it('formats have.text', () => expect(formatAssertion('have.text', 'title', { expected: 'Hello' })).toBe('Expect element "title" to have text "Hello"'));
+        it('formats not.have.text', () => expect(formatAssertion('not.have.text', 'title', { expected: 'Hello' })).toBe('Expect element "title" not to have text "Hello"'));
+        it('formats contain.text', () => expect(formatAssertion('contain.text', 'title', { expected: 'Hello' })).toBe('Expect element "title" to contain text "Hello"'));
+        it('formats not.contain.text', () => expect(formatAssertion('not.contain.text', 'title', { expected: 'Hello' })).toBe('Expect element "title" not to contain text "Hello"'));
+        it('formats have.value', () => expect(formatAssertion('have.value', 'input', { expected: 'admin' })).toBe('Expect element "input" to have value "admin"'));
+        it('formats not.have.value', () => expect(formatAssertion('not.have.value', 'input', { expected: 'admin' })).toBe('Expect element "input" not to have value "admin"'));
+        it('formats contain.value', () => expect(formatAssertion('contain.value', 'input', { expected: 'min' })).toBe('Expect element "input" to contain value "min"'));
+        it('formats not.contain.value', () => expect(formatAssertion('not.contain.value', 'input', { expected: 'min' })).toBe('Expect element "input" not to contain value "min"'));
+        it('formats have.attr', () => expect(formatAssertion('have.attr', 'img', { name: 'alt', value: 'logo' })).toBe('Expect element "img" to have attribute "alt" = "logo"'));
+        it('formats not.have.attr', () => expect(formatAssertion('not.have.attr', 'img', { name: 'alt' })).toBe('Expect element "img" not to have attribute "alt"'));
+        it('formats have.class', () => expect(formatAssertion('have.class', 'div', { expected: 'active' })).toBe('Expect element "div" to have class "active"'));
+        it('formats not.have.class', () => expect(formatAssertion('not.have.class', 'div', { expected: 'active' })).toBe('Expect element "div" not to have class "active"'));
+        it('formats have.css', () => expect(formatAssertion('have.css', 'div', { name: 'color', value: 'red' })).toBe('Expect element "div" to have CSS "color" = "red"'));
+        it('formats not.have.css', () => expect(formatAssertion('not.have.css', 'div', { name: 'color', value: 'red' })).toBe('Expect element "div" not to have CSS "color" = "red"'));
+        it('formats have.length', () => expect(formatAssertion('have.length', 'DashboardPage.statCards', { expected: 4 })).toBe('Expect collection "DashboardPage.statCards" count to equal 4'));
+        it('formats not.have.length', () => expect(formatAssertion('not.have.length', 'cards', { expected: 4 })).toBe('Expect collection "cards" count not to equal 4'));
+        it('formats have.length.greaterThan', () => expect(formatAssertion('have.length.greaterThan', 'cards', { expected: 2 })).toBe('Expect collection "cards" count to be greater than 2'));
+        it('formats have.length.lessThan', () => expect(formatAssertion('have.length.lessThan', 'cards', { expected: 10 })).toBe('Expect collection "cards" count to be less than 10'));
+        it('formats be.empty', () => expect(formatAssertion('be.empty', 'cards')).toBe('Expect collection "cards" to be empty'));
+        it('formats not.be.empty', () => expect(formatAssertion('not.be.empty', 'cards')).toBe('Expect collection "cards" not to be empty'));
+        it('formats shouldHaveUrl', () => expect(formatAssertion('shouldHaveUrl', undefined, { expected: '/home' })).toBe('Expect browser URL to be "/home"'));
+        it('formats shouldContainUrl', () => expect(formatAssertion('shouldContainUrl', undefined, { expected: '/home' })).toBe('Expect browser URL to contain "/home"'));
+        it('formats shouldHaveTitle', () => expect(formatAssertion('shouldHaveTitle', undefined, { expected: 'Home' })).toBe('Expect browser title to be "Home"'));
+        it('formats shouldContainTitle', () => expect(formatAssertion('shouldContainTitle', undefined, { expected: 'Home' })).toBe('Expect browser title to contain "Home"'));
+        it('formats shouldBeLoaded', () => expect(formatAssertion('shouldBeLoaded', undefined)).toBe('Expect page to be fully loaded'));
+        it('formats shouldBePageLoaded', () => expect(formatAssertion('shouldBePageLoaded', undefined)).toBe('Expect page to be fully loaded'));
+        it('formats shouldHaveNoConsoleErrors', () => expect(formatAssertion('shouldHaveNoConsoleErrors', undefined)).toBe('Expect browser console to have no errors'));
+    });
+});

package/dist/reporter/semantic-formatter.d.ts

@@ -0,0 +1,6 @@
+import { ActionKey, AssertionKey } from './types.js';
+/**
+ * Transforms raw matcher assertions and element commands into grammatically correct English sentences.
+ */
+export declare function formatAction(actionKey: ActionKey | string, target?: any, args?: Record<string, any>): string;
+export declare function formatAssertion(assertionKey: AssertionKey | string, target?: any, args?: Record<string, any>): string;

package/dist/reporter/semantic-formatter.js

@@ -0,0 +1,191 @@
+function extractTargetString(target) {
+    if (!target)
+        return '';
+    if (typeof target === 'string')
+        return target;
+    if (typeof target === 'object') {
+        if (typeof target.selector === 'string')
+            return target.selector;
+        if (typeof target.name === 'string')
+            return target.name;
+        if (typeof target.target === 'string')
+            return target.target;
+    }
+    return String(target);
+}
+function formatElementTarget(target) {
+    const sel = extractTargetString(target);
+    if (!sel)
+        return 'element {target}';
+    if (sel.startsWith('element "') || sel.startsWith('collection "')) {
+        return sel;
+    }
+    return `element "${sel}"`;
+}
+function formatCollectionTarget(target) {
+    const sel = extractTargetString(target);
+    if (!sel)
+        return 'collection "{selector}"';
+    if (sel.startsWith('collection "')) {
+        return sel;
+    }
+    return `collection "${sel}"`;
+}
+/**
+ * Transforms raw matcher assertions and element commands into grammatically correct English sentences.
+ */
+export function formatAction(actionKey, target, args = {}) {
+    const el = formatElementTarget(target);
+    switch (actionKey) {
+        case 'click':
+            return `Click on ${el}`;
+        case 'doubleClick':
+            return `Double-click on ${el}`;
+        case 'rightClick':
+            return `Right-click on ${el}`;
+        case 'type':
+            return `Type "${args.text ?? args.value ?? '{text}'}" into ${el}`;
+        case 'clear':
+            return `Clear text in ${el}`;
+        case 'select':
+        case 'selectOption':
+            return `Select option "${args.option ?? args.value ?? args.text ?? '{option}'}" in ${el}`;
+        case 'hover':
+            return `Hover over ${el}`;
+        case 'dragDrop':
+            const dest = args.dest || args.destination ? formatElementTarget(args.dest || args.destination) : 'element {dest}';
+            return `Drag ${el} and drop onto ${dest}`;
+        case 'scrollIntoView':
+            return `Scroll ${el} into view`;
+        case 'longPress':
+            return `Long-press on ${el} for ${args.durationMs ?? args.ms ?? args.duration ?? '{durationMs}'}ms`;
+        case 'waitForElement':
+            return `Wait for ${el} to be displayed`;
+        case 'navigate':
+            return `Navigate to "${args.url ?? '{url}'}"`;
+        case 'back':
+            return `Navigate back in browser`;
+        case 'forward':
+            return `Navigate forward in browser`;
+        case 'refresh':
+            return `Refresh current page`;
+        case 'setViewport':
+            return `Set viewport to ${args.width ?? '{width}'}x${args.height ?? '{height}'}`;
+        case 'wait':
+            return `Wait for ${args.ms ?? args.durationMs ?? '{ms}'}ms`;
+        case 'pressKey':
+            return `Press keyboard key "${args.key ?? args.value ?? '{key}'}"`;
+        case 'scroll':
+            return `Scroll ${args.direction ?? '{direction}'} by ${args.pixels ?? '{pixels}'}px`;
+        case 'swipe':
+            return `Swipe ${args.direction ?? '{direction}'} by ${args.distance ?? '{distance}'}px`;
+        case 'intercept':
+            return `Intercept ${args.method ?? '{method}'} "${args.url ?? '{url}'}" mock rule registered`;
+        case 'clearCookies':
+            return `Clear all browser cookies`;
+        case 'clearLocalStorage':
+            return `Clear browser localStorage`;
+        default:
+            return `Perform ${actionKey} on ${el}`;
+    }
+}
+export function formatAssertion(assertionKey, target, args = {}) {
+    const el = formatElementTarget(target);
+    const col = formatCollectionTarget(target);
+    switch (assertionKey) {
+        case 'be.visible':
+            return `Expect ${el} to be visible`;
+        case 'not.be.visible':
+            return `Expect ${el} not to be visible`;
+        case 'exist':
+            return `Expect ${el} to exist in DOM`;
+        case 'not.exist':
+            return `Expect ${el} not to exist in DOM`;
+        case 'be.clickable':
+            return `Expect ${el} to be clickable`;
+        case 'not.be.clickable':
+            return `Expect ${el} not to be clickable`;
+        case 'be.enabled':
+            return `Expect ${el} to be enabled`;
+        case 'be.disabled':
+            return `Expect ${el} to be disabled`;
+        case 'be.checked':
+            return `Expect ${el} to be checked`;
+        case 'not.be.checked':
+            return `Expect ${el} not to be checked`;
+        case 'be.selected':
+            return `Expect ${el} to be selected`;
+        case 'not.be.selected':
+            return `Expect ${el} not to be selected`;
+        case 'be.focused':
+            return `Expect ${el} to be focused`;
+        case 'not.be.focused':
+            return `Expect ${el} not to be focused`;
+        case 'have.text':
+            return `Expect ${el} to have text "${args.expected ?? args.text ?? '{str}'}"`;
+        case 'not.have.text':
+            return `Expect ${el} not to have text "${args.expected ?? args.text ?? '{str}'}"`;
+        case 'contain.text':
+            return `Expect ${el} to contain text "${args.expected ?? args.text ?? '{sub}'}"`;
+        case 'not.contain.text':
+            return `Expect ${el} not to contain text "${args.expected ?? args.text ?? '{s}'}"`;
+        case 'have.value':
+            return `Expect ${el} to have value "${args.expected ?? args.value ?? '{val}'}"`;
+        case 'not.have.value':
+            return `Expect ${el} not to have value "${args.expected ?? args.value ?? '{val}'}"`;
+        case 'contain.value':
+            return `Expect ${el} to contain value "${args.expected ?? args.value ?? '{s}'}"`;
+        case 'not.contain.value':
+            return `Expect ${el} not to contain value "${args.expected ?? args.value ?? '{s}'}"`;
+        case 'have.attr':
+            return args.value !== undefined
+                ? `Expect ${el} to have attribute "${args.name ?? args.expected ?? '{k}'}" = "${args.value}"`
+                : `Expect ${el} to have attribute "${args.name ?? args.expected ?? '{k}'}"`;
+        case 'not.have.attr':
+            return `Expect ${el} not to have attribute "${args.name ?? args.expected ?? '{k}'}"`;
+        case 'have.class':
+            return `Expect ${el} to have class "${args.expected ?? args.className ?? '{cls}'}"`;
+        case 'not.have.class':
+            return `Expect ${el} not to have class "${args.expected ?? args.className ?? '{cls}'}"`;
+        case 'have.css':
+            return `Expect ${el} to have CSS "${args.name ?? args.property ?? '{prop}'}" = "${args.value ?? '{val}'}"`;
+        case 'not.have.css':
+            return `Expect ${el} not to have CSS "${args.name ?? args.property ?? '{p}'}" = "${args.value ?? '{v}'}"`;
+        // Collections
+        case 'have.length':
+            return `Expect ${col} count to equal ${args.expected ?? args.length ?? '{n}'}`;
+        case 'not.have.length':
+            return `Expect ${col} count not to equal ${args.expected ?? args.length ?? '{n}'}`;
+        case 'have.length.greaterThan':
+            return `Expect ${col} count to be greater than ${args.expected ?? args.min ?? '{n}'}`;
+        case 'have.length.lessThan':
+            return `Expect ${col} count to be less than ${args.expected ?? args.max ?? '{n}'}`;
+        case 'be.empty':
+            return `Expect ${col} to be empty`;
+        case 'not.be.empty':
+            return `Expect ${col} not to be empty`;
+        // Browser Context
+        case 'have.url':
+        case 'shouldHaveUrl':
+            return `Expect browser URL to be "${args.expected ?? args.url ?? '{url}'}"`;
+        case 'contain.url':
+        case 'shouldContainUrl':
+            return `Expect browser URL to contain "${args.expected ?? args.url ?? '{url}'}"`;
+        case 'have.title':
+        case 'shouldHaveTitle':
+            return `Expect browser title to be "${args.expected ?? args.title ?? '{title}'}"`;
+        case 'contain.title':
+        case 'shouldContainTitle':
+            return `Expect browser title to contain "${args.expected ?? args.title ?? '{title}'}"`;
+        case 'be.loaded':
+        case 'shouldBeLoaded':
+        case 'be.pageLoaded':
+        case 'shouldBePageLoaded':
+            return `Expect page to be fully loaded`;
+        case 'have.noConsoleErrors':
+        case 'shouldHaveNoConsoleErrors':
+            return `Expect browser console to have no errors`;
+        default:
+            return `Expect ${el} to match ${assertionKey}`;
+    }
+}

package/dist/reporter/summary-view.d.ts

@@ -0,0 +1,12 @@
+export interface ExecutionSummary {
+    totalSuites: number;
+    totalTests: number;
+    passedCount: number;
+    failedCount: number;
+    durationMs: number;
+    reportLocation: string;
+}
+/**
+ * Renders the final execution summary box.
+ */
+export declare function renderSummaryView(summary: ExecutionSummary): void;

package/dist/reporter/summary-view.js

@@ -0,0 +1,19 @@
+import chalk from 'chalk';
+/**
+ * Renders the final execution summary box.
+ */
+export function renderSummaryView(summary) {
+    const { totalSuites, totalTests, passedCount, failedCount, durationMs, reportLocation } = summary;
+    const durationSec = (durationMs / 1000).toFixed(2);
+    console.log();
+    console.log(chalk.bold('TestSpectra Execution Summary'));
+    console.log(chalk.gray('────────────────────────────────────────'));
+    console.log(`Suites:    ${chalk.bold(totalSuites)}`);
+    console.log(`Tests:     ${chalk.bold(totalTests)} total, ` +
+        `${passedCount > 0 ? chalk.green.bold(`${passedCount} passed`) : '0 passed'}, ` +
+        `${failedCount > 0 ? chalk.red.bold(`${failedCount} failed`) : '0 failed'}`);
+    console.log(`Duration:  ${durationSec}s`);
+    console.log(`Report:    ${chalk.cyan(reportLocation)}`);
+    console.log(chalk.gray('────────────────────────────────────────'));
+    console.log();
+}

package/dist/reporter/terminal-stream.d.ts

@@ -0,0 +1,32 @@
+export declare class TerminalStream {
+    private spinner;
+    private currentTestTitle;
+    private stepCount;
+    constructor();
+    /**
+     * Starts a new test case, logging the pending bullet and test title.
+     */
+    startTest(title: string): void;
+    /**
+     * Begins a new step, rendering an active spinner on the terminal with 2 spaces indentation.
+     */
+    startStep(text: string): void;
+    /**
+     * Marks the current step as passed, updating the spinner to a green checkmark
+     * and appending the duration in gray with 2 spaces indentation.
+     */
+    passStep(text: string, durationMs: number): void;
+    /**
+     * Marks the current step as failed, updating the spinner to a red cross,
+     * coloring the text red, appending the duration, and optionally logging the error with 2 spaces indentation.
+     */
+    failStep(text: string, durationMs: number, errorMsg?: string): void;
+    /**
+     * Concludes the active test case as passed, overwriting the initial "●" line with "✓" and duration in-place.
+     */
+    passTest(title: string, durationMs: number): void;
+    /**
+     * Concludes the active test case as failed, overwriting the initial "●" line with "✗" and duration in-place.
+     */
+    failTest(title: string, durationMs: number): void;
+}

package/dist/reporter/terminal-stream.js

@@ -0,0 +1,82 @@
+import ora from 'ora';
+import chalk from 'chalk';
+export class TerminalStream {
+    spinner;
+    currentTestTitle = '';
+    stepCount = 0;
+    constructor() {
+        this.spinner = ora({
+            spinner: 'dots',
+            color: 'cyan',
+            prefixText: '  ',
+        });
+    }
+    /**
+     * Starts a new test case, logging the pending bullet and test title.
+     */
+    startTest(title) {
+        if (this.spinner.isSpinning) {
+            this.spinner.stop();
+        }
+        this.currentTestTitle = title;
+        this.stepCount = 0;
+        console.log(`${chalk.hex('#2dd4bf')('●')} ${chalk.white.bold(title)}`);
+    }
+    /**
+     * Begins a new step, rendering an active spinner on the terminal with 2 spaces indentation.
+     */
+    startStep(text) {
+        if (this.spinner.isSpinning) {
+            this.spinner.stop();
+        }
+        this.spinner.start(text);
+    }
+    /**
+     * Marks the current step as passed, updating the spinner to a green checkmark
+     * and appending the duration in gray with 2 spaces indentation.
+     */
+    passStep(text, durationMs) {
+        const durationStr = chalk.gray(`(${durationMs}ms)`);
+        this.spinner.succeed(`${text} ${durationStr}`);
+        this.stepCount++;
+    }
+    /**
+     * Marks the current step as failed, updating the spinner to a red cross,
+     * coloring the text red, appending the duration, and optionally logging the error with 2 spaces indentation.
+     */
+    failStep(text, durationMs, errorMsg) {
+        const durationStr = chalk.gray(`(${durationMs}ms)`);
+        this.spinner.fail(`${chalk.red(text)} ${durationStr}`);
+        this.stepCount++;
+        if (errorMsg) {
+            console.error(chalk.red(`    ↳ ${errorMsg}`));
+            this.stepCount++;
+        }
+    }
+    /**
+     * Concludes the active test case as passed, overwriting the initial "●" line with "✓" and duration in-place.
+     */
+    passTest(title, durationMs) {
+        if (this.spinner.isSpinning) {
+            this.spinner.stop();
+        }
+        const testTitle = title || this.currentTestTitle;
+        const durationStr = chalk.gray(`(${durationMs}ms)`);
+        const completedHeader = `${chalk.hex('#34d399')('✓')} ${chalk.white.bold(testTitle)} ${durationStr}`;
+        const linesToMoveUp = this.stepCount + 1;
+        process.stdout.write(`\x1b[${linesToMoveUp}A\r\x1b[2K${completedHeader}\x1b[${linesToMoveUp}B\r\n`);
+    }
+    /**
+     * Concludes the active test case as failed, overwriting the initial "●" line with "✗" and duration in-place.
+     */
+    failTest(title, durationMs) {
+        if (this.spinner.isSpinning) {
+            this.spinner.stop();
+        }
+        const testTitle = title || this.currentTestTitle;
+        const durationStr = chalk.gray(`(${durationMs}ms)`);
+        const completedHeader = `${chalk.hex('#f87171')('✗')} ${chalk.white.bold(testTitle)} ${durationStr}`;
+        const linesToMoveUp = this.stepCount + 1;
+        process.stdout.write(`\x1b[${linesToMoveUp}A\r\x1b[2K${completedHeader}\x1b[${linesToMoveUp}B\r\n`);
+    }
+}

package/dist/reporter/types.d.ts

@@ -0,0 +1,2 @@
+export type ActionKey = 'click' | 'doubleClick' | 'rightClick' | 'type' | 'clear' | 'select' | 'hover' | 'dragDrop' | 'scrollIntoView' | 'longPress' | 'waitForElement' | 'navigate' | 'back' | 'forward' | 'refresh' | 'setViewport' | 'wait' | 'pressKey' | 'scroll' | 'swipe' | 'intercept' | 'clearCookies' | 'clearLocalStorage';
+export type AssertionKey = 'be.visible' | 'not.be.visible' | 'exist' | 'not.exist' | 'be.clickable' | 'not.be.clickable' | 'be.enabled' | 'be.disabled' | 'be.checked' | 'not.be.checked' | 'be.selected' | 'not.be.selected' | 'be.focused' | 'not.be.focused' | 'have.text' | 'not.have.text' | 'contain.text' | 'not.contain.text' | 'have.value' | 'not.have.value' | 'contain.value' | 'not.contain.value' | 'have.attr' | 'not.have.attr' | 'have.class' | 'not.have.class' | 'have.css' | 'not.have.css' | 'have.length' | 'not.have.length' | 'have.length.greaterThan' | 'have.length.lessThan' | 'be.empty' | 'not.be.empty' | 'shouldHaveUrl' | 'shouldContainUrl' | 'shouldHaveTitle' | 'shouldContainTitle' | 'shouldBeLoaded' | 'shouldBePageLoaded' | 'shouldHaveNoConsoleErrors' | 'have.url' | 'contain.url' | 'have.title' | 'contain.title' | 'be.loaded' | 'be.pageLoaded' | 'have.noConsoleErrors';

package/dist/reporter/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runner/bridge.d.ts

@@ -1,18 +1,23 @@
-import { ConfigData } from "../config/schema.js";
-import { Reporter, TestRunResult } from "./reporter.js";
+import { ConfigData } from '../config/schema.js';
+import { Reporter, TestRunResult } from './reporter.js';
 export interface RunOptions {
     baseDir: string;
     appDataPath: string;
-    platform: "web" | "android" | "ios" | "common";
-    suite: string;
-    testCases: Array<{
+    platform: 'web' | 'android' | 'ios' | 'common' | 'mobile';
+    suite?: string;
+    testCases?: Array<{
         id: string;
         title: string;
         executionOrder?: number;
     }>;
     config: ConfigData;
     targetDevice?: string;
+    licenseKey?: string;
     outputJsonPath?: string;
+    specs?: string[];
+    concurrency?: number;
+    failedOnly?: boolean;
+    failedTarget?: string;
 }
 export declare class RustCoreBridge {
     static resolveBinaryPath(): string;