@testspectra/matchers 1.0.70 → 1.1.0-rc.1

package/dist/intercept/mock-registry.js

@@ -0,0 +1,97 @@
+import fs from 'fs';
+import path from 'path';
+import { MockHandle } from './mock-handle.js';
+export function globToRegExp(glob) {
+    let regexStr = '';
+    let i = 0;
+    while (i < glob.length) {
+        const c = glob[i];
+        if (c === '*' && glob[i + 1] === '*') {
+            regexStr += '.*';
+            i += 2;
+        }
+        else if (c === '*') {
+            regexStr += '[^/]*';
+            i += 1;
+        }
+        else if (['.', '?', '+', '^', '$', '[', ']', '(', ')', '{', '}', '|', '\\'].includes(c)) {
+            regexStr += `\\${c}`;
+            i += 1;
+        }
+        else {
+            regexStr += c;
+            i += 1;
+        }
+    }
+    // If glob does not start with protocol and does not start with wildcard, allow leading domain
+    if (!glob.startsWith('http://') && !glob.startsWith('https://') && !glob.startsWith('*')) {
+        return new RegExp(`(?:https?://[^/]+)?${regexStr}(?:\\?.*)?$`);
+    }
+    return new RegExp(`^${regexStr}(?:\\?.*)?$`);
+}
+export function matchesUrl(pattern, url) {
+    if (pattern instanceof RegExp) {
+        return pattern.test(url);
+    }
+    if (pattern === url) {
+        return true;
+    }
+    try {
+        const parsed = new URL(url, 'http://localhost');
+        if (pattern === parsed.pathname || pattern === `${parsed.pathname}${parsed.search}`) {
+            return true;
+        }
+    }
+    catch { }
+    const reg = globToRegExp(pattern);
+    return reg.test(url);
+}
+export function matchesMethod(ruleMethod, reqMethod = 'GET') {
+    if (!ruleMethod || ruleMethod.toUpperCase() === 'ALL') {
+        return true;
+    }
+    return ruleMethod.toUpperCase() === reqMethod.toUpperCase();
+}
+export class MockRegistry {
+    static instance;
+    handles = [];
+    recordedResources = [];
+    static getInstance() {
+        if (!MockRegistry.instance) {
+            MockRegistry.instance = new MockRegistry();
+        }
+        return MockRegistry.instance;
+    }
+    register(rule) {
+        const handle = new MockHandle(rule);
+        this.handles.unshift(handle);
+        return handle;
+    }
+    findMatchingHandle(method, url) {
+        return this.handles.find((h) => {
+            return matchesMethod(h.rule.method, method) && matchesUrl(h.rule.url, url);
+        });
+    }
+    clear() {
+        for (const h of this.handles) {
+            h.clear();
+        }
+        this.handles = [];
+    }
+    recordResource(resource) {
+        this.recordedResources.push(resource);
+    }
+    getRecordedResources() {
+        return [...this.recordedResources];
+    }
+    clearRecordedResources() {
+        this.recordedResources = [];
+    }
+    exportNetworkResources(filePath) {
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, JSON.stringify(this.recordedResources, null, 2), 'utf-8');
+    }
+}

package/dist/intercept/types.d.ts

@@ -0,0 +1,43 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'ALL';
+export type NetworkAbortReason = 'Failed' | 'Aborted' | 'TimedOut' | 'ConnectionReset' | 'AccessDenied';
+export interface MockResponse {
+    status?: number;
+    headers?: Record<string, string>;
+    body?: any;
+    delayMs?: number;
+}
+export interface InterceptedRequest {
+    id: string;
+    url: string;
+    method: string;
+    headers?: Record<string, string>;
+    body?: any;
+    timestamp: number;
+}
+export interface InterceptRule {
+    url: string | RegExp;
+    method?: HttpMethod;
+    response?: MockResponse | ((request: InterceptedRequest) => MockResponse | Promise<MockResponse>);
+}
+export interface NetworkResourceTiming {
+    dns: number;
+    tcp: number;
+    ssl: number;
+    ttfb: number;
+    download: number;
+    total: number;
+}
+export interface RecordedNetworkResource {
+    id: string;
+    url: string;
+    method: string;
+    status: number;
+    statusText: string;
+    resourceType: string;
+    requestHeaders?: Record<string, string>;
+    responseHeaders?: Record<string, string>;
+    requestBody?: any;
+    responseBody?: any;
+    timing: NetworkResourceTiming;
+    transferSize: number;
+}

package/dist/intercept/types.js

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

package/dist/matchers.d.ts

@@ -1,4 +1,4 @@
-import { SingleElementMatcher, MultiElementMatcher, ElementTarget } from "./types.js";
+import { SingleElementMatcher, MultiElementMatcher, ElementTarget } from './types.js';
 /**
  * Resolves an ElementTarget (selector string, WebdriverIO.Element, or ChainablePromiseElement)
  * to an actionable WebdriverIO.Element.
@@ -6,9 +6,16 @@ import { SingleElementMatcher, MultiElementMatcher, ElementTarget } from "./type
  * @param target - Selector string or element instance.
  * @returns Resolved WebdriverIO.Element instance.
  */
-export declare function resolveElement(target: ElementTarget): Promise<WebdriverIO.Element>;
 /**
- * Executes a single element matcher against the WebdriverIO browser / element context.
+ * Resolves an ElementTarget (selector string, WebdriverIO.Element, Playwright Locator, or ChainablePromiseElement)
+ * to an actionable element instance.
+ *
+ * @param target - Selector string or element instance.
+ * @returns Resolved element or locator instance.
+ */
+export declare function resolveElement(target: ElementTarget): Promise<any>;
+/**
+ * Executes a single element matcher against the active runner context (Playwright or WebdriverIO).
  *
  * @param target - Optional element target (not required for browser-level assertions).
  * @param matcher - Single element matcher string.
@@ -16,10 +23,14 @@ export declare function resolveElement(target: ElementTarget): Promise<Webdriver
  */
 export declare function executeSingleMatcher(target: ElementTarget | undefined, matcher: SingleElementMatcher, args: any[]): Promise<void>;
 /**
- * Executes a multi-element collection matcher against WebdriverIO $$.
+ * Executes a multi-element collection matcher against $$.
  *
  * @param selector - CSS/XPath selector for the collection.
  * @param matcher - Multi-element matcher string.
  * @param args - Expected values or count limits.
  */
 export declare function executeMultiMatcher(selector: string, matcher: MultiElementMatcher, args: any[]): Promise<void>;
+/**
+ * Executes browser-level context assertions.
+ */
+export declare function executeBrowserAssertion(assertion: 'shouldHaveUrl' | 'shouldContainUrl' | 'shouldHaveTitle' | 'shouldContainTitle' | 'shouldBePageLoaded' | 'shouldHaveNoConsoleErrors', args?: any[]): Promise<void>;