pw-core 1.1.0 → 1.2.1

package/dist/page/config.js

@@ -1,45 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.oneArgMethodsList = exports.zeroArgMethodsList = void 0;
+exports.strategyList = exports.rolesList = exports.oneArgMethodsList = exports.zeroArgMethodsList = void 0;
 exports.getOptionsArgumentIndex = getOptionsArgumentIndex;
 exports.createPageConfig = createPageConfig;
-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'
-];
+const methods_1 = require("../constants/methods");
+var methods_2 = require("../constants/methods");
+Object.defineProperty(exports, "zeroArgMethodsList", { enumerable: true, get: function () { return methods_2.zeroArgMethodsList; } });
+Object.defineProperty(exports, "oneArgMethodsList", { enumerable: true, get: function () { return methods_2.oneArgMethodsList; } });
+var strategies_1 = require("../constants/strategies");
+Object.defineProperty(exports, "rolesList", { enumerable: true, get: function () { return strategies_1.rolesList; } });
+Object.defineProperty(exports, "strategyList", { enumerable: true, get: function () { return strategies_1.strategyList; } });
 function getOptionsArgumentIndex(methodName) {
-    if (exports.zeroArgMethodsList.includes(methodName))
+    if (methods_1.zeroArgMethodsList.includes(methodName))
         return 0;
-    if (exports.oneArgMethodsList.includes(methodName))
+    if (methods_1.oneArgMethodsList.includes(methodName))
         return 1;
     return -1;
 }
 /**
  * Creates a strongly-typed page configuration object containing URLs, testIds, and CSS selectors.
- *
- * @example
- * ```ts
- * import { createPageConfig } from 'pw-core/page';
- *
- * const config = createPageConfig({
- *   url: '/login',
- *   testIds: {
- *     username: 'username-input',
- *     password: 'password-input',
- *     submitBtn: 'login-button',
- *   },
- *   selectors: {
- *     errorAlert: '.alert-danger',
- *   }
- * });
- * ```
  */
 function createPageConfig(config) {
     return config;

package/dist/page/index.d.ts

@@ -5,6 +5,7 @@ export * from './assertions/verify-helpers';
 export * from './assertions/expect';
 export * from './actions/page-actions';
 export * from './actions/locator-actions';
+export * from './locators/dynamic-locator-resolver';
 export * from './locators/resolver';
 export * from './typed-page';
 export * from './registry';

package/dist/page/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./assertions/verify-helpers"), exports);
 __exportStar(require("./assertions/expect"), exports);
 __exportStar(require("./actions/page-actions"), exports);
 __exportStar(require("./actions/locator-actions"), exports);
+__exportStar(require("./locators/dynamic-locator-resolver"), exports);
 __exportStar(require("./locators/resolver"), exports);
 __exportStar(require("./typed-page"), exports);
 __exportStar(require("./registry"), exports);

package/dist/page/locators/dynamic-locator-resolver.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Dynamic locator resolver — expands `{placeholder}` patterns in testId keys
+ * into all value combinations at runtime.
+ *
+ * @example
+ * ```ts
+ * const testIds = {
+ *   staticKey: 'static-test-id',
+ *   "{status}{id}Chart": {
+ *     id: ['line', 'bar'],
+ *     status: ['active', 'inactive'],
+ *     testId: "status-id-chart"
+ *   }
+ * };
+ *
+ * expandDynamicLocators(testIds);
+ * // => {
+ * //   staticKey: 'static-test-id',
+ * //   activeLineChart:    'active-line-chart',
+ * //   activeBarChart:     'active-bar-chart',
+ * //   inactiveLineChart:  'inactive-line-chart',
+ * //   inactiveBarChart:   'inactive-bar-chart'
+ * // }
+ * ```
+ */
+/**
+ * Shape of a dynamic testId entry.
+ *
+ * `testId` — the test-id pattern with placeholder *names* as literal substrings.
+ * Every other property is a placeholder name mapped to its list of allowed values.
+ */
+export type DynamicTestIdEntry = {
+    testId?: string;
+    [placeholder: string]: string | readonly string[] | undefined;
+};
+export type DynamicSelectorEntry = {
+    selector?: string;
+    [placeholder: string]: string | readonly string[] | undefined;
+};
+export type DynamicLocatorEntry = DynamicTestIdEntry | DynamicSelectorEntry;
+/** Returns true when `key` contains at least one `{…}` placeholder. */
+export declare function isDynamicKey(key: string): boolean;
+/**
+ * Expands all dynamic entries in a `testIds` map into a flat `key → testId` map.
+ * Static (string-valued) entries pass through unchanged.
+ */
+export declare function expandDynamicLocators(testIds: Record<string, string | DynamicLocatorEntry>): Record<string, string>;
+/** Return the expanded (flat) testIds map, caching the result per config object. */
+export declare function getExpandedTestIds(testIds: Record<string, string | DynamicLocatorEntry>): Record<string, string>;

package/dist/page/locators/dynamic-locator-resolver.js

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * Dynamic locator resolver — expands `{placeholder}` patterns in testId keys
+ * into all value combinations at runtime.
+ *
+ * @example
+ * ```ts
+ * const testIds = {
+ *   staticKey: 'static-test-id',
+ *   "{status}{id}Chart": {
+ *     id: ['line', 'bar'],
+ *     status: ['active', 'inactive'],
+ *     testId: "status-id-chart"
+ *   }
+ * };
+ *
+ * expandDynamicLocators(testIds);
+ * // => {
+ * //   staticKey: 'static-test-id',
+ * //   activeLineChart:    'active-line-chart',
+ * //   activeBarChart:     'active-bar-chart',
+ * //   inactiveLineChart:  'inactive-line-chart',
+ * //   inactiveBarChart:   'inactive-bar-chart'
+ * // }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDynamicKey = isDynamicKey;
+exports.expandDynamicLocators = expandDynamicLocators;
+exports.getExpandedTestIds = getExpandedTestIds;
+/** Returns true when `key` contains at least one `{…}` placeholder. */
+function isDynamicKey(key) {
+    return /\{[^}]+\}/.test(key);
+}
+/**
+ * Capitalize the first character of a string.
+ * @internal
+ */
+function capitalize(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+/**
+ * Compute the cartesian product of an array-of-arrays.
+ *
+ * @example cartesianProduct([['a','b'],['1','2']]) // [['a','1'],['a','2'],['b','1'],['b','2']]
+ * @internal
+ */
+function cartesianProduct(arrays) {
+    if (arrays.length === 0)
+        return [[]];
+    return arrays.reduce((acc, arr) => acc.flatMap((combo) => arr.map((val) => [...combo, val])), [[]]);
+}
+/**
+ * Extract placeholder names from a pattern like `"{status}{id}Chart"`.
+ * @internal
+ */
+function extractPlaceholders(pattern) {
+    const names = [];
+    const re = /\{([^}]+)\}/g;
+    let m;
+    while ((m = re.exec(pattern)) !== null) {
+        names.push(m[1]);
+    }
+    return names;
+}
+/**
+ * Expand a single dynamic key pattern + entry into flat key → locator-value pairs.
+ * Validates the entry at runtime before expansion.
+ * @internal
+ */
+function expandSingleDynamic(pattern, entry) {
+    const testIdPattern = entry.testId;
+    const selectorPattern = entry.selector;
+    const targetPattern = (testIdPattern !== undefined ? testIdPattern : selectorPattern);
+    const targetKey = testIdPattern !== undefined ? 'testId' : 'selector';
+    if (targetPattern === undefined) {
+        throw new Error(`Dynamic locator "${pattern}": entry must contain either 'testId' or 'selector' property.`);
+    }
+    const placeholders = { ...entry };
+    delete placeholders.testId;
+    delete placeholders.selector;
+    // ─── Validation ──────────────────────────────────────────────────────
+    const expectedNames = extractPlaceholders(pattern);
+    // 0.5. No duplicate placeholders in the pattern
+    const uniqueNames = Array.from(new Set(expectedNames));
+    if (uniqueNames.length !== expectedNames.length) {
+        throw new Error(`Dynamic locator "${pattern}": pattern has duplicate placeholders.`);
+    }
+    // 1. No unknown keys (only placeholder names + targetKey)
+    const actualKeys = Object.keys(placeholders);
+    const unknownKeys = actualKeys.filter((k) => !expectedNames.includes(k));
+    if (unknownKeys.length > 0) {
+        throw new Error(`Dynamic locator "${pattern}": unknown key(s) [${unknownKeys.join(', ')}]. ` +
+            `Only '${targetKey}' and placeholder keys [${expectedNames.join(', ')}] are allowed.`);
+    }
+    // 2. All placeholders from the pattern must have a key in the entry
+    const missingKeys = expectedNames.filter((name) => !(name in placeholders));
+    if (missingKeys.length > 0) {
+        throw new Error(`Dynamic locator "${pattern}": missing placeholder key(s) [${missingKeys.join(', ')}]. ` +
+            `You must provide values for all placeholders defined in the pattern.`);
+    }
+    // 2.5. Placeholder values must be arrays
+    const nonArrayKeys = expectedNames.filter((name) => !Array.isArray(placeholders[name]));
+    if (nonArrayKeys.length > 0) {
+        throw new Error(`Dynamic locator "${pattern}": placeholder key(s) [${nonArrayKeys.join(', ')}] must be arrays.`);
+    }
+    // 3. All placeholder names must appear as substrings in the target pattern value
+    const missingInPattern = expectedNames.filter((name) => !targetPattern.includes(name));
+    if (missingInPattern.length > 0) {
+        throw new Error(`Dynamic locator "${pattern}": ${targetKey} "${targetPattern}" does not contain ` +
+            `placeholder name(s) [${missingInPattern.join(', ')}]. ` +
+            `All placeholder names must appear in the ${targetKey} so they can be replaced at runtime.`);
+    }
+    // ─── Expansion ───────────────────────────────────────────────────────
+    // Sort placeholder names longest-first to avoid substring replacement issues
+    const names = Object.keys(placeholders).sort((a, b) => b.length - a.length);
+    const values = names.map((name) => {
+        const v = placeholders[name];
+        return v;
+    });
+    const result = {};
+    for (const combo of cartesianProduct(values)) {
+        // Build the *key* — replace {name} with Capitalize(value), then uncapitalize the first char
+        let expandedKey = pattern;
+        let expandedValue = targetPattern;
+        const isPurePlaceholder = pattern === `{${names[0]}}` && names.length === 1;
+        for (let i = 0; i < names.length; i++) {
+            const name = names[i];
+            const val = combo[i];
+            let capValue = '';
+            if (isPurePlaceholder) {
+                capValue = val;
+            }
+            else {
+                const words = val.split(/[^a-zA-Z0-9]/).filter(Boolean);
+                capValue = words.map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join('');
+            }
+            expandedKey = expandedKey.replace(`{${name}}`, capValue);
+            const replacement = targetKey === 'selector' ? val : val.toLowerCase();
+            expandedValue = expandedValue.replaceAll(`{${name}}`, replacement);
+            expandedValue = expandedValue.replaceAll(name, replacement);
+        }
+        // camelCase: uncapitalize the first character
+        expandedKey = expandedKey.charAt(0).toLowerCase() + expandedKey.slice(1);
+        result[expandedKey] = expandedValue;
+    }
+    return result;
+}
+/**
+ * Expands all dynamic entries in a `testIds` map into a flat `key → testId` map.
+ * Static (string-valued) entries pass through unchanged.
+ */
+function expandDynamicLocators(testIds) {
+    const result = {};
+    for (const [key, value] of Object.entries(testIds)) {
+        if (typeof value === 'string') {
+            if (key in result) {
+                throw new Error(`Duplicate key "${key}" defined in page object configuration.`);
+            }
+            result[key] = value;
+        }
+        else {
+            const expanded = expandSingleDynamic(key, value);
+            for (const k of Object.keys(expanded)) {
+                if (k in result) {
+                    throw new Error(`Duplicate key "${k}" defined in page object configuration.`);
+                }
+                result[k] = expanded[k];
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Cached expansion — avoids re-expanding the same config on every action call.
+ * @internal
+ */
+const expandedCache = new WeakMap();
+/** Return the expanded (flat) testIds map, caching the result per config object. */
+function getExpandedTestIds(testIds) {
+    let expanded = expandedCache.get(testIds);
+    if (!expanded) {
+        expanded = expandDynamicLocators(testIds);
+        expandedCache.set(testIds, expanded);
+    }
+    return expanded;
+}

package/dist/page/locators/resolver.d.ts

@@ -1,24 +1,25 @@
 import { Page, Locator } from '@playwright/test';
-import { ChainedKeys, PageKeys } from '../config';
-export declare function defineLocators<T extends {
-    testIds?: Record<string, string>;
-    selectors?: Record<string, string>;
-}>(instance: any, context: Page | Locator, config: T): void;
-export declare function resolveLocator<T extends {
-    testIds?: Record<string, string>;
-    selectors?: Record<string, string>;
-}>(context: Page | Locator, config: T, target: PageKeys<T> | ChainedKeys<T> | Locator, options?: {
+export declare const locatorStrategies: Record<string, {
+    resolver: string;
+    role?: string;
+}>;
+export interface LocatorMetadata {
+    strategy: string;
+    value: any;
+}
+export declare function cleanKey(s: string): string;
+export declare const lookupIndexCache: WeakMap<object, Map<string, LocatorMetadata>>;
+export declare function buildLookupIndex(config: any): Map<string, LocatorMetadata>;
+export declare function defineLocators(instance: any, context: Page | Locator, config: any): void;
+export declare function resolveLocator(context: Page | Locator, config: any, target: any, options?: {
     nth?: number;
     raw?: boolean;
     hasText?: string | RegExp;
-}): Locator;
+} & Record<string, any>): Locator;
 /**
  * Resolve a config key to a proxied Locator with step-wrapped Playwright methods.
  */
-export declare function locator<T extends {
-    testIds?: Record<string, string>;
-    selectors?: Record<string, string>;
-}>(context: Page | Locator, config: T, target: PageKeys<T> | ChainedKeys<T> | Locator, options?: Parameters<Locator['filter']>[0] & {
+export declare function locator(context: Page | Locator, config: any, target: any, options?: Parameters<Locator['filter']>[0] & {
     nth?: number;
 }): Locator;
 export declare function wrapLocatorWithProxy(loc: Locator): Locator;

package/dist/page/locators/resolver.js

@@ -1,5 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookupIndexCache = exports.locatorStrategies = void 0;
+exports.cleanKey = cleanKey;
+exports.buildLookupIndex = buildLookupIndex;
 exports.defineLocators = defineLocators;
 exports.resolveLocator = resolveLocator;
 exports.locator = locator;
@@ -7,47 +10,164 @@ exports.wrapLocatorWithProxy = wrapLocatorWithProxy;
 const test_1 = require("@playwright/test");
 const config_1 = require("../config");
 const formatter_1 = require("../utils/formatter");
-function defineLocators(instance, context, config) {
-    if (config.testIds) {
-        for (const key of Object.keys(config.testIds)) {
-            Object.defineProperty(instance, key, {
-                get: () => {
-                    return context.getByTestId(config.testIds[key]);
-                },
-                enumerable: true,
-                configurable: true,
-            });
+const dynamic_locator_resolver_1 = require("./dynamic-locator-resolver");
+const caller_location_1 = require("../utils/caller-location");
+exports.locatorStrategies = {
+    testId: { resolver: 'getByTestId' },
+    selector: { resolver: 'locator' },
+    text: { resolver: 'getByText' },
+    label: { resolver: 'getByLabel' },
+    title: { resolver: 'getByTitle' },
+    placeholder: { resolver: 'getByPlaceholder' },
+    altText: { resolver: 'getByAltText' }
+};
+// Add all roles dynamically
+for (const role of config_1.rolesList) {
+    exports.locatorStrategies[role] = { resolver: 'getByRole', role };
+}
+function cleanKey(s) {
+    let clean = s;
+    const suffixes = ['Btn', 'Button', 'Link', 'Input', 'Checkbox', 'Option', 'Title', 'Label', 'Value', 'Text', 'Wrapper', 'Container', 'Card', 'Item'];
+    for (const suffix of suffixes) {
+        clean = clean.replace(new RegExp(`[-_]?${suffix}$`, 'i'), '');
+    }
+    clean = clean.replace(/[^a-zA-Z0-9]/g, '').toLowerCase();
+    clean = clean.replace(/^\d+/, '').replace(/\d+$/, '');
+    return clean;
+}
+exports.lookupIndexCache = new WeakMap();
+function buildLookupIndex(config) {
+    const index = new Map();
+    const seenInStrategies = new Map();
+    const addKey = (key, strategy, value) => {
+        const cleanedKey = cleanKey(key);
+        if (seenInStrategies.has(cleanedKey)) {
+            const existing = seenInStrategies.get(cleanedKey);
+            if (!existing.includes(strategy)) {
+                existing.push(strategy);
+            }
+        }
+        else {
+            seenInStrategies.set(cleanedKey, [strategy]);
+        }
+        index.set(cleanedKey, { strategy, value });
+    };
+    // 1. Process testId / testIds (backward compatibility)
+    const testIdConfig = config.testId || config.testIds;
+    if (testIdConfig) {
+        const expanded = (0, dynamic_locator_resolver_1.getExpandedTestIds)(testIdConfig);
+        for (const key of Object.keys(expanded)) {
+            addKey(key, 'testId', expanded[key]);
+        }
+    }
+    // 2. Process selector / selectors (backward compatibility)
+    const selectorConfig = config.selector || config.selectors;
+    if (selectorConfig) {
+        const expanded = (0, dynamic_locator_resolver_1.getExpandedTestIds)(selectorConfig);
+        for (const key of Object.keys(expanded)) {
+            addKey(key, 'selector', expanded[key]);
         }
     }
-    if (config.selectors) {
-        for (const key of Object.keys(config.selectors)) {
-            Object.defineProperty(instance, key, {
-                get: () => {
-                    return context.locator(config.selectors[key]);
-                },
-                enumerable: true,
-                configurable: true,
-            });
+    // 3. Process all other strategies
+    for (const strategy of config_1.strategyList) {
+        if (strategy === 'testId' || strategy === 'selector')
+            continue;
+        const items = config[strategy];
+        if (Array.isArray(items)) {
+            for (const item of items) {
+                if (typeof item === 'string') {
+                    addKey(item, strategy, item);
+                }
+            }
         }
     }
+    // 4. Duplicate Check & Validation
+    for (const [key, strategies] of seenInStrategies.entries()) {
+        if (strategies.length > 1) {
+            throw new Error(`Duplicate locator value "${key}"\n\nFound in\n\n${strategies.join('\n\n')}\n\nLocator values must be globally unique.`);
+        }
+    }
+    return index;
+}
+function defineLocators(instance, context, config) {
+    let index = exports.lookupIndexCache.get(config);
+    if (!index) {
+        index = buildLookupIndex(config);
+        exports.lookupIndexCache.set(config, index);
+    }
+    for (const key of index.keys()) {
+        Object.defineProperty(instance, key, {
+            get: () => {
+                return resolveLocator(context, config, key);
+            },
+            enumerable: true,
+            configurable: true
+        });
+    }
 }
 function resolveLocator(context, config, target, options) {
     if (typeof target !== 'string')
         return target;
     const targetStr = target;
-    const parts = targetStr.split('.');
+    let index = exports.lookupIndexCache.get(config);
+    if (!index) {
+        index = buildLookupIndex(config);
+        exports.lookupIndexCache.set(config, index);
+    }
+    const toRegex = (val) => {
+        const escaped = val.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+        return new RegExp(escaped.replace(/\s+/g, '\\s+'), 'i');
+    };
     const resolveSingle = (key, ctx) => {
-        if (config.testIds && key in config.testIds) {
-            return ctx.getByTestId(config.testIds[key]);
+        const cleaned = cleanKey(key);
+        const meta = index.get(cleaned);
+        if (!meta) {
+            throw new Error(`Locator key '${key}' is not defined in page object configuration.`);
+        }
+        const strategy = exports.locatorStrategies[meta.strategy];
+        if (!strategy) {
+            throw new Error(`Unknown locator strategy '${meta.strategy}' for key '${key}'.`);
         }
-        if (config.selectors && key in config.selectors) {
-            return ctx.locator(config.selectors[key]);
+        const { resolver, role } = strategy;
+        if (resolver === 'getByRole') {
+            const val = typeof meta.value === 'string' ? toRegex(meta.value) : meta.value;
+            const roleOptions = { name: val };
+            if (options) {
+                const allowedOptions = ['exact', 'checked', 'disabled', 'expanded', 'includeHidden', 'level', 'pressed', 'selected'];
+                for (const opt of allowedOptions) {
+                    if (opt in options) {
+                        roleOptions[opt] = options[opt];
+                    }
+                }
+            }
+            return ctx[resolver](role, roleOptions);
+        }
+        else if (resolver === 'locator') {
+            return ctx[resolver](meta.value);
+        }
+        else {
+            const opt = {};
+            if (options && 'exact' in options) {
+                opt.exact = options.exact;
+            }
+            const val = typeof meta.value === 'string' ? toRegex(meta.value) : meta.value;
+            return ctx[resolver](val, opt);
         }
-        throw new Error(`Locator key '${key}' is not defined in testIds or selectors.`);
     };
-    let loc = resolveSingle(parts[0], context);
-    for (let i = 1; i < parts.length; i++) {
-        loc = resolveSingle(parts[i], loc);
+    let loc;
+    const cleanedTarget = cleanKey(targetStr);
+    if (index.has(cleanedTarget)) {
+        loc = resolveSingle(targetStr, context);
+    }
+    else if (targetStr.includes('.')) {
+        const parts = targetStr.split('.');
+        loc = resolveSingle(parts[0], context);
+        for (let i = 1; i < parts.length; i++) {
+            loc = resolveSingle(parts[i], loc);
+        }
+    }
+    else {
+        loc = resolveSingle(targetStr, context);
     }
     let resolved = loc;
     if (options?.hasText !== undefined) {
@@ -67,7 +187,9 @@ function resolveLocator(context, config, target, options) {
 function locator(context, config, target, options) {
     const resolved = resolveLocator(context, config, target, { raw: true });
     const filtered = options ? resolved.filter(options) : resolved;
-    const loc = (options && typeof options === 'object' && 'nth' in options && options.nth !== undefined) ? filtered.nth(options.nth) : filtered;
+    const loc = options && typeof options === 'object' && 'nth' in options && options.nth !== undefined
+        ? filtered.nth(options.nth)
+        : filtered;
     return wrapLocatorWithProxy(loc);
 }
 function wrapLocatorWithProxy(loc) {
@@ -78,7 +200,42 @@ function wrapLocatorWithProxy(loc) {
             if (typeof val === 'function' && actionMethods.includes(propKey)) {
                 return (...args) => {
                     const stepName = (0, formatter_1.formatStepDescription)(propKey, targetLoc, args);
-                    return test_1.test.step(stepName, () => val.apply(targetLoc, args));
+                    if (propKey === 'fill') {
+                        const options = args[1];
+                        let shouldMask = false;
+                        if (options && typeof options === 'object' && options.mask !== undefined) {
+                            shouldMask = options.mask === true;
+                        }
+                        else {
+                            const targetStr = (0, formatter_1.formatTarget)(targetLoc);
+                            const targetStrLower = targetStr.toLowerCase();
+                            shouldMask = targetStrLower.includes('pass') || targetStrLower.includes('pw');
+                        }
+                        if (shouldMask) {
+                            return test_1.test.step(stepName, async () => {
+                                await targetLoc.focus();
+                                await targetLoc.evaluate((el, val) => {
+                                    const inputEl = el;
+                                    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);
+                                    }
+                                    else {
+                                        inputEl.value = val;
+                                    }
+                                    inputEl.dispatchEvent(new Event('input', { bubbles: true }));
+                                    inputEl.dispatchEvent(new Event('change', { bubbles: true }));
+                                }, args[0]);
+                            }, { box: true, location: (0, caller_location_1.getCallerLocation)() });
+                        }
+                    }
+                    return test_1.test.step(stepName, () => val.apply(targetLoc, args), {
+                        box: true,
+                        location: (0, caller_location_1.getCallerLocation)()
+                    });
                 };
             }
             return val;