pw-core 1.2.0 → 1.2.1

package/dist/codegen/key-utils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Key creation utilities for codegen-generated registry keys.
+ *
+ * Rules:
+ * - Custom keys (testId, selector) are always camelCase
+ * - No spaces, hyphens, or special characters
+ * - Leading digits are trimmed
+ * - Trailing digits are preserved (they may be disambiguation suffixes)
+ * - Role suffixes (Btn, Input) are appended after sanitization
+ */
+/**
+ * Convert an arbitrary string into a clean camelCase registry key.
+ *
+ * @example
+ * toRegistryKey('GET api/app/projects List all projects') => 'getApiAppProjectsListAllProjects'
+ * toRegistryKey('01Dynamic-Locators') => 'dynamicLocators'
+ * toRegistryKey('POST api/app/projects Create-a-project') => 'postApiAppProjectsCreateAProject'
+ * toRegistryKey('switch-to-k6-core') => 'switchToK6Core'
+ * toRegistryKey('hello world') => 'helloWorld'
+ */
+export declare function toRegistryKey(str: string, options?: {
+    roleSuffix?: string;
+}): string;

package/dist/codegen/key-utils.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Key creation utilities for codegen-generated registry keys.
+ *
+ * Rules:
+ * - Custom keys (testId, selector) are always camelCase
+ * - No spaces, hyphens, or special characters
+ * - Leading digits are trimmed
+ * - Trailing digits are preserved (they may be disambiguation suffixes)
+ * - Role suffixes (Btn, Input) are appended after sanitization
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRegistryKey = toRegistryKey;
+/**
+ * Convert an arbitrary string into a clean camelCase registry key.
+ *
+ * @example
+ * toRegistryKey('GET api/app/projects List all projects') => 'getApiAppProjectsListAllProjects'
+ * toRegistryKey('01Dynamic-Locators') => 'dynamicLocators'
+ * toRegistryKey('POST api/app/projects Create-a-project') => 'postApiAppProjectsCreateAProject'
+ * toRegistryKey('switch-to-k6-core') => 'switchToK6Core'
+ * toRegistryKey('hello world') => 'helloWorld'
+ */
+function toRegistryKey(str, options) {
+    if (!str)
+        return 'element';
+    // Strip all non-alphanumeric characters except spaces (used as word separators)
+    // First, normalize common separators (hyphens, underscores, slashes, dots) to spaces
+    let normalized = str
+        .replace(/[-_/\\.]+/g, ' ')
+        // Remove any remaining special characters (keep letters, digits, spaces)
+        .replace(/[^a-zA-Z0-9\s]/g, '')
+        .trim();
+    if (!normalized)
+        return 'element';
+    // Split into words on whitespace and camelCase boundaries
+    const words = normalized
+        .replace(/([a-z])([A-Z])/g, '$1 $2') // split camelCase
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2') // split consecutive uppercase
+        .split(/\s+/)
+        .filter(Boolean);
+    if (words.length === 0)
+        return 'element';
+    // Build camelCase
+    const camel = words
+        .map((word, idx) => {
+        if (idx === 0)
+            return word.toLowerCase();
+        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+    })
+        .join('');
+    // Trim leading digits
+    let result = camel.replace(/^\d+/, '');
+    if (!result)
+        return 'element';
+    // Append role suffix if requested (e.g. 'Btn' for buttons)
+    if (options?.roleSuffix) {
+        const lowerResult = result.toLowerCase();
+        const lowerSuffix = options.roleSuffix.toLowerCase();
+        if (!lowerResult.endsWith(lowerSuffix)) {
+            result += options.roleSuffix;
+        }
+    }
+    // Hard cap at 40 characters
+    if (result.length > 40)
+        result = result.slice(0, 40);
+    return result;
+}

package/dist/codegen/scorer/base-score.d.ts

@@ -0,0 +1 @@
+export declare function getBaseScore(strategyName: string): number;

package/dist/codegen/scorer/base-score.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBaseScore = getBaseScore;
+const config_1 = require("../config");
+function getBaseScore(strategyName) {
+    return config_1.codegenConfig.weights[strategyName] ?? 0;
+}

package/dist/codegen/scorer/context-score.d.ts

@@ -0,0 +1,2 @@
+import { DOMContext } from '../types';
+export declare function getContextScore(context: DOMContext): number;

package/dist/codegen/scorer/context-score.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContextScore = getContextScore;
+const config_1 = require("../config");
+function getContextScore(context) {
+    let score = 0;
+    const cw = config_1.codegenConfig.contextWeights;
+    if (context.accessibleName) {
+        score += cw.accessibleName || 0;
+    }
+    if (context.siblingText) {
+        score += cw.siblingText || 0;
+    }
+    if (context.parentText) {
+        score += cw.parentText || 0;
+    }
+    if (context.nearbyHeading) {
+        score += cw.heading || 0;
+    }
+    if (context.parentAttributes) {
+        const hasSemanticParent = Object.keys(context.parentAttributes).some((attr) => attr.startsWith('data-') || attr === 'id' || attr === 'role');
+        if (hasSemanticParent) {
+            score += cw.semanticParent || 0;
+        }
+    }
+    return score;
+}

package/dist/codegen/scorer/index.d.ts

@@ -0,0 +1,5 @@
+export * from './base-score';
+export { getBaseScore as getStrategyScore } from './base-score';
+export * from './semantic-score';
+export * from './context-score';
+export * from './locator.ranking';

package/dist/codegen/scorer/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStrategyScore = void 0;
+__exportStar(require("./base-score"), exports);
+var base_score_1 = require("./base-score");
+Object.defineProperty(exports, "getStrategyScore", { enumerable: true, get: function () { return base_score_1.getBaseScore; } });
+__exportStar(require("./semantic-score"), exports);
+__exportStar(require("./context-score"), exports);
+__exportStar(require("./locator.ranking"), exports);

package/dist/codegen/scorer/locator.ranking.d.ts

@@ -0,0 +1,15 @@
+export interface RankingRule {
+    strategy: string;
+    source?: 'target' | 'child' | 'sibling' | 'parent' | 'ancestor';
+    attrName?: string | RegExp;
+    roleVal?: string;
+    score: number;
+}
+export declare const priorityRankingRules: RankingRule[];
+export declare function getPriorityScore(c: {
+    strategy: string;
+    source: string;
+    depth: number;
+    attrName?: string;
+    roleVal?: string;
+}): number;

package/dist/codegen/scorer/locator.ranking.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.priorityRankingRules = void 0;
+exports.getPriorityScore = getPriorityScore;
+exports.priorityRankingRules = [
+    { strategy: 'testId', source: 'target', score: 1000 },
+    { strategy: 'testId', source: 'sibling', score: 980 },
+    { strategy: 'testId', source: 'parent', score: 970 },
+    { strategy: 'testId', source: 'ancestor', score: 960 },
+    { strategy: 'dataAttribute', attrName: /data-test-id|data-testid|datatestid/i, source: 'target', score: 980 },
+    { strategy: 'dataAttribute', attrName: /data-test-id|data-testid|datatestid/i, source: 'sibling', score: 960 },
+    { strategy: 'dataAttribute', attrName: /data-test-id|data-testid|datatestid/i, source: 'parent', score: 950 },
+    { strategy: 'dataAttribute', attrName: /data-test-id|data-testid|datatestid/i, source: 'ancestor', score: 940 },
+    { strategy: 'id', source: 'target', score: 960 },
+    { strategy: 'id', source: 'sibling', score: 940 },
+    { strategy: 'id', source: 'parent', score: 930 },
+    { strategy: 'id', source: 'ancestor', score: 920 },
+    { strategy: 'dataAttribute', attrName: 'data-parent-id', source: 'target', score: 940 },
+    { strategy: 'dataAttribute', attrName: 'data-parent-id', source: 'sibling', score: 925 },
+    { strategy: 'dataAttribute', attrName: 'data-parent-id', source: 'parent', score: 915 },
+    { strategy: 'dataAttribute', attrName: 'data-parent-id', source: 'ancestor', score: 905 },
+    { strategy: 'dataAttribute', attrName: /data-.*id$/i, source: 'target', score: 920 },
+    { strategy: 'dataAttribute', attrName: /data-.*id$/i, source: 'sibling', score: 875 },
+    { strategy: 'dataAttribute', attrName: /data-.*id$/i, source: 'parent', score: 825 },
+    { strategy: 'dataAttribute', attrName: /data-.*id$/i, source: 'ancestor', score: 775 },
+    { strategy: 'dataAttribute', attrName: /id/i, source: 'target', score: 900 },
+    { strategy: 'dataAttribute', attrName: /id/i, source: 'sibling', score: 860 },
+    { strategy: 'dataAttribute', attrName: /id/i, source: 'parent', score: 810 },
+    { strategy: 'dataAttribute', attrName: /id/i, source: 'ancestor', score: 760 },
+    { strategy: 'role', roleVal: 'link', source: 'target', score: 880 },
+    { strategy: 'role', roleVal: 'link', source: 'sibling', score: 840 },
+    { strategy: 'role', roleVal: 'link', source: 'parent', score: 790 },
+    { strategy: 'role', roleVal: 'link', source: 'ancestor', score: 740 },
+    { strategy: 'role', roleVal: 'button', source: 'target', score: 870 },
+    { strategy: 'role', roleVal: 'button', source: 'sibling', score: 830 },
+    { strategy: 'role', roleVal: 'button', source: 'parent', score: 780 },
+    { strategy: 'role', roleVal: 'button', source: 'ancestor', score: 730 },
+    { strategy: 'text', source: 'target', score: 550 },
+    { strategy: 'text', source: 'sibling', score: 500 },
+    { strategy: 'text', source: 'parent', score: 450 },
+    { strategy: 'text', source: 'ancestor', score: 400 },
+    { strategy: 'role', source: 'target', score: 750 },
+    { strategy: 'role', source: 'sibling', score: 710 },
+    { strategy: 'role', source: 'parent', score: 660 },
+    { strategy: 'role', source: 'ancestor', score: 610 },
+    { strategy: 'dataAttribute', attrName: 'data-section', score: 625 },
+    { strategy: 'dataAttribute', attrName: 'data-page', score: 620 },
+    { strategy: 'dataAttribute', attrName: 'data-component', score: 615 },
+    { strategy: 'dataAttribute', score: 600 },
+    { strategy: 'label', attrName: 'aria-labelledby', score: 575 },
+    { strategy: 'label', attrName: 'title', score: 550 },
+    { strategy: 'label', score: 570 },
+    { strategy: 'placeholder', score: 565 },
+    { strategy: 'altText', score: 563 },
+    { strategy: 'title', score: 562 },
+    { strategy: 'class', score: 500 },
+    { strategy: 'css', score: 400 },
+    { strategy: 'xpath', score: 300 }
+];
+function getPriorityScore(c) {
+    const isIdAttr = c.attrName && /id/i.test(c.attrName);
+    for (const rule of exports.priorityRankingRules) {
+        if (rule.strategy !== c.strategy)
+            continue;
+        if (rule.source && rule.source !== c.source)
+            continue;
+        if (rule.roleVal && rule.roleVal !== c.roleVal)
+            continue;
+        if (rule.attrName) {
+            if (typeof rule.attrName === 'string') {
+                if (rule.attrName !== c.attrName)
+                    continue;
+            }
+            else {
+                const nameToTest = isIdAttr ? 'id' : (c.attrName || '');
+                if (!rule.attrName.test(nameToTest))
+                    continue;
+            }
+        }
+        return rule.score;
+    }
+    return 100; // default CSS
+}

package/dist/codegen/scorer/semantic-score.d.ts

@@ -0,0 +1 @@
+export declare function getSemanticScore(value: string | null): number;

package/dist/codegen/scorer/semantic-score.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSemanticScore = getSemanticScore;
+function getSemanticScore(value) {
+    if (!value)
+        return 0;
+    let score = 0;
+    // Hyphenated values are intentional naming (e.g. "why-pw-core", "page-registry")
+    if (value.includes('-'))
+        score += 10;
+    // Longer values are more descriptive
+    if (value.length > 5)
+        score += 5;
+    if (value.length > 10)
+        score += 5;
+    // Exclude purely numeric or long random sequences
+    if (!/\d{4,}/.test(value))
+        score += 10;
+    // Pure words (no digits) are more semantic
+    if (/^[a-zA-Z-_]+$/.test(value))
+        score += 5;
+    // Penalize extremely short generic values
+    if (value.length <= 3)
+        score -= 15;
+    // Penalize single-word utility-like values (e.g. "flex", "block", "hidden")
+    const utilityNames = [
+        'flex', 'grid', 'block', 'inline', 'hidden', 'visible', 'relative', 'absolute',
+        'fixed', 'sticky', 'static', 'auto', 'none', 'inherit', 'initial', 'unset',
+        'revert', 'polyline', 'svg', 'path', 'circle', 'rect', 'div', 'span', 'section',
+        'article', 'main', 'header', 'footer', 'nav', 'aside', 'tbody', 'thead', 'tr',
+        'td', 'th'
+    ];
+    if (utilityNames.includes(value.toLowerCase()))
+        score -= 30;
+    // Penalize CSS utility-pattern values (e.g. transition-all, border-0, shadow-lg)
+    const utilityPatterns = [
+        /^transition-/, /^transform-/, /^duration-/, /^ease-/, /^delay-/, /^animate-/,
+        /^shadow-/, /^opacity-/, /^blur-/, /^scale-/, /^translate-/, /^rotate-/,
+        /^skew-/, /^origin-/, /^border-/, /^rounded-/, /^ring-/, /^outline-/, /^bg-/,
+        /^text-/, /^font-/, /^leading-/, /^tracking-/, /^w-/, /^h-/, /^min-/, /^max-/,
+        /^gap-/, /^space-/, /^m[tblrxy]?-/, /^p[tblrxy]?-/, /^col-/, /^row-/, /^grid-/,
+        /^flex-/, /^z-/, /^inset-/, /^top-/, /^right-/, /^bottom-/, /^left-/
+    ];
+    if (utilityPatterns.some((p) => p.test(value)))
+        score -= 25;
+    return score;
+}

package/dist/codegen/types.d.ts

@@ -0,0 +1,35 @@
+export interface DOMContext {
+    parentText?: string;
+    siblingText?: string;
+    nearbyHeading?: string;
+    accessibleName?: string;
+    parentAttributes?: Record<string, string>;
+    siblingAttributes?: Record<string, string>;
+}
+export interface Candidate {
+    selector: string;
+    source: 'target' | 'child' | 'sibling' | 'parent' | 'ancestor';
+    strategy: string;
+    depth: number;
+    baseScore: number;
+    semanticScore: number;
+    proximityScore: number;
+    similarityScore: number;
+    uniquenessScore: number;
+    totalScore: number;
+    unique: boolean;
+    valueToScore?: string;
+}
+export interface LocatorCandidate extends Candidate {
+    locator: string;
+    contextScore: number;
+    nearbyText?: string;
+    parentText?: string;
+    accessibleName?: string;
+    generatedKey?: string;
+}
+export interface LocatorStrategy {
+    name: string;
+    matches(element: Element): boolean;
+    build(element: Element): LocatorCandidate | null;
+}

package/dist/codegen/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/component/table.js

@@ -20,15 +20,15 @@ class TableRows extends Array {
             return this[0] ? this[0][key] : undefined;
         }
         // Return the first matching row
-        return this.find(row => row[key] === value);
+        return this.find((row) => row[key] === value);
     }
     getAll(key, value) {
         if (arguments.length === 1) {
             // Return the values of the key from all rows
-            return this.map(row => row[key]);
+            return this.map((row) => row[key]);
         }
         // Return all matching rows
-        return this.filter(row => row[key] === value);
+        return this.filter((row) => row[key] === value);
     }
 }
 exports.TableRows = TableRows;
@@ -42,7 +42,9 @@ class Table {
      */
     async getHeaders() {
         return test_1.test.step(`Get headers of table`, async () => {
-            const headers = await this.root.locator('th').evaluateAll(ths => ths.map(th => th.textContent?.trim().toLowerCase() || ''));
+            const headers = await this.root
+                .locator('th')
+                .evaluateAll((ths) => ths.map((th) => th.textContent?.trim().toLowerCase() || ''));
             return headers;
         }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
     }
@@ -53,9 +55,11 @@ class Table {
     async getRows() {
         return test_1.test.step('Get table rows', async () => {
             const headers = await this.getHeaders();
-            const rowsData = await this.root.locator('tbody tr, tr[data-testid="transaction-row"]').evaluateAll((trs, headers) => {
-                return trs.map(tr => {
-                    const cells = Array.from(tr.querySelectorAll('td')).map(td => td.textContent?.trim() || '');
+            const rowsData = await this.root
+                .locator('tbody tr, tr[data-testid="transaction-row"]')
+                .evaluateAll((trs, headers) => {
+                return trs.map((tr) => {
+                    const cells = Array.from(tr.querySelectorAll('td')).map((td) => td.textContent?.trim() || '');
                     if (cells.length === 0)
                         return null; // Skip header or empty rows
                     const rowData = {};
@@ -83,8 +87,8 @@ class Table {
      */
     async getRowCount() {
         return test_1.test.step('Get table row count', async () => {
-            return await this.root.locator('tbody tr, tr[data-testid="transaction-row"]').evaluateAll(trs => {
-                return trs.filter(tr => tr.querySelectorAll('td').length > 0).length;
+            return await this.root.locator('tbody tr, tr[data-testid="transaction-row"]').evaluateAll((trs) => {
+                return trs.filter((tr) => tr.querySelectorAll('td').length > 0).length;
             });
         }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
     }
@@ -100,7 +104,7 @@ class Table {
             }
             return await this.root.evaluate((tableEl, { rowIndex, columnIndex }) => {
                 const trs = Array.from(tableEl.querySelectorAll('tbody tr, tr[data-testid="transaction-row"]'));
-                const dataRows = trs.filter(tr => tr.querySelectorAll('td').length > 0);
+                const dataRows = trs.filter((tr) => tr.querySelectorAll('td').length > 0);
                 if (rowIndex < 0 || rowIndex >= dataRows.length) {
                     throw new Error(`Row index ${rowIndex} is out of bounds (0 to ${dataRows.length - 1})`);
                 }

package/dist/constants/methods.d.ts

@@ -0,0 +1,2 @@
+export declare const zeroArgMethodsList: readonly ["click", "dblclick", "hover", "focus", "blur", "check", "uncheck", "clear", "waitFor", "isChecked", "isDisabled", "isVisible", "textContent", "innerText", "allInnerTexts", "allTextContents", "count", "scrollIntoViewIfNeeded", "boundingBox"];
+export declare const oneArgMethodsList: readonly ["fill", "press", "pressSequentially", "selectOption", "setInputFiles", "getAttribute", "dragTo"];

package/dist/constants/methods.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oneArgMethodsList = exports.zeroArgMethodsList = void 0;
+exports.zeroArgMethodsList = [
+    'click',
+    'dblclick',
+    'hover',
+    'focus',
+    'blur',
+    'check',
+    'uncheck',
+    'clear',
+    'waitFor',
+    'isChecked',
+    'isDisabled',
+    'isVisible',
+    'textContent',
+    'innerText',
+    'allInnerTexts',
+    'allTextContents',
+    'count',
+    'scrollIntoViewIfNeeded',
+    'boundingBox'
+];
+exports.oneArgMethodsList = [
+    'fill',
+    'press',
+    'pressSequentially',
+    'selectOption',
+    'setInputFiles',
+    'getAttribute',
+    'dragTo'
+];

package/dist/constants/strategies.d.ts

@@ -0,0 +1,2 @@
+export declare const rolesList: readonly ["button", "checkbox", "radio", "heading", "link", "dialog", "list", "listbox", "textbox", "menu", "menuitem", "option", "row", "cell", "tab", "tabpanel", "grid", "gridcell", "combobox", "switch", "progressbar", "status", "tooltip", "tree", "treeitem", "article", "banner", "navigation", "main", "form", "region", "searchbox"];
+export declare const strategyList: readonly ["testId", "selector", "text", "label", "title", "placeholder", "altText", "button", "checkbox", "radio", "heading", "link", "dialog", "list", "listbox", "textbox", "menu", "menuitem", "option", "row", "cell", "tab", "tabpanel", "grid", "gridcell", "combobox", "switch", "progressbar", "status", "tooltip", "tree", "treeitem", "article", "banner", "navigation", "main", "form", "region", "searchbox"];

package/dist/constants/strategies.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.strategyList = exports.rolesList = void 0;
+exports.rolesList = [
+    'button',
+    'checkbox',
+    'radio',
+    'heading',
+    'link',
+    'dialog',
+    'list',
+    'listbox',
+    'textbox',
+    'menu',
+    'menuitem',
+    'option',
+    'row',
+    'cell',
+    'tab',
+    'tabpanel',
+    'grid',
+    'gridcell',
+    'combobox',
+    'switch',
+    'progressbar',
+    'status',
+    'tooltip',
+    'tree',
+    'treeitem',
+    'article',
+    'banner',
+    'navigation',
+    'main',
+    'form',
+    'region',
+    'searchbox'
+];
+exports.strategyList = [
+    'testId',
+    'selector',
+    'text',
+    'label',
+    'title',
+    'placeholder',
+    'altText',
+    ...exports.rolesList
+];

package/dist/page/actions/locator-actions.js

@@ -23,7 +23,13 @@ function executeAction(prop, resolveLocatorFn, timeout, args) {
         }
     }
     const isCount = prop === 'count';
-    const locator = resolveLocatorFn(locatorKey, { nth: optNth, hasText: optHasText, raw: isCount });
+    const userOptions = optionsIndex !== -1 && methodArgs.length > optionsIndex ? methodArgs[optionsIndex] : undefined;
+    const locator = resolveLocatorFn(locatorKey, {
+        nth: optNth,
+        hasText: optHasText,
+        raw: isCount,
+        ...userOptions
+    });
     const method = locator[prop];
     if (typeof method !== 'function') {
         throw new Error(`Property '${prop}' does not exist on Locator.`);
@@ -31,6 +37,13 @@ function executeAction(prop, resolveLocatorFn, timeout, args) {
     if (prop === 'dragTo' && methodArgs.length > 0) {
         methodArgs[0] = resolveLocatorFn(methodArgs[0]);
     }
+    if (optionsIndex !== -1 && methodArgs.length > optionsIndex) {
+        const opts = methodArgs[optionsIndex];
+        if (opts && typeof opts === 'object') {
+            const { exact, checked, disabled, expanded, includeHidden, level, pressed, selected, ...rest } = opts;
+            methodArgs[optionsIndex] = rest;
+        }
+    }
     if (timeout !== undefined) {
         if (optionsIndex !== -1) {
             while (methodArgs.length < optionsIndex) {
@@ -65,9 +78,7 @@ function executeAction(prop, resolveLocatorFn, timeout, args) {
             await locator.focus();
             await locator.evaluate((el, val) => {
                 const inputEl = el;
-                const prototype = el.tagName === 'TEXTAREA'
-                    ? window.HTMLTextAreaElement.prototype
-                    : window.HTMLInputElement.prototype;
+                const prototype = el.tagName === 'TEXTAREA' ? window.HTMLTextAreaElement.prototype : window.HTMLInputElement.prototype;
                 const descriptor = Object.getOwnPropertyDescriptor(prototype, 'value');
                 if (descriptor && descriptor.set) {
                     descriptor.set.call(inputEl, val);