@testsmith/testblocks 0.5.0 → 0.7.0

package/dist/core/blocks/playwright/assertions.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertionBlocks = void 0;
+const utils_1 = require("./utils");
+/**
+ * Assertion blocks for Playwright (visibility, text, values)
+ */
+exports.assertionBlocks = [
+    // 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 = (0, utils_1.resolveSelector)(params, context);
+            const displaySelector = (0, utils_1.getDisplaySelector)(params, context);
+            const timeout = params.TIMEOUT;
+            const expect = await (0, utils_1.getExpect)();
+            const locator = page.locator(selector);
+            context.logger.info(`Asserting ${displaySelector} is visible`);
+            await (0, utils_1.executeWebAssertion)(context, async () => { await expect(locator).toBeVisible({ timeout }); }, `Expected element ${displaySelector} to be visible`, { stepType: 'web_assert_visible', expected: 'visible', actual: 'not visible' });
+            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 = (0, utils_1.resolveSelector)(params, context);
+            const displaySelector = (0, utils_1.getDisplaySelector)(params, context);
+            const timeout = params.TIMEOUT;
+            const expect = await (0, utils_1.getExpect)();
+            const locator = page.locator(selector);
+            context.logger.info(`Asserting ${displaySelector} is not visible`);
+            await (0, utils_1.executeWebAssertion)(context, async () => { await expect(locator).toBeHidden({ timeout }); }, `Expected element ${displaySelector} to be hidden`, { stepType: 'web_assert_not_visible', expected: 'hidden', actual: 'visible' });
+            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 = (0, utils_1.resolveSelector)(params, context);
+            const displaySelector = (0, utils_1.getDisplaySelector)(params, context);
+            const expectedText = (0, utils_1.resolveVariables)(params.TEXT, context);
+            const timeout = params.TIMEOUT;
+            const expect = await (0, utils_1.getExpect)();
+            const locator = page.locator(selector);
+            context.logger.info(`Asserting ${displaySelector} contains "${expectedText}"`);
+            await (0, utils_1.executeWebAssertion)(context, async () => { await expect(locator).toContainText(expectedText, { timeout }); }, `Expected element ${displaySelector} to contain text "${expectedText}"`, { stepType: 'web_assert_text_contains', expected: expectedText });
+            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 = (0, utils_1.resolveSelector)(params, context);
+            const displaySelector = (0, utils_1.getDisplaySelector)(params, context);
+            const expectedText = (0, utils_1.resolveVariables)(params.TEXT, context);
+            const timeout = params.TIMEOUT;
+            const expect = await (0, utils_1.getExpect)();
+            const locator = page.locator(selector);
+            context.logger.info(`Asserting ${displaySelector} text equals "${expectedText}"`);
+            await (0, utils_1.executeWebAssertion)(context, async () => { await expect(locator).toHaveText(expectedText, { timeout }); }, `Expected element ${displaySelector} text to equal "${expectedText}"`, { stepType: 'web_assert_text_equals', expected: expectedText });
+            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 = (0, utils_1.resolveVariables)(params.TEXT, context);
+            const timeout = params.TIMEOUT;
+            const expect = await (0, utils_1.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 (0, utils_1.executeWebAssertion)(context, async () => { await expect(page).toHaveURL(urlPattern, { timeout }); }, `Expected URL to contain "${expectedText}"`, { stepType: 'web_assert_url_contains', expected: expectedText, actual: page.url() });
+            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 = (0, utils_1.resolveVariables)(params.TEXT, context);
+            const timeout = params.TIMEOUT;
+            const expect = await (0, utils_1.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 (0, utils_1.executeWebAssertion)(context, async () => { await expect(page).toHaveTitle(titlePattern, { timeout }); }, `Expected title to contain "${expectedText}"`, { stepType: 'web_assert_title_contains', expected: expectedText });
+            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 = (0, utils_1.resolveSelector)(params, context);
+            const displaySelector = (0, utils_1.getDisplaySelector)(params, context);
+            const timeout = params.TIMEOUT;
+            const expect = await (0, utils_1.getExpect)();
+            const locator = page.locator(selector);
+            context.logger.info(`Asserting ${displaySelector} is enabled`);
+            await (0, utils_1.executeWebAssertion)(context, async () => { await expect(locator).toBeEnabled({ timeout }); }, `Expected element ${displaySelector} to be enabled`, { stepType: 'web_assert_enabled', expected: 'enabled', actual: 'disabled' });
+            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 = (0, utils_1.resolveSelector)(params, context);
+            const displaySelector = (0, utils_1.getDisplaySelector)(params, context);
+            const expected = params.EXPECTED;
+            const timeout = params.TIMEOUT;
+            const expect = await (0, utils_1.getExpect)();
+            const locator = page.locator(selector);
+            context.logger.info(`Asserting ${displaySelector} is ${expected ? 'checked' : 'unchecked'}`);
+            await (0, utils_1.executeWebAssertion)(context, async () => {
+                if (expected) {
+                    await expect(locator).toBeChecked({ timeout });
+                }
+                else {
+                    await expect(locator).not.toBeChecked({ timeout });
+                }
+            }, `Expected checkbox ${displaySelector} to be ${expected ? 'checked' : 'unchecked'}`, { stepType: 'web_assert_checked', expected: expected ? 'checked' : 'unchecked' });
+            context.logger.info(`✓ Checkbox ${displaySelector} is ${expected ? 'checked' : 'unchecked'}`);
+            return {
+                _summary: `${displaySelector} is ${expected ? 'checked' : 'unchecked'}`,
+                selector,
+                expected,
+            };
+        },
+    },
+    // Assert Input Value
+    {
+        type: 'web_assert_value',
+        category: 'Web',
+        color: '#FF9800',
+        tooltip: 'Assert that an input field has a specific value (auto-waits)',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'VALUE', 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 = (0, utils_1.resolveSelector)(params, context);
+            const displaySelector = (0, utils_1.getDisplaySelector)(params, context);
+            const expectedValue = (0, utils_1.resolveVariables)(params.VALUE, context);
+            const timeout = params.TIMEOUT;
+            const expect = await (0, utils_1.getExpect)();
+            const locator = page.locator(selector);
+            context.logger.info(`Asserting ${displaySelector} has value "${expectedValue}"`);
+            await (0, utils_1.executeWebAssertion)(context, async () => {
+                await expect(locator).toHaveValue(expectedValue, { timeout });
+            }, `Expected input ${displaySelector} to have value "${expectedValue}"`, { stepType: 'web_assert_value', expected: expectedValue });
+            context.logger.info(`✓ Input ${displaySelector} has value "${expectedValue}"`);
+            return {
+                _summary: `${displaySelector} = "${expectedValue}"`,
+                selector,
+                expected: expectedValue,
+            };
+        },
+    },
+    // Assert Input Value Contains
+    {
+        type: 'web_assert_value_contains',
+        category: 'Web',
+        color: '#FF9800',
+        tooltip: 'Assert that an input field value contains specific text (auto-waits)',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'VALUE', 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 = (0, utils_1.resolveSelector)(params, context);
+            const displaySelector = (0, utils_1.getDisplaySelector)(params, context);
+            const expectedValue = (0, utils_1.resolveVariables)(params.VALUE, context);
+            const timeout = params.TIMEOUT;
+            const expect = await (0, utils_1.getExpect)();
+            const locator = page.locator(selector);
+            context.logger.info(`Asserting ${displaySelector} value contains "${expectedValue}"`);
+            await (0, utils_1.executeWebAssertion)(context, async () => {
+                await expect(locator).toHaveValue(new RegExp(expectedValue), { timeout });
+            }, `Expected input ${displaySelector} value to contain "${expectedValue}"`, { stepType: 'web_assert_value_contains', expected: expectedValue });
+            context.logger.info(`✓ Input ${displaySelector} value contains "${expectedValue}"`);
+            return {
+                _summary: `${displaySelector} contains "${expectedValue}"`,
+                selector,
+                expected: expectedValue,
+            };
+        },
+    },
+];

package/dist/core/blocks/playwright/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Playwright blocks - modular organization
+ *
+ * Blocks are organized into categories:
+ * - navigation: Navigate, wait, screenshot
+ * - interactions: Click, fill, type, select, checkbox, hover
+ * - retrieval: Get text, attributes, values, title, URL
+ * - assertions: Visibility, text, value, URL, title assertions
+ */
+import { BlockDefinition } from '../../types';
+export * from './types';
+export * from './utils';
+export { navigationBlocks } from './navigation';
+export { interactionBlocks } from './interactions';
+export { retrievalBlocks } from './retrieval';
+export { assertionBlocks } from './assertions';
+export declare const playwrightBlocks: BlockDefinition[];

package/dist/core/blocks/playwright/index.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Playwright blocks - modular organization
+ *
+ * Blocks are organized into categories:
+ * - navigation: Navigate, wait, screenshot
+ * - interactions: Click, fill, type, select, checkbox, hover
+ * - retrieval: Get text, attributes, values, title, URL
+ * - assertions: Visibility, text, value, URL, title assertions
+ */
+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.playwrightBlocks = exports.assertionBlocks = exports.retrievalBlocks = exports.interactionBlocks = exports.navigationBlocks = void 0;
+const navigation_1 = require("./navigation");
+const interactions_1 = require("./interactions");
+const retrieval_1 = require("./retrieval");
+const assertions_1 = require("./assertions");
+// Re-export types and utilities for external use
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+// Re-export individual block categories
+var navigation_2 = require("./navigation");
+Object.defineProperty(exports, "navigationBlocks", { enumerable: true, get: function () { return navigation_2.navigationBlocks; } });
+var interactions_2 = require("./interactions");
+Object.defineProperty(exports, "interactionBlocks", { enumerable: true, get: function () { return interactions_2.interactionBlocks; } });
+var retrieval_2 = require("./retrieval");
+Object.defineProperty(exports, "retrievalBlocks", { enumerable: true, get: function () { return retrieval_2.retrievalBlocks; } });
+var assertions_2 = require("./assertions");
+Object.defineProperty(exports, "assertionBlocks", { enumerable: true, get: function () { return assertions_2.assertionBlocks; } });
+// Combined export of all Playwright blocks
+exports.playwrightBlocks = [
+    ...navigation_1.navigationBlocks,
+    ...interactions_1.interactionBlocks,
+    ...retrieval_1.retrievalBlocks,
+    ...assertions_1.assertionBlocks,
+];

package/dist/core/blocks/playwright/interactions.d.ts

@@ -0,0 +1,5 @@
+import { BlockDefinition } from '../../types';
+/**
+ * User interaction blocks for Playwright (click, type, fill, etc.)
+ */
+export declare const interactionBlocks: BlockDefinition[];

package/dist/core/blocks/playwright/interactions.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interactionBlocks = void 0;
+const utils_1 = require("./utils");
+/**
+ * User interaction blocks for Playwright (click, type, fill, etc.)
+ */
+exports.interactionBlocks = [
+    // 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 = (0, utils_1.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 = (0, utils_1.resolveSelector)(params, context);
+            const rawValue = params.VALUE;
+            const value = (0, utils_1.resolveVariables)(rawValue, 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 = (0, utils_1.resolveSelector)(params, context);
+            const text = (0, utils_1.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 = (0, utils_1.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 = (0, utils_1.resolveSelector)(params, context);
+            const value = (0, utils_1.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 = (0, utils_1.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 = (0, utils_1.resolveSelector)(params, context);
+            context.logger.info(`Hovering over ${selector}`);
+            await page.hover(selector);
+            return {
+                _summary: params.SELECTOR,
+                selector,
+            };
+        },
+    },
+];

package/dist/core/blocks/playwright/navigation.d.ts

@@ -0,0 +1,5 @@
+import { BlockDefinition } from '../../types';
+/**
+ * Navigation and waiting blocks for Playwright
+ */
+export declare const navigationBlocks: BlockDefinition[];