testblocks 0.1.0

package/dist/core/blocks/playwright.js

@@ -0,0 +1,764 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playwrightBlocks = void 0;
+// Import Playwright's expect for assertions with auto-waiting
+// We use dynamic import with string concatenation to prevent Vite from
+// trying to bundle the playwright package (which is Node.js-only)
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let playwrightExpect = null;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function getExpect() {
+    if (!playwrightExpect) {
+        // Use string concatenation to hide import from Vite's static analysis
+        const moduleName = '@playwright' + '/test';
+        const { expect } = await Promise.resolve(`${moduleName}`).then(s => __importStar(require(s)));
+        playwrightExpect = expect;
+    }
+    return playwrightExpect;
+}
+// Playwright Web Testing Blocks
+exports.playwrightBlocks = [
+    // Navigate to URL
+    {
+        type: 'web_navigate',
+        category: 'Web',
+        color: '#E91E63',
+        tooltip: 'Navigate to a URL',
+        inputs: [
+            { name: 'URL', type: 'field', fieldType: 'text', required: true },
+            { name: 'WAIT_UNTIL', type: 'field', fieldType: 'dropdown', options: [['Load', 'load'], ['DOM Content Loaded', 'domcontentloaded'], ['Network Idle', 'networkidle']], default: 'load' },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const url = resolveVariables(params.URL, context);
+            const waitUntil = params.WAIT_UNTIL;
+            context.logger.info(`Navigating to ${url}`);
+            await page.goto(url, { waitUntil });
+            return {
+                _summary: url,
+                url,
+                waitUntil,
+            };
+        },
+    },
+    // Click Element
+    {
+        type: 'web_click',
+        category: 'Web',
+        color: '#E91E63',
+        tooltip: 'Click on an element',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'TIMEOUT', type: 'field', fieldType: 'number', default: 30000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const timeout = params.TIMEOUT;
+            context.logger.info(`Clicking: ${selector}`);
+            await page.click(selector, { timeout });
+            return {
+                _summary: params.SELECTOR,
+                selector,
+            };
+        },
+    },
+    // Fill Input
+    {
+        type: 'web_fill',
+        category: 'Web',
+        color: '#E91E63',
+        tooltip: 'Fill an input field (clears existing value)',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'VALUE', type: 'field', fieldType: 'text', required: true },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const value = resolveVariables(params.VALUE, context);
+            context.logger.info(`Filling ${selector} with "${value}"`);
+            await page.fill(selector, value);
+            const displayValue = value.length > 30 ? value.substring(0, 30) + '...' : value;
+            return {
+                _summary: `${params.SELECTOR} = "${displayValue}"`,
+                selector,
+                value,
+            };
+        },
+    },
+    // Type Text
+    {
+        type: 'web_type',
+        category: 'Web',
+        color: '#E91E63',
+        tooltip: 'Type text character by character',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'TEXT', type: 'field', fieldType: 'text', required: true },
+            { name: 'DELAY', type: 'field', fieldType: 'number', default: 50 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const text = resolveVariables(params.TEXT, context);
+            const delay = params.DELAY;
+            context.logger.info(`Typing "${text}" into ${selector}`);
+            await page.type(selector, text, { delay });
+            const displayText = text.length > 30 ? text.substring(0, 30) + '...' : text;
+            return {
+                _summary: `${params.SELECTOR} = "${displayText}"`,
+                selector,
+                text,
+                delay,
+            };
+        },
+    },
+    // Press Key
+    {
+        type: 'web_press_key',
+        category: 'Web',
+        color: '#E91E63',
+        tooltip: 'Press a keyboard key',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'KEY', type: 'field', fieldType: 'dropdown', options: [['Enter', 'Enter'], ['Tab', 'Tab'], ['Escape', 'Escape'], ['Backspace', 'Backspace'], ['ArrowUp', 'ArrowUp'], ['ArrowDown', 'ArrowDown'], ['ArrowLeft', 'ArrowLeft'], ['ArrowRight', 'ArrowRight']] },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const key = params.KEY;
+            context.logger.info(`Pressing ${key} on ${selector}`);
+            await page.press(selector, key);
+            return {
+                _summary: `${key} on ${params.SELECTOR}`,
+                selector,
+                key,
+            };
+        },
+    },
+    // Select Option
+    {
+        type: 'web_select',
+        category: 'Web',
+        color: '#E91E63',
+        tooltip: 'Select an option from a dropdown',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'VALUE', type: 'field', fieldType: 'text', required: true },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const value = resolveVariables(params.VALUE, context);
+            context.logger.info(`Selecting "${value}" in ${selector}`);
+            await page.selectOption(selector, value);
+            return {
+                _summary: `${params.SELECTOR} = "${value}"`,
+                selector,
+                value,
+            };
+        },
+    },
+    // Check/Uncheck Checkbox
+    {
+        type: 'web_checkbox',
+        category: 'Web',
+        color: '#E91E63',
+        tooltip: 'Check or uncheck a checkbox',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'ACTION', type: 'field', fieldType: 'dropdown', options: [['Check', 'check'], ['Uncheck', 'uncheck']] },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const action = params.ACTION;
+            context.logger.info(`${action === 'check' ? 'Checking' : 'Unchecking'} ${selector}`);
+            if (action === 'check') {
+                await page.check(selector);
+            }
+            else {
+                await page.uncheck(selector);
+            }
+            return {
+                _summary: `${action} ${params.SELECTOR}`,
+                selector,
+                action,
+            };
+        },
+    },
+    // Hover
+    {
+        type: 'web_hover',
+        category: 'Web',
+        color: '#E91E63',
+        tooltip: 'Hover over an element',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            context.logger.info(`Hovering over ${selector}`);
+            await page.hover(selector);
+            return {
+                _summary: params.SELECTOR,
+                selector,
+            };
+        },
+    },
+    // Wait for Element
+    {
+        type: 'web_wait_for_element',
+        category: 'Web',
+        color: '#9C27B0',
+        tooltip: 'Wait for an element to appear/disappear',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'STATE', type: 'field', fieldType: 'dropdown', options: [['Visible', 'visible'], ['Hidden', 'hidden'], ['Attached', 'attached'], ['Detached', 'detached']] },
+            { name: 'TIMEOUT', type: 'field', fieldType: 'number', default: 30000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const state = params.STATE;
+            const timeout = params.TIMEOUT;
+            context.logger.info(`Waiting for ${selector} to be ${state}`);
+            await page.waitForSelector(selector, { state, timeout });
+            return {
+                _summary: `${params.SELECTOR} is ${state}`,
+                selector,
+                state,
+            };
+        },
+    },
+    // Wait for URL
+    {
+        type: 'web_wait_for_url',
+        category: 'Web',
+        color: '#9C27B0',
+        tooltip: 'Wait for URL to match',
+        inputs: [
+            { name: 'URL', type: 'field', fieldType: 'text', required: true },
+            { name: 'TIMEOUT', type: 'field', fieldType: 'number', default: 30000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const url = resolveVariables(params.URL, context);
+            const timeout = params.TIMEOUT;
+            context.logger.info(`Waiting for URL to match: ${url}`);
+            await page.waitForURL(url, { timeout });
+            return {
+                _summary: url,
+                url,
+            };
+        },
+    },
+    // Wait (pause)
+    {
+        type: 'web_wait',
+        category: 'Web',
+        color: '#9C27B0',
+        tooltip: 'Wait for a specified time',
+        inputs: [
+            { name: 'MILLISECONDS', type: 'field', fieldType: 'number', default: 1000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const ms = params.MILLISECONDS;
+            context.logger.info(`Waiting ${ms}ms`);
+            await page.waitForTimeout(ms);
+            return {
+                _summary: `${ms}ms`,
+                milliseconds: ms,
+            };
+        },
+    },
+    // Take Screenshot
+    {
+        type: 'web_screenshot',
+        category: 'Web',
+        color: '#607D8B',
+        tooltip: 'Take a screenshot',
+        inputs: [
+            { name: 'NAME', type: 'field', fieldType: 'text', default: 'screenshot' },
+            { name: 'FULL_PAGE', type: 'field', fieldType: 'checkbox', default: false },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const name = params.NAME;
+            const fullPage = params.FULL_PAGE;
+            context.logger.info(`Taking screenshot: ${name}`);
+            const buffer = await page.screenshot({ fullPage });
+            return {
+                _summary: `${name}${fullPage ? ' (full page)' : ''}`,
+                name,
+                fullPage,
+                buffer: buffer.toString('base64'),
+            };
+        },
+    },
+    // Get Text Content
+    {
+        type: 'web_get_text',
+        category: 'Web',
+        color: '#2196F3',
+        tooltip: 'Get text content of an element',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+        ],
+        output: { type: 'String' },
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const text = await page.textContent(selector);
+            context.logger.debug(`Text content of ${selector}: "${text}"`);
+            const displayText = text && text.length > 40 ? text.substring(0, 40) + '...' : text;
+            return {
+                _summary: `"${displayText}"`,
+                _value: text,
+                selector,
+                text,
+            };
+        },
+    },
+    // Get Attribute
+    {
+        type: 'web_get_attribute',
+        category: 'Web',
+        color: '#2196F3',
+        tooltip: 'Get attribute value of an element',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'ATTRIBUTE', type: 'field', fieldType: 'text', required: true },
+        ],
+        output: { type: 'String' },
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const attribute = params.ATTRIBUTE;
+            const value = await page.getAttribute(selector, attribute);
+            context.logger.debug(`Attribute ${attribute} of ${selector}: "${value}"`);
+            return {
+                _summary: `${attribute} = "${value}"`,
+                _value: value,
+                selector,
+                attribute,
+                value,
+            };
+        },
+    },
+    // Get Input Value
+    {
+        type: 'web_get_input_value',
+        category: 'Web',
+        color: '#2196F3',
+        tooltip: 'Get current value of an input field',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+        ],
+        output: { type: 'String' },
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const value = await page.inputValue(selector);
+            context.logger.debug(`Input value of ${selector}: "${value}"`);
+            const displayValue = value.length > 40 ? value.substring(0, 40) + '...' : value;
+            return {
+                _summary: `"${displayValue}"`,
+                _value: value,
+                selector,
+                value,
+            };
+        },
+    },
+    // Get Page Title
+    {
+        type: 'web_get_title',
+        category: 'Web',
+        color: '#2196F3',
+        tooltip: 'Get the page title',
+        inputs: [],
+        output: { type: 'String' },
+        execute: async (params, context) => {
+            const page = context.page;
+            const title = await page.title();
+            context.logger.debug(`Page title: "${title}"`);
+            return {
+                _summary: `"${title}"`,
+                _value: title,
+                title,
+            };
+        },
+    },
+    // Get Current URL
+    {
+        type: 'web_get_url',
+        category: 'Web',
+        color: '#2196F3',
+        tooltip: 'Get the current URL',
+        inputs: [],
+        output: { type: 'String' },
+        execute: async (params, context) => {
+            const page = context.page;
+            const url = page.url();
+            context.logger.debug(`Current URL: "${url}"`);
+            return {
+                _summary: url,
+                _value: url,
+                url,
+            };
+        },
+    },
+    // Assert Element Visible
+    {
+        type: 'web_assert_visible',
+        category: 'Web',
+        color: '#FF9800',
+        tooltip: 'Assert that an element is visible (auto-waits)',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'TIMEOUT', type: 'field', fieldType: 'number', default: 30000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const displaySelector = getDisplaySelector(params, context);
+            const timeout = params.TIMEOUT;
+            const expect = await getExpect();
+            const locator = page.locator(selector);
+            context.logger.info(`Asserting ${displaySelector} is visible`);
+            await expect(locator).toBeVisible({ timeout });
+            context.logger.info(`✓ Element ${displaySelector} is visible`);
+            return {
+                _summary: `${displaySelector} is visible`,
+                selector,
+                isVisible: true,
+            };
+        },
+    },
+    // Assert Element Not Visible
+    {
+        type: 'web_assert_not_visible',
+        category: 'Web',
+        color: '#FF9800',
+        tooltip: 'Assert that an element is not visible (auto-waits)',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'TIMEOUT', type: 'field', fieldType: 'number', default: 30000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const displaySelector = getDisplaySelector(params, context);
+            const timeout = params.TIMEOUT;
+            const expect = await getExpect();
+            const locator = page.locator(selector);
+            context.logger.info(`Asserting ${displaySelector} is not visible`);
+            await expect(locator).toBeHidden({ timeout });
+            context.logger.info(`✓ Element ${displaySelector} is not visible`);
+            return {
+                _summary: `${displaySelector} is not visible`,
+                selector,
+                isVisible: false,
+            };
+        },
+    },
+    // Assert Text Contains
+    {
+        type: 'web_assert_text_contains',
+        category: 'Web',
+        color: '#FF9800',
+        tooltip: 'Assert that element text contains expected value (auto-waits)',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'TEXT', type: 'field', fieldType: 'text', required: true },
+            { name: 'TIMEOUT', type: 'field', fieldType: 'number', default: 30000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const displaySelector = getDisplaySelector(params, context);
+            const expectedText = resolveVariables(params.TEXT, context);
+            const timeout = params.TIMEOUT;
+            const expect = await getExpect();
+            const locator = page.locator(selector);
+            context.logger.info(`Asserting ${displaySelector} contains "${expectedText}"`);
+            await expect(locator).toContainText(expectedText, { timeout });
+            context.logger.info(`✓ Element ${displaySelector} contains text "${expectedText}"`);
+            return {
+                _summary: `"${expectedText}" found`,
+                selector,
+                expectedText,
+            };
+        },
+    },
+    // Assert Text Equals
+    {
+        type: 'web_assert_text_equals',
+        category: 'Web',
+        color: '#FF9800',
+        tooltip: 'Assert that element text equals expected value (auto-waits)',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'TEXT', type: 'field', fieldType: 'text', required: true },
+            { name: 'TIMEOUT', type: 'field', fieldType: 'number', default: 30000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const displaySelector = getDisplaySelector(params, context);
+            const expectedText = resolveVariables(params.TEXT, context);
+            const timeout = params.TIMEOUT;
+            const expect = await getExpect();
+            const locator = page.locator(selector);
+            context.logger.info(`Asserting ${displaySelector} text equals "${expectedText}"`);
+            await expect(locator).toHaveText(expectedText, { timeout });
+            context.logger.info(`✓ Element ${displaySelector} text equals "${expectedText}"`);
+            return {
+                _summary: `"${expectedText}" matches`,
+                selector,
+                expectedText,
+            };
+        },
+    },
+    // Assert URL Contains
+    {
+        type: 'web_assert_url_contains',
+        category: 'Web',
+        color: '#FF9800',
+        tooltip: 'Assert that current URL contains expected value (auto-waits)',
+        inputs: [
+            { name: 'TEXT', type: 'field', fieldType: 'text', required: true },
+            { name: 'TIMEOUT', type: 'field', fieldType: 'number', default: 30000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const expectedText = resolveVariables(params.TEXT, context);
+            const timeout = params.TIMEOUT;
+            const expect = await getExpect();
+            // Escape special regex characters and create a regex pattern
+            const escapedText = expectedText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const urlPattern = new RegExp(escapedText);
+            context.logger.info(`Asserting URL contains "${expectedText}"`);
+            await expect(page).toHaveURL(urlPattern, { timeout });
+            context.logger.info(`✓ URL contains "${expectedText}"`);
+            return {
+                _summary: `"${expectedText}" in URL`,
+                expectedText,
+                actualUrl: page.url(),
+            };
+        },
+    },
+    // Assert Title Contains
+    {
+        type: 'web_assert_title_contains',
+        category: 'Web',
+        color: '#FF9800',
+        tooltip: 'Assert that page title contains expected value (auto-waits)',
+        inputs: [
+            { name: 'TEXT', type: 'field', fieldType: 'text', required: true },
+            { name: 'TIMEOUT', type: 'field', fieldType: 'number', default: 30000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const expectedText = resolveVariables(params.TEXT, context);
+            const timeout = params.TIMEOUT;
+            const expect = await getExpect();
+            // Escape special regex characters and create a regex pattern
+            const escapedText = expectedText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const titlePattern = new RegExp(escapedText);
+            context.logger.info(`Asserting title contains "${expectedText}"`);
+            await expect(page).toHaveTitle(titlePattern, { timeout });
+            context.logger.info(`✓ Title contains "${expectedText}"`);
+            return {
+                _summary: `"${expectedText}" in title`,
+                expectedText,
+            };
+        },
+    },
+    // Assert Element Enabled
+    {
+        type: 'web_assert_enabled',
+        category: 'Web',
+        color: '#FF9800',
+        tooltip: 'Assert that an element is enabled (auto-waits)',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'TIMEOUT', type: 'field', fieldType: 'number', default: 30000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const displaySelector = getDisplaySelector(params, context);
+            const timeout = params.TIMEOUT;
+            const expect = await getExpect();
+            const locator = page.locator(selector);
+            context.logger.info(`Asserting ${displaySelector} is enabled`);
+            await expect(locator).toBeEnabled({ timeout });
+            context.logger.info(`✓ Element ${displaySelector} is enabled`);
+            return {
+                _summary: `${displaySelector} is enabled`,
+                selector,
+                isEnabled: true,
+            };
+        },
+    },
+    // Assert Checkbox Checked
+    {
+        type: 'web_assert_checked',
+        category: 'Web',
+        color: '#FF9800',
+        tooltip: 'Assert that a checkbox is checked (auto-waits)',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'EXPECTED', type: 'field', fieldType: 'checkbox', default: true },
+            { name: 'TIMEOUT', type: 'field', fieldType: 'number', default: 30000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const page = context.page;
+            const selector = resolveSelector(params, context);
+            const displaySelector = getDisplaySelector(params, context);
+            const expected = params.EXPECTED;
+            const timeout = params.TIMEOUT;
+            const expect = await getExpect();
+            const locator = page.locator(selector);
+            context.logger.info(`Asserting ${displaySelector} is ${expected ? 'checked' : 'unchecked'}`);
+            if (expected) {
+                await expect(locator).toBeChecked({ timeout });
+            }
+            else {
+                await expect(locator).not.toBeChecked({ timeout });
+            }
+            context.logger.info(`✓ Checkbox ${displaySelector} is ${expected ? 'checked' : 'unchecked'}`);
+            return {
+                _summary: `${displaySelector} is ${expected ? 'checked' : 'unchecked'}`,
+                selector,
+                expected,
+            };
+        },
+    },
+];
+// Helper function - supports dot notation for object properties (e.g., ${user.email})
+function resolveVariables(text, context) {
+    return text.replace(/\$\{([\w.]+)\}/g, (match, path) => {
+        const parts = path.split('.');
+        const varName = parts[0];
+        let value = context.variables.get(varName);
+        // Handle dot notation for nested object access
+        if (parts.length > 1 && value !== undefined && value !== null) {
+            for (let i = 1; i < parts.length; i++) {
+                if (value === undefined || value === null)
+                    break;
+                value = value[parts[i]];
+            }
+        }
+        if (value === undefined || value === null)
+            return match;
+        if (typeof value === 'object')
+            return JSON.stringify(value);
+        return String(value);
+    });
+}
+/**
+ * Resolve a selector based on its type
+ * - For 'testid:value' format: constructs [testIdAttribute="value"] using the global testIdAttribute
+ * - For other formats: returns the selector as-is
+ */
+function resolveSelector(params, context) {
+    const rawSelector = resolveVariables(params.SELECTOR, context);
+    // Check for testid: prefix (e.g., "testid:nav-sign-in")
+    if (rawSelector.startsWith('testid:')) {
+        const testIdValue = rawSelector.substring(7); // Remove 'testid:' prefix
+        const testIdAttr = context.testIdAttribute || 'data-testid';
+        return `[${testIdAttr}="${testIdValue}"]`;
+    }
+    return rawSelector;
+}
+/**
+ * Get a display-friendly version of the selector (strips testid: prefix)
+ */
+function getDisplaySelector(params, context) {
+    const rawSelector = params.SELECTOR;
+    // For testid: prefix, show the actual CSS selector that will be used
+    if (rawSelector.startsWith('testid:')) {
+        const testIdValue = rawSelector.substring(7);
+        const testIdAttr = context.testIdAttribute || 'data-testid';
+        return `[${testIdAttr}="${testIdValue}"]`;
+    }
+    return rawSelector;
+}