@testsmith/testblocks 0.9.4 → 0.9.7

package/dist/core/blocks/logic.js

@@ -1,360 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logicBlocks = void 0;
-const assertions_1 = require("./assertions");
-// Logic and Control Flow Blocks
-exports.logicBlocks = [
-    // Set Variable
-    {
-        type: 'logic_set_variable',
-        category: 'Logic',
-        color: '#795548',
-        tooltip: 'Set a variable value',
-        inputs: [
-            { name: 'NAME', type: 'field', fieldType: 'text', required: true },
-            { name: 'VALUE', type: 'value', required: true },
-        ],
-        previousStatement: true,
-        nextStatement: true,
-        execute: async (params, context) => {
-            const name = params.NAME;
-            let value = params.VALUE;
-            // If the value is a block result with _value, extract just the value
-            if (value && typeof value === 'object' && '_value' in value) {
-                value = value._value;
-            }
-            context.variables.set(name, value);
-            context.logger.debug(`Set variable ${name} = ${JSON.stringify(value)}`);
-        },
-    },
-    // Get Variable
-    {
-        type: 'logic_get_variable',
-        category: 'Logic',
-        color: '#795548',
-        tooltip: 'Get a variable value',
-        inputs: [
-            { name: 'NAME', type: 'field', fieldType: 'text', required: true },
-        ],
-        output: { type: ['String', 'Number', 'Boolean', 'Object', 'Array'] },
-        execute: async (params, context) => {
-            const name = params.NAME;
-            return context.variables.get(name);
-        },
-    },
-    // If Condition
-    {
-        type: 'logic_if',
-        category: 'Logic',
-        color: '#5C6BC0',
-        tooltip: 'Execute blocks if condition is true',
-        inputs: [
-            { name: 'CONDITION', type: 'value', check: 'Boolean', required: true },
-            { name: 'DO', type: 'statement' },
-            { name: 'ELSE', type: 'statement' },
-        ],
-        previousStatement: true,
-        nextStatement: true,
-        execute: async (params, _context) => {
-            const condition = params.CONDITION;
-            if (condition && params.DO) {
-                // Execute DO block - handled by executor
-                return { branch: 'DO' };
-            }
-            else if (!condition && params.ELSE) {
-                // Execute ELSE block - handled by executor
-                return { branch: 'ELSE' };
-            }
-        },
-    },
-    // Compare Values
-    {
-        type: 'logic_compare',
-        category: 'Logic',
-        color: '#5C6BC0',
-        tooltip: 'Compare two values',
-        inputs: [
-            { name: 'A', type: 'value', required: true },
-            { name: 'OP', type: 'field', fieldType: 'dropdown', options: [['=', 'eq'], ['≠', 'neq'], ['<', 'lt'], ['≤', 'lte'], ['>', 'gt'], ['≥', 'gte'], ['contains', 'contains']] },
-            { name: 'B', type: 'value', required: true },
-        ],
-        output: { type: 'Boolean' },
-        execute: async (params, _context) => {
-            const a = params.A;
-            const b = params.B;
-            const op = params.OP;
-            switch (op) {
-                case 'eq':
-                    return JSON.stringify(a) === JSON.stringify(b);
-                case 'neq':
-                    return JSON.stringify(a) !== JSON.stringify(b);
-                case 'lt':
-                    return a < b;
-                case 'lte':
-                    return a <= b;
-                case 'gt':
-                    return a > b;
-                case 'gte':
-                    return a >= b;
-                case 'contains':
-                    if (typeof a === 'string')
-                        return a.includes(b);
-                    if (Array.isArray(a))
-                        return a.includes(b);
-                    return false;
-                default:
-                    return false;
-            }
-        },
-    },
-    // Boolean Operations
-    {
-        type: 'logic_boolean_op',
-        category: 'Logic',
-        color: '#5C6BC0',
-        tooltip: 'Combine boolean values',
-        inputs: [
-            { name: 'A', type: 'value', check: 'Boolean', required: true },
-            { name: 'OP', type: 'field', fieldType: 'dropdown', options: [['and', 'and'], ['or', 'or']] },
-            { name: 'B', type: 'value', check: 'Boolean', required: true },
-        ],
-        output: { type: 'Boolean' },
-        execute: async (params) => {
-            const a = params.A;
-            const b = params.B;
-            const op = params.OP;
-            return op === 'and' ? a && b : a || b;
-        },
-    },
-    // Not
-    {
-        type: 'logic_not',
-        category: 'Logic',
-        color: '#5C6BC0',
-        tooltip: 'Negate a boolean value',
-        inputs: [
-            { name: 'VALUE', type: 'value', check: 'Boolean', required: true },
-        ],
-        output: { type: 'Boolean' },
-        execute: async (params) => {
-            return !params.VALUE;
-        },
-    },
-    // Loop (repeat n times)
-    {
-        type: 'logic_repeat',
-        category: 'Logic',
-        color: '#5C6BC0',
-        tooltip: 'Repeat blocks a specified number of times',
-        inputs: [
-            { name: 'TIMES', type: 'field', fieldType: 'number', default: 10, required: true },
-            { name: 'DO', type: 'statement' },
-        ],
-        previousStatement: true,
-        nextStatement: true,
-        execute: async (params, _context) => {
-            const times = params.TIMES;
-            return { loop: true, times, statement: 'DO' };
-        },
-    },
-    // For Each
-    {
-        type: 'logic_foreach',
-        category: 'Logic',
-        color: '#5C6BC0',
-        tooltip: 'Iterate over an array',
-        inputs: [
-            { name: 'ARRAY', type: 'value', check: 'Array', required: true },
-            { name: 'VAR', type: 'field', fieldType: 'text', default: 'item', required: true },
-            { name: 'DO', type: 'statement' },
-        ],
-        previousStatement: true,
-        nextStatement: true,
-        execute: async (params, _context) => {
-            const array = params.ARRAY;
-            const varName = params.VAR;
-            return { loop: true, array, varName, statement: 'DO' };
-        },
-    },
-    // Try/Catch
-    {
-        type: 'logic_try_catch',
-        category: 'Logic',
-        color: '#5C6BC0',
-        tooltip: 'Handle errors gracefully',
-        inputs: [
-            { name: 'TRY', type: 'statement' },
-            { name: 'CATCH', type: 'statement' },
-        ],
-        previousStatement: true,
-        nextStatement: true,
-        execute: async (_params, _context) => {
-            return { tryCatch: true };
-        },
-    },
-    // Log Message
-    {
-        type: 'logic_log',
-        category: 'Logic',
-        color: '#607D8B',
-        tooltip: 'Log a message',
-        inputs: [
-            { name: 'LEVEL', type: 'field', fieldType: 'dropdown', options: [['Info', 'info'], ['Warning', 'warn'], ['Error', 'error'], ['Debug', 'debug']] },
-            { name: 'MESSAGE', type: 'field', fieldType: 'text', required: true },
-        ],
-        previousStatement: true,
-        nextStatement: true,
-        execute: async (params, context) => {
-            const level = params.LEVEL || 'info';
-            const message = resolveVariables(params.MESSAGE, context);
-            context.logger[level](message);
-            return { _message: message, _summary: message };
-        },
-    },
-    // Comment (no-op, for documentation)
-    {
-        type: 'logic_comment',
-        category: 'Logic',
-        color: '#9E9E9E',
-        tooltip: 'Add a comment (does nothing)',
-        inputs: [
-            { name: 'TEXT', type: 'field', fieldType: 'text', default: 'Comment' },
-        ],
-        previousStatement: true,
-        nextStatement: true,
-        execute: async () => {
-            // No-op
-        },
-    },
-    // Text/String block
-    {
-        type: 'logic_text',
-        category: 'Logic',
-        color: '#795548',
-        tooltip: 'A text value',
-        inputs: [
-            { name: 'TEXT', type: 'field', fieldType: 'text', default: '' },
-        ],
-        output: { type: 'String' },
-        execute: async (params, context) => {
-            return resolveVariables(params.TEXT, context);
-        },
-    },
-    // Number block
-    {
-        type: 'logic_number',
-        category: 'Logic',
-        color: '#795548',
-        tooltip: 'A number value',
-        inputs: [
-            { name: 'NUM', type: 'field', fieldType: 'number', default: 0 },
-        ],
-        output: { type: 'Number' },
-        execute: async (params) => {
-            return params.NUM;
-        },
-    },
-    // Boolean block
-    {
-        type: 'logic_boolean',
-        category: 'Logic',
-        color: '#795548',
-        tooltip: 'A boolean value',
-        inputs: [
-            { name: 'BOOL', type: 'field', fieldType: 'dropdown', options: [['true', 'true'], ['false', 'false']] },
-        ],
-        output: { type: 'Boolean' },
-        execute: async (params) => {
-            return params.BOOL === 'true';
-        },
-    },
-    // Create Object
-    {
-        type: 'logic_object',
-        category: 'Logic',
-        color: '#795548',
-        tooltip: 'Create a JSON object',
-        inputs: [
-            { name: 'JSON', type: 'field', fieldType: 'text', default: '{}' },
-        ],
-        output: { type: 'Object' },
-        execute: async (params, context) => {
-            const json = resolveVariables(params.JSON, context);
-            return JSON.parse(json);
-        },
-    },
-    // Create Array
-    {
-        type: 'logic_array',
-        category: 'Logic',
-        color: '#795548',
-        tooltip: 'Create an array',
-        inputs: [
-            { name: 'JSON', type: 'field', fieldType: 'text', default: '[]' },
-        ],
-        output: { type: 'Array' },
-        execute: async (params, context) => {
-            const json = resolveVariables(params.JSON, context);
-            return JSON.parse(json);
-        },
-    },
-    // Fail Test
-    {
-        type: 'logic_fail',
-        category: 'Logic',
-        color: '#f44336',
-        tooltip: 'Fail the test with a message',
-        inputs: [
-            { name: 'MESSAGE', type: 'field', fieldType: 'text', default: 'Test failed' },
-        ],
-        previousStatement: true,
-        execute: async (params, context) => {
-            const message = resolveVariables(params.MESSAGE, context);
-            throw new Error(message);
-        },
-    },
-    // Assert
-    {
-        type: 'logic_assert',
-        category: 'Logic',
-        color: '#FF9800',
-        tooltip: 'Assert a condition is true',
-        inputs: [
-            { name: 'CONDITION', type: 'value', check: 'Boolean', required: true },
-            { name: 'MESSAGE', type: 'field', fieldType: 'text', default: 'Assertion failed' },
-        ],
-        previousStatement: true,
-        nextStatement: true,
-        execute: async (params, context) => {
-            const condition = params.CONDITION;
-            const message = resolveVariables(params.MESSAGE, context);
-            (0, assertions_1.handleAssertion)(context, condition, message, { stepType: 'logic_assert', expected: true, actual: condition });
-            context.logger.info('✓ Assertion passed');
-        },
-    },
-];
-// Helper function
-function resolveVariables(text, context) {
-    // Match ${varName} or ${varName.property.path}
-    return text.replace(/\$\{([\w.]+)\}/g, (match, path) => {
-        const parts = path.split('.');
-        const varName = parts[0];
-        let value = context.variables.get(varName);
-        // Navigate through object properties if path has dots
-        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; // Keep original if not found
-        }
-        // Return stringified value
-        if (typeof value === 'object') {
-            return JSON.stringify(value);
-        }
-        return String(value);
-    });
-}

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

@@ -1,5 +0,0 @@
-import { BlockDefinition } from '../../types';
-/**
- * Assertion blocks for Playwright (visibility, text, values)
- */
-export declare const assertionBlocks: BlockDefinition[];

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

@@ -1,311 +0,0 @@
-"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 },
-        ],
-        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 = (0, utils_1.getTimeout)(context);
-            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 },
-        ],
-        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 = (0, utils_1.getTimeout)(context);
-            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 },
-        ],
-        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 = (0, utils_1.getTimeout)(context);
-            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 },
-        ],
-        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 = (0, utils_1.getTimeout)(context);
-            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 },
-        ],
-        previousStatement: true,
-        nextStatement: true,
-        execute: async (params, context) => {
-            const page = context.page;
-            const expectedText = (0, utils_1.resolveVariables)(params.TEXT, context);
-            const timeout = (0, utils_1.getTimeout)(context);
-            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 },
-        ],
-        previousStatement: true,
-        nextStatement: true,
-        execute: async (params, context) => {
-            const page = context.page;
-            const expectedText = (0, utils_1.resolveVariables)(params.TEXT, context);
-            const timeout = (0, utils_1.getTimeout)(context);
-            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 },
-        ],
-        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 = (0, utils_1.getTimeout)(context);
-            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 },
-        ],
-        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 = (0, utils_1.getTimeout)(context);
-            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 },
-        ],
-        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 = (0, utils_1.getTimeout)(context);
-            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 },
-        ],
-        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 = (0, utils_1.getTimeout)(context);
-            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/interactions.d.ts

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