@testspectra/matchers 1.1.8-rc.2 → 1.1.8-rc.21

package/tsconfig.json

@@ -1,17 +1,17 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "declaration": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "types": ["node"],
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "src/**/__tests__/**", "src/runtime/**"]
-}
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["node"],
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "src/**/__tests__/**", "src/runtime/**"]
+}

package/dist/semantic.d.ts

@@ -1,11 +0,0 @@
-/**
- * @packageDocumentation
- * # @testspectra/matchers - Semantic Natural Language Formatter
- *
- * Formats commands, actions, and assertions into clean, grammatically
- * correct English sentences for real-time reporting.
- */
-export declare function formatSemanticTarget(target: any, isCollection?: boolean): string;
-export declare function formatSemanticAction(action: string, target: any, args?: any[]): string;
-export declare function formatSemanticMatcher(target: any, matcher: string, args?: any[], isCollection?: boolean): string;
-export declare function formatSemanticBrowser(method: string, args?: any[]): string;

package/dist/semantic.js

@@ -1,141 +0,0 @@
-/**
- * @packageDocumentation
- * # @testspectra/matchers - Semantic Natural Language Formatter
- *
- * Formats commands, actions, and assertions into clean, grammatically
- * correct English sentences for real-time reporting.
- */
-export function formatSemanticTarget(target, isCollection = false) {
-    if (target === undefined || target === null)
-        return isCollection ? 'collection' : 'element';
-    if (typeof target === 'string') {
-        return isCollection ? `collection "${target}"` : `element "${target}"`;
-    }
-    if (typeof target === 'object') {
-        if (target.selector) {
-            return isCollection ? `collection "${target.selector}"` : `element "${target.selector}"`;
-        }
-        if (target.constructor && target.constructor.name && target.constructor.name !== 'Object') {
-            return `element "${target.constructor.name}"`;
-        }
-    }
-    return `element "${String(target)}"`;
-}
-export function formatSemanticAction(action, target, args = []) {
-    const targetStr = formatSemanticTarget(target, false);
-    const arg0 = args[0] !== undefined ? String(args[0]) : '';
-    switch (action) {
-        case 'type':
-            return `Type "${arg0}" into ${targetStr}`;
-        case 'click':
-            return `Click on ${targetStr}`;
-        case 'doubleClick':
-            return `Double-click on ${targetStr}`;
-        case 'rightClick':
-            return `Right-click on ${targetStr}`;
-        case 'check':
-            return `Check checkbox ${targetStr}`;
-        case 'uncheck':
-            return `Uncheck checkbox ${targetStr}`;
-        case 'selectOption':
-            return `Select option "${arg0}" in ${targetStr}`;
-        case 'clear':
-            return `Clear text in ${targetStr}`;
-        case 'hover':
-            return `Hover over ${targetStr}`;
-        case 'scrollIntoView':
-            return `Scroll ${targetStr} into view`;
-        case 'navigate':
-            return `Navigate to "${arg0}"`;
-        case 'wait':
-            return `Wait for ${arg0}ms`;
-        case 'pause':
-            return `Pause execution for ${arg0}ms`;
-        default:
-            return `Perform ${action} on ${targetStr}`;
-    }
-}
-export function formatSemanticMatcher(target, matcher, args = [], isCollection = false) {
-    const targetStr = formatSemanticTarget(target, isCollection);
-    const arg0 = args[0] !== undefined ? String(args[0]) : '';
-    const arg1 = args[1] !== undefined ? String(args[1]) : '';
-    switch (matcher) {
-        case 'be.visible':
-            return `Expect ${targetStr} to be visible`;
-        case 'not.be.visible':
-            return `Expect ${targetStr} not to be visible`;
-        case 'exist':
-            return `Expect ${targetStr} to exist in DOM`;
-        case 'not.exist':
-            return `Expect ${targetStr} not to exist in DOM`;
-        case 'be.enabled':
-            return `Expect ${targetStr} to be enabled`;
-        case 'be.disabled':
-            return `Expect ${targetStr} to be disabled`;
-        case 'be.checked':
-            return `Expect ${targetStr} to be checked`;
-        case 'not.be.checked':
-            return `Expect ${targetStr} not to be checked`;
-        case 'have.text':
-            return `Expect ${targetStr} to have text "${arg0}"`;
-        case 'not.have.text':
-            return `Expect ${targetStr} not to have text "${arg0}"`;
-        case 'contain.text':
-            return `Expect ${targetStr} to contain text "${arg0}"`;
-        case 'not.contain.text':
-            return `Expect ${targetStr} not to contain text "${arg0}"`;
-        case 'have.value':
-            return `Expect ${targetStr} to have value "${arg0}"`;
-        case 'not.have.value':
-            return `Expect ${targetStr} not to have value "${arg0}"`;
-        case 'contain.value':
-            return `Expect ${targetStr} to contain value "${arg0}"`;
-        case 'not.contain.value':
-            return `Expect ${targetStr} not to contain value "${arg0}"`;
-        case 'have.class':
-            return `Expect ${targetStr} to have class "${arg0}"`;
-        case 'not.have.class':
-            return `Expect ${targetStr} not to have class "${arg0}"`;
-        case 'have.attr':
-            return args.length >= 2
-                ? `Expect ${targetStr} to have attribute "${arg0}" = "${arg1}"`
-                : `Expect ${targetStr} to have attribute "${arg0}"`;
-        case 'not.have.attr':
-            return `Expect ${targetStr} not to have attribute "${arg0}"`;
-        case 'be.focused':
-            return `Expect ${targetStr} to be focused`;
-        case 'be.selected':
-            return `Expect ${targetStr} to be selected`;
-        case 'be.empty':
-            return `Expect ${targetStr} to be empty`;
-        case 'not.be.empty':
-            return `Expect ${targetStr} not to be empty`;
-        case 'have.length':
-            return `Expect ${targetStr} count to equal ${arg0}`;
-        case 'have.length.greaterThan':
-            return `Expect ${targetStr} count to be greater than ${arg0}`;
-        case 'have.length.lessThan':
-            return `Expect ${targetStr} count to be less than ${arg0}`;
-        case 'have.length.atLeast':
-            return `Expect ${targetStr} count to be at least ${arg0}`;
-        case 'have.length.atMost':
-            return `Expect ${targetStr} count to be at most ${arg0}`;
-        default:
-            return `Expect ${targetStr} to match ${matcher}`;
-    }
-}
-export function formatSemanticBrowser(method, args = []) {
-    const arg0 = args[0] !== undefined ? String(args[0]) : '';
-    switch (method) {
-        case 'shouldContainTitle':
-            return `Expect browser title to contain "${arg0}"`;
-        case 'shouldHaveTitle':
-            return `Expect browser title to be "${arg0}"`;
-        case 'shouldContainUrl':
-            return `Expect browser URL to contain "${arg0}"`;
-        case 'shouldHaveUrl':
-            return `Expect browser URL to be "${arg0}"`;
-        default:
-            return `Expect browser to ${method} "${arg0}"`;
-    }
-}