@testsmith/testblocks 0.9.4 → 0.9.7

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertEnabledBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that an element is enabled (auto-waits).
+ */
+class WebAssertEnabledBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_enabled';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that an element is enabled (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(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,
+        };
+    }
+}
+exports.WebAssertEnabledBlock = WebAssertEnabledBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Assert that an element is focused (auto-waits).
+ */
+export declare class WebAssertFocusedBlock extends StatementBlock {
+    readonly type = "web_assert_focused";
+    readonly category = "Web";
+    readonly color = "#FF9800";
+    readonly tooltip = "Assert that an element is focused (auto-waits)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertFocusedBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that an element is focused (auto-waits).
+ */
+class WebAssertFocusedBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_focused';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that an element is focused (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(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 focused`);
+        await (0, utils_1.executeWebAssertion)(context, async () => { await expect(locator).toBeFocused({ timeout }); }, `Expected element ${displaySelector} to be focused`, { stepType: 'web_assert_focused', expected: 'focused', actual: 'not focused' });
+        context.logger.info(`✓ Element ${displaySelector} is focused`);
+        return {
+            _summary: `${displaySelector} is focused`,
+            selector,
+            isFocused: true,
+        };
+    }
+}
+exports.WebAssertFocusedBlock = WebAssertFocusedBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Assert that an element has a specific ID (auto-waits).
+ */
+export declare class WebAssertIdBlock extends StatementBlock {
+    readonly type = "web_assert_id";
+    readonly category = "Web";
+    readonly color = "#FF9800";
+    readonly tooltip = "Assert that an element has a specific ID (auto-waits)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertIdBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that an element has a specific ID (auto-waits).
+ */
+class WebAssertIdBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_id';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that an element has a specific ID (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'ID', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const selector = (0, utils_1.resolveSelector)(params, context);
+        const displaySelector = (0, utils_1.getDisplaySelector)(params, context);
+        const expectedId = (0, utils_1.resolveVariables)(params.ID, 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 ID "${expectedId}"`);
+        await (0, utils_1.executeWebAssertion)(context, async () => { await expect(locator).toHaveId(expectedId, { timeout }); }, `Expected element ${displaySelector} to have ID "${expectedId}"`, { stepType: 'web_assert_id', expected: expectedId });
+        context.logger.info(`✓ Element ${displaySelector} has ID "${expectedId}"`);
+        return {
+            _summary: `id="${expectedId}"`,
+            selector,
+            expectedId,
+        };
+    }
+}
+exports.WebAssertIdBlock = WebAssertIdBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Assert that an element is in the viewport (auto-waits).
+ */
+export declare class WebAssertInViewportBlock extends StatementBlock {
+    readonly type = "web_assert_in_viewport";
+    readonly category = "Web";
+    readonly color = "#FF9800";
+    readonly tooltip = "Assert that an element is in the viewport (auto-waits)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertInViewportBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that an element is in the viewport (auto-waits).
+ */
+class WebAssertInViewportBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_in_viewport';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that an element is in the viewport (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(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 in viewport`);
+        await (0, utils_1.executeWebAssertion)(context, async () => { await expect(locator).toBeInViewport({ timeout }); }, `Expected element ${displaySelector} to be in viewport`, { stepType: 'web_assert_in_viewport', expected: 'in viewport', actual: 'not in viewport' });
+        context.logger.info(`✓ Element ${displaySelector} is in viewport`);
+        return {
+            _summary: `${displaySelector} is in viewport`,
+            selector,
+            isInViewport: true,
+        };
+    }
+}
+exports.WebAssertInViewportBlock = WebAssertInViewportBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Assert that an element is not visible (auto-waits).
+ */
+export declare class WebAssertNotVisibleBlock extends StatementBlock {
+    readonly type = "web_assert_not_visible";
+    readonly category = "Web";
+    readonly color = "#FF9800";
+    readonly tooltip = "Assert that an element is not visible (auto-waits)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertNotVisibleBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that an element is not visible (auto-waits).
+ */
+class WebAssertNotVisibleBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_not_visible';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that an element is not visible (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(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,
+        };
+    }
+}
+exports.WebAssertNotVisibleBlock = WebAssertNotVisibleBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Assert that an element has a specific ARIA role (auto-waits).
+ */
+export declare class WebAssertRoleBlock extends StatementBlock {
+    readonly type = "web_assert_role";
+    readonly category = "Web";
+    readonly color = "#FF9800";
+    readonly tooltip = "Assert that an element has a specific ARIA role (auto-waits)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertRoleBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that an element has a specific ARIA role (auto-waits).
+ */
+class WebAssertRoleBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_role';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that an element has a specific ARIA role (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'ROLE', type: 'field', fieldType: 'dropdown', required: true, options: [
+                    ['Button', 'button'],
+                    ['Checkbox', 'checkbox'],
+                    ['Combobox', 'combobox'],
+                    ['Dialog', 'dialog'],
+                    ['Grid', 'grid'],
+                    ['Heading', 'heading'],
+                    ['Link', 'link'],
+                    ['List', 'list'],
+                    ['Listbox', 'listbox'],
+                    ['Listitem', 'listitem'],
+                    ['Menu', 'menu'],
+                    ['Menuitem', 'menuitem'],
+                    ['Navigation', 'navigation'],
+                    ['Option', 'option'],
+                    ['Radio', 'radio'],
+                    ['Region', 'region'],
+                    ['Row', 'row'],
+                    ['Searchbox', 'searchbox'],
+                    ['Slider', 'slider'],
+                    ['Spinbutton', 'spinbutton'],
+                    ['Switch', 'switch'],
+                    ['Tab', 'tab'],
+                    ['Tablist', 'tablist'],
+                    ['Tabpanel', 'tabpanel'],
+                    ['Textbox', 'textbox'],
+                    ['Tree', 'tree'],
+                    ['Treeitem', 'treeitem'],
+                ] },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const selector = (0, utils_1.resolveSelector)(params, context);
+        const displaySelector = (0, utils_1.getDisplaySelector)(params, context);
+        const expectedRole = params.ROLE;
+        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 role "${expectedRole}"`);
+        await (0, utils_1.executeWebAssertion)(context, async () => { await expect(locator).toHaveRole(expectedRole, { timeout }); }, `Expected element ${displaySelector} to have role "${expectedRole}"`, { stepType: 'web_assert_role', expected: expectedRole });
+        context.logger.info(`✓ Element ${displaySelector} has role "${expectedRole}"`);
+        return {
+            _summary: `role="${expectedRole}"`,
+            selector,
+            expectedRole,
+        };
+    }
+}
+exports.WebAssertRoleBlock = WebAssertRoleBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Assert that element text contains expected value (auto-waits).
+ */
+export declare class WebAssertTextContainsBlock extends StatementBlock {
+    readonly type = "web_assert_text_contains";
+    readonly category = "Web";
+    readonly color = "#FF9800";
+    readonly tooltip = "Assert that element text contains expected value (auto-waits)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertTextContainsBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that element text contains expected value (auto-waits).
+ */
+class WebAssertTextContainsBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_text_contains';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that element text contains expected value (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'TEXT', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(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,
+        };
+    }
+}
+exports.WebAssertTextContainsBlock = WebAssertTextContainsBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Assert that element text equals expected value (auto-waits).
+ */
+export declare class WebAssertTextEqualsBlock extends StatementBlock {
+    readonly type = "web_assert_text_equals";
+    readonly category = "Web";
+    readonly color = "#FF9800";
+    readonly tooltip = "Assert that element text equals expected value (auto-waits)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertTextEqualsBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that element text equals expected value (auto-waits).
+ */
+class WebAssertTextEqualsBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_text_equals';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that element text equals expected value (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'TEXT', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(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,
+        };
+    }
+}
+exports.WebAssertTextEqualsBlock = WebAssertTextEqualsBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Assert that page title contains expected value (auto-waits).
+ */
+export declare class WebAssertTitleContainsBlock extends StatementBlock {
+    readonly type = "web_assert_title_contains";
+    readonly category = "Web";
+    readonly color = "#FF9800";
+    readonly tooltip = "Assert that page title contains expected value (auto-waits)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertTitleContainsBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that page title contains expected value (auto-waits).
+ */
+class WebAssertTitleContainsBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_title_contains';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that page title contains expected value (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'TEXT', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(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,
+        };
+    }
+}
+exports.WebAssertTitleContainsBlock = WebAssertTitleContainsBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Assert that the page title equals an expected value (auto-waits).
+ */
+export declare class WebAssertTitleEqualsBlock extends StatementBlock {
+    readonly type = "web_assert_title_equals";
+    readonly category = "Web";
+    readonly color = "#FF9800";
+    readonly tooltip = "Assert that the page title equals an expected value (auto-waits)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertTitleEqualsBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that the page title equals an expected value (auto-waits).
+ */
+class WebAssertTitleEqualsBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_title_equals';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that the page title equals an expected value (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'TITLE', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const expectedTitle = (0, utils_1.resolveVariables)(params.TITLE, context);
+        const timeout = (0, utils_1.getTimeout)(context);
+        const expect = await (0, utils_1.getExpect)();
+        context.logger.info(`Asserting title equals "${expectedTitle}"`);
+        await (0, utils_1.executeWebAssertion)(context, async () => { await expect(page).toHaveTitle(expectedTitle, { timeout }); }, `Expected title to equal "${expectedTitle}"`, { stepType: 'web_assert_title_equals', expected: expectedTitle });
+        context.logger.info(`✓ Title equals "${expectedTitle}"`);
+        return {
+            _summary: `"${expectedTitle}"`,
+            expectedTitle,
+        };
+    }
+}
+exports.WebAssertTitleEqualsBlock = WebAssertTitleEqualsBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Assert that current URL contains expected value (auto-waits).
+ */
+export declare class WebAssertUrlContainsBlock extends StatementBlock {
+    readonly type = "web_assert_url_contains";
+    readonly category = "Web";
+    readonly color = "#FF9800";
+    readonly tooltip = "Assert that current URL contains expected value (auto-waits)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertUrlContainsBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that current URL contains expected value (auto-waits).
+ */
+class WebAssertUrlContainsBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_url_contains';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that current URL contains expected value (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'TEXT', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(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(),
+        };
+    }
+}
+exports.WebAssertUrlContainsBlock = WebAssertUrlContainsBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Assert that the page URL equals an expected value (auto-waits).
+ */
+export declare class WebAssertUrlEqualsBlock extends StatementBlock {
+    readonly type = "web_assert_url_equals";
+    readonly category = "Web";
+    readonly color = "#FF9800";
+    readonly tooltip = "Assert that the page URL equals an expected value (auto-waits)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}