@testspectra/cli 1.0.69 → 1.1.0

package/dist/plugin.js

@@ -1,184 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { TypeGenerator } from "./types/generator.js";
-/**
- * Traverses upwards from `startDir` to locate the TestSpectra workspace root.
- * Looks for indicators: `spectra.config.ts`, `.testspectra`, `pnpm-workspace.yaml`, or `nx.json`.
- */
-function findWorkspaceRoot(startDir) {
-    let cur = path.resolve(startDir);
-    while (cur !== path.dirname(cur)) {
-        if (fs.existsSync(path.join(cur, "spectra.config.ts")) ||
-            fs.existsSync(path.join(cur, ".testspectra")) ||
-            fs.existsSync(path.join(cur, "pnpm-workspace.yaml")) ||
-            fs.existsSync(path.join(cur, "nx.json"))) {
-            return cur;
-        }
-        cur = path.dirname(cur);
-    }
-    return startDir;
-}
-function appendLog(workspaceRoot, message) {
-    try {
-        const logDir = path.join(workspaceRoot, ".testspectra", "logs");
-        if (!fs.existsSync(logDir))
-            fs.mkdirSync(logDir, { recursive: true });
-        const logFile = path.join(logDir, "plugin.log");
-        const timestamp = new Date().toISOString();
-        fs.appendFileSync(logFile, `[${timestamp}] ${message}\n`, "utf-8");
-    }
-    catch { }
-}
-/**
- * TypeScript Language Service Plugin Factory for TestSpectra.
- * Runs silently inside TSServer (VS Code, Cursor, WebStorm, Neovim, etc.).
- *
- * It generates and refreshes `.testspectra/types/` ambient declarations
- * automatically in the background whenever the project is opened or files change.
- */
-function init(modules) {
-    const tsModule = modules.typescript;
-    function create(info) {
-        const project = info.project;
-        const configPath = typeof project.getConfigFilePath === "function" ? project.getConfigFilePath() : "";
-        const projectDir = configPath ? path.dirname(configPath) : project.getCurrentDirectory();
-        const workspaceRoot = findWorkspaceRoot(projectDir);
-        const log = (msg) => {
-            try {
-                info.project.projectService.logger.info(`[TestSpectra TS Plugin] ${msg}`);
-            }
-            catch { }
-            appendLog(workspaceRoot, msg);
-        };
-        log(`Plugin initialized on project: ${projectDir} (resolved root: ${workspaceRoot})`);
-        // 1. Initial Generation on project load
-        try {
-            TypeGenerator.writeDeclarationFiles(workspaceRoot);
-            if (typeof project.markAsDirty === "function") {
-                project.markAsDirty();
-            }
-            log(`Generated ambient declarations on startup`);
-        }
-        catch (err) {
-            log(`Failed initial type generation: ${err?.message}`);
-        }
-        // Debounced regeneration handler
-        let debounceTimer = null;
-        const triggerRegeneration = (reason, sync = false) => {
-            const doRegen = () => {
-                try {
-                    TypeGenerator.writeDeclarationFiles(workspaceRoot);
-                    if (typeof project.markAsDirty === "function") {
-                        project.markAsDirty();
-                    }
-                    log(`Regenerated ambient declarations (${reason})`);
-                }
-                catch (err) {
-                    log(`Error during regeneration: ${err?.message}`);
-                }
-            };
-            if (sync) {
-                doRegen();
-            }
-            else {
-                if (debounceTimer)
-                    clearTimeout(debounceTimer);
-                debounceTimer = setTimeout(doRegen, 80);
-            }
-        };
-        // 2. Active File System Watcher on the entire workspace
-        try {
-            if (fs.existsSync(workspaceRoot)) {
-                const watcher = fs.watch(workspaceRoot, { recursive: true }, (eventType, filename) => {
-                    if (!filename)
-                        return;
-                    const fn = filename.toString();
-                    // Skip internal and build directories
-                    if (fn.includes(".testspectra") ||
-                        fn.includes("node_modules") ||
-                        fn.includes(".git") ||
-                        fn.includes("dist") ||
-                        fn.includes(".nx")) {
-                        return;
-                    }
-                    // Match relevant entity files
-                    if (fn.includes("fixtures") ||
-                        fn.includes("page-objects") ||
-                        fn.includes("pageobjects") ||
-                        fn.includes("actions") ||
-                        fn.includes("steps") ||
-                        fn.includes("hooks") ||
-                        fn.includes("spectra.config")) {
-                        log(`Detected file change [${eventType}]: ${fn}`);
-                        triggerRegeneration(`fs.watch '${eventType}' on ${fn}`);
-                    }
-                });
-                watcher.on("error", () => { });
-                log(`Attached recursive fs.watch on ${workspaceRoot}`);
-            }
-        }
-        catch (err) {
-            log(`Note: Recursive fs.watch not supported or failed: ${err?.message}`);
-        }
-        // 3. Proxy language service methods to detect file modifications / completions
-        if (!info.languageService) {
-            return Object.create(null);
-        }
-        const proxy = Object.create(null);
-        for (const k of Object.keys(info.languageService)) {
-            const x = info.languageService[k];
-            // @ts-ignore
-            proxy[k] = (...args) => x.apply(info.languageService, args);
-        }
-        // Intercept getCompletionsAtPosition to ensure fresh types
-        const originalGetCompletions = info.languageService.getCompletionsAtPosition;
-        proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings) => {
-            const ext = path.extname(fileName);
-            if (ext === ".ts" || ext === ".tsx" || ext === ".js" || ext === ".mjs") {
-                triggerRegeneration(`completions at ${path.basename(fileName)}`, false);
-            }
-            return originalGetCompletions.apply(info.languageService, [
-                fileName,
-                position,
-                options,
-                formattingSettings,
-            ]);
-        };
-        // Intercept getQuickInfoAtPosition for fresh hover info
-        const originalGetQuickInfo = info.languageService.getQuickInfoAtPosition;
-        proxy.getQuickInfoAtPosition = (fileName, position) => {
-            return originalGetQuickInfo.apply(info.languageService, [fileName, position]);
-        };
-        return proxy;
-    }
-    function getExternalFiles(project) {
-        try {
-            const workspaceRoot = findWorkspaceRoot(project.getCurrentDirectory());
-            const typesDir = path.join(workspaceRoot, ".testspectra", "types");
-            const files = [];
-            function collectDts(dir) {
-                if (!fs.existsSync(dir))
-                    return;
-                const entries = fs.readdirSync(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    const fullPath = path.join(dir, entry.name);
-                    if (entry.isDirectory()) {
-                        collectDts(fullPath);
-                    }
-                    else if (entry.isFile() && entry.name.endsWith(".d.ts")) {
-                        files.push(fullPath);
-                    }
-                }
-            }
-            collectDts(typesDir);
-            return files;
-        }
-        catch {
-            return [];
-        }
-    }
-    return { create, getExternalFiles };
-}
-init.TypeGenerator = TypeGenerator;
-export default init;
-export { init };

package/dist/step/index.d.ts

@@ -1,6 +0,0 @@
-export * from "./types.js";
-export * from "./matchers.js";
-export * from "./runner/single.js";
-export * from "./runner/collection.js";
-export * from "./spectra.js";
-export * from "./proto.js";

package/dist/step/index.js

@@ -1,6 +0,0 @@
-export * from "./types.js";
-export * from "./matchers.js";
-export * from "./runner/single.js";
-export * from "./runner/collection.js";
-export * from "./spectra.js";
-export * from "./proto.js";

package/dist/step/matchers.d.ts

@@ -1,14 +0,0 @@
-import { SingleElementMatcher, MultiElementMatcher, ElementTarget } from "./types.js";
-/**
- * Resolves an ElementTarget (selector string, WebdriverIO.Element, or ChainablePromiseElement)
- * to an actionable WebdriverIO.Element.
- */
-export declare function resolveElement(target: ElementTarget): Promise<WebdriverIO.Element>;
-/**
- * Executes a single element matcher against the WebdriverIO browser / element context.
- */
-export declare function executeSingleMatcher(target: ElementTarget | undefined, matcher: SingleElementMatcher, args: any[]): Promise<void>;
-/**
- * Executes a multi-element collection matcher against WebdriverIO $$.
- */
-export declare function executeMultiMatcher(selector: string, matcher: MultiElementMatcher, args: any[]): Promise<void>;

package/dist/step/matchers.js

@@ -1,114 +0,0 @@
-/**
- * Resolves an ElementTarget (selector string, WebdriverIO.Element, or ChainablePromiseElement)
- * to an actionable WebdriverIO.Element.
- */
-export async function resolveElement(target) {
-    if (typeof target === "string") {
-        const el = await $(target);
-        return el;
-    }
-    const el = await target;
-    return el;
-}
-/**
- * Executes a single element matcher against the WebdriverIO browser / element context.
- */
-export async function executeSingleMatcher(target, matcher, args) {
-    const isBrowserLevel = matcher === "have.url" ||
-        matcher === "contain.url" ||
-        matcher === "have.title" ||
-        matcher === "contain.title";
-    if (isBrowserLevel) {
-        const expected = args[0];
-        switch (matcher) {
-            case "have.url":
-                await expect(browser).toHaveUrl(expected);
-                break;
-            case "contain.url":
-                await expect(browser).toHaveUrl(expect.stringContaining(expected));
-                break;
-            case "have.title":
-                await expect(browser).toHaveTitle(expected);
-                break;
-            case "contain.title":
-                await expect(browser).toHaveTitle(expect.stringContaining(expected));
-                break;
-        }
-        return;
-    }
-    if (!target) {
-        throw new Error(`Assertion matcher '${matcher}' requires an element target.`);
-    }
-    const el = await resolveElement(target);
-    switch (matcher) {
-        case "be.visible":
-            await expect(el).toBeDisplayed();
-            break;
-        case "not.be.visible":
-            await expect(el).not.toBeDisplayed();
-            break;
-        case "exist":
-            await expect(el).toExist();
-            break;
-        case "not.exist":
-            await expect(el).not.toExist();
-            break;
-        case "be.enabled":
-            await expect(el).toBeEnabled();
-            break;
-        case "be.disabled":
-            await expect(el).toBeDisabled();
-            break;
-        case "be.checked":
-        case "be.selected":
-            await expect(el).toBeSelected();
-            break;
-        case "have.value":
-            await expect(el).toHaveValue(args[0]);
-            break;
-        case "contain.value":
-            await expect(el).toHaveValue(expect.stringContaining(args[0]));
-            break;
-        case "have.text":
-            await expect(el).toHaveText(args[0]);
-            break;
-        case "contain.text":
-            await expect(el).toHaveText(expect.stringContaining(args[0]));
-            break;
-        case "have.class":
-            await expect(el).toHaveElementClass(args[0]);
-            break;
-        case "have.attr":
-            if (args.length >= 2) {
-                await expect(el).toHaveAttribute(args[0], args[1]);
-            }
-            else {
-                await expect(el).toHaveAttribute(args[0]);
-            }
-            break;
-        default:
-            throw new Error(`Unsupported matcher: ${matcher}`);
-    }
-}
-/**
- * Executes a multi-element collection matcher against WebdriverIO $$.
- */
-export async function executeMultiMatcher(selector, matcher, args) {
-    const elements = await $$(selector);
-    switch (matcher) {
-        case "have.length":
-            await expect(elements).toBeElementsArrayOfSize(args[0]);
-            break;
-        case "have.length.greaterThan":
-            await expect(elements).toBeElementsArrayOfSize({ gte: args[0] + 1 });
-            break;
-        case "be.empty":
-            await expect(elements).toBeElementsArrayOfSize(0);
-            break;
-        case "exist":
-            await expect(elements).toBeElementsArrayOfSize({ gte: 1 });
-            break;
-        default:
-            throw new Error(`Unsupported multi-element matcher: ${matcher}`);
-    }
-}

package/dist/step/proto.d.ts

@@ -1,46 +0,0 @@
-declare global {
-    namespace WebdriverIO {
-        interface Element {
-            shouldBeVisible(): Promise<Element>;
-            shouldNotBeVisible(): Promise<Element>;
-            shouldExist(): Promise<Element>;
-            shouldNotExist(): Promise<Element>;
-            shouldBeEnabled(): Promise<Element>;
-            shouldBeDisabled(): Promise<Element>;
-            shouldBeSelected(): Promise<Element>;
-            shouldBeChecked(): Promise<Element>;
-            shouldHaveValue(expectedValue: string): Promise<Element>;
-            shouldContainValue(expectedValue: string): Promise<Element>;
-            shouldHaveText(expectedText: string): Promise<Element>;
-            shouldContainText(expectedText: string): Promise<Element>;
-            shouldHaveClass(className: string): Promise<Element>;
-            shouldHaveAttribute(attributeName: string, expectedValue?: string): Promise<Element>;
-        }
-        interface Browser {
-            shouldHaveUrl(expectedUrl: string): Promise<void>;
-            shouldContainUrl(expectedUrl: string): Promise<void>;
-            shouldHaveTitle(expectedTitle: string): Promise<void>;
-            shouldContainTitle(expectedTitle: string): Promise<void>;
-        }
-    }
-    interface Promise<T> {
-        shouldBeVisible(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-        shouldNotBeVisible(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-        shouldExist(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-        shouldNotExist(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-        shouldBeEnabled(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-        shouldBeDisabled(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-        shouldBeSelected(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-        shouldBeChecked(this: Promise<WebdriverIO.Element>): Promise<WebdriverIO.Element>;
-        shouldHaveValue(this: Promise<WebdriverIO.Element>, expectedValue: string): Promise<WebdriverIO.Element>;
-        shouldContainValue(this: Promise<WebdriverIO.Element>, expectedValue: string): Promise<WebdriverIO.Element>;
-        shouldHaveText(this: Promise<WebdriverIO.Element>, expectedText: string): Promise<WebdriverIO.Element>;
-        shouldContainText(this: Promise<WebdriverIO.Element>, expectedText: string): Promise<WebdriverIO.Element>;
-        shouldHaveClass(this: Promise<WebdriverIO.Element>, className: string): Promise<WebdriverIO.Element>;
-        shouldHaveAttribute(this: Promise<WebdriverIO.Element>, attributeName: string, expectedValue?: string): Promise<WebdriverIO.Element>;
-    }
-}
-/**
- * Install direct callable assertion methods onto WebdriverIO browser/element and Promise prototypes.
- */
-export declare function installPrototypes(): void;

package/dist/step/proto.js

@@ -1,114 +0,0 @@
-import { resolveElement } from "./matchers.js";
-/**
- * Install direct callable assertion methods onto WebdriverIO browser/element and Promise prototypes.
- */
-export function installPrototypes() {
-    const elementCommands = {
-        async shouldBeVisible() {
-            const el = await resolveElement(this);
-            await expect(el).toBeDisplayed();
-            return el;
-        },
-        async shouldNotBeVisible() {
-            const el = await resolveElement(this);
-            await expect(el).not.toBeDisplayed();
-            return el;
-        },
-        async shouldExist() {
-            const el = await resolveElement(this);
-            await expect(el).toExist();
-            return el;
-        },
-        async shouldNotExist() {
-            const el = await resolveElement(this);
-            await expect(el).not.toExist();
-            return el;
-        },
-        async shouldBeEnabled() {
-            const el = await resolveElement(this);
-            await expect(el).toBeEnabled();
-            return el;
-        },
-        async shouldBeDisabled() {
-            const el = await resolveElement(this);
-            await expect(el).toBeDisabled();
-            return el;
-        },
-        async shouldBeSelected() {
-            const el = await resolveElement(this);
-            await expect(el).toBeSelected();
-            return el;
-        },
-        async shouldBeChecked() {
-            const el = await resolveElement(this);
-            await expect(el).toBeSelected();
-            return el;
-        },
-        async shouldHaveValue(val) {
-            const el = await resolveElement(this);
-            await expect(el).toHaveValue(val);
-            return el;
-        },
-        async shouldContainValue(val) {
-            const el = await resolveElement(this);
-            await expect(el).toHaveValue(expect.stringContaining(val));
-            return el;
-        },
-        async shouldHaveText(text) {
-            const el = await resolveElement(this);
-            await expect(el).toHaveText(text);
-            return el;
-        },
-        async shouldContainText(text) {
-            const el = await resolveElement(this);
-            await expect(el).toHaveText(expect.stringContaining(text));
-            return el;
-        },
-        async shouldHaveClass(cls) {
-            const el = await resolveElement(this);
-            await expect(el).toHaveElementClass(cls);
-            return el;
-        },
-        async shouldHaveAttribute(name, val) {
-            const el = await resolveElement(this);
-            if (val !== undefined) {
-                await expect(el).toHaveAttribute(name, val);
-            }
-            else {
-                await expect(el).toHaveAttribute(name);
-            }
-            return el;
-        },
-    };
-    const browserCommands = {
-        async shouldHaveUrl(url) {
-            await expect(browser).toHaveUrl(url);
-        },
-        async shouldContainUrl(url) {
-            await expect(browser).toHaveUrl(expect.stringContaining(url));
-        },
-        async shouldHaveTitle(title) {
-            await expect(browser).toHaveTitle(title);
-        },
-        async shouldContainTitle(title) {
-            await expect(browser).toHaveTitle(expect.stringContaining(title));
-        },
-    };
-    if (typeof browser !== "undefined" && browser.addCommand) {
-        for (const [name, fn] of Object.entries(elementCommands)) {
-            browser.addCommand(name, fn, true);
-        }
-        for (const [name, fn] of Object.entries(browserCommands)) {
-            browser.addCommand(name, fn, false);
-        }
-    }
-    // Attach to Promise.prototype for ChainablePromiseElement unwrapping
-    for (const [name, fn] of Object.entries(elementCommands)) {
-        if (typeof Promise.prototype[name] !== "function") {
-            Promise.prototype[name] = async function (...args) {
-                const el = await this;
-                return await fn.call(el, ...args);
-            };
-        }
-    }
-}

package/dist/step/runner/collection.d.ts

@@ -1,13 +0,0 @@
-import { MultiElementMatcher } from "../types.js";
-import { SingleElementRunner } from "./single.js";
-export declare class MultiElementRunner implements PromiseLike<void> {
-    private _selector;
-    private _assertions;
-    constructor(selector: string);
-    should(matcher: MultiElementMatcher, ...args: any[]): this;
-    eq(index: number): SingleElementRunner;
-    first(): SingleElementRunner;
-    last(): SingleElementRunner;
-    each(callback: (el: SingleElementRunner, index: number) => Promise<void>): Promise<void>;
-    then<TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-}

package/dist/step/runner/collection.js

@@ -1,51 +0,0 @@
-import { executeMultiMatcher } from "../matchers.js";
-import { SingleElementRunner } from "./single.js";
-export class MultiElementRunner {
-    _selector;
-    _assertions = [];
-    constructor(selector) {
-        this._selector = selector;
-    }
-    // --- Collection Assertions ---
-    should(matcher, ...args) {
-        this._assertions.push({ matcher, args });
-        return this;
-    }
-    // --- Item Navigation ---
-    eq(index) {
-        const indexedSelector = `(${this._selector})[${index + 1}]`;
-        return new SingleElementRunner(indexedSelector);
-    }
-    first() {
-        return this.eq(0);
-    }
-    last() {
-        const indexedSelector = `(${this._selector})[last()]`;
-        return new SingleElementRunner(indexedSelector);
-    }
-    // --- Iteration Callback ---
-    async each(callback) {
-        const elements = await $$(this._selector);
-        const count = await elements.length;
-        for (let i = 0; i < count; i++) {
-            const runner = this.eq(i);
-            await callback(runner, i);
-        }
-    }
-    // --- Execution when awaited ---
-    async then(onfulfilled, onrejected) {
-        try {
-            for (const assert of this._assertions) {
-                await executeMultiMatcher(this._selector, assert.matcher, assert.args);
-            }
-            const res = (onfulfilled ? await onfulfilled() : undefined);
-            return res;
-        }
-        catch (err) {
-            if (onrejected) {
-                return onrejected(err);
-            }
-            throw err;
-        }
-    }
-}

package/dist/step/runner/single.d.ts

@@ -1,21 +0,0 @@
-import { SingleElementMatcher, ElementTarget } from "../types.js";
-export declare class SingleElementRunner implements PromiseLike<void> {
-    private _target;
-    private _action;
-    private _assertions;
-    constructor(target?: ElementTarget, action?: () => Promise<any>);
-    click(): this;
-    doubleClick(): this;
-    longPress(durationMs?: number): this;
-    type(value: string, options?: {
-        clearFirst?: boolean;
-    }): this;
-    clear(): this;
-    select(value: string): this;
-    hover(): this;
-    waitForElement(timeoutMs?: number): this;
-    should(matcher: SingleElementMatcher, ...args: any[]): this;
-    should(target: ElementTarget, matcher: SingleElementMatcher, ...args: any[]): this;
-    then<TResult1 = void, TResult2 = never>(onfulfilled?: ((value: void) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
-    private requireTarget;
-}