@testsmith/testblocks 0.9.4 → 0.9.7

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertVisibleBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that an element is visible (auto-waits).
+ */
+class WebAssertVisibleBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_visible';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that an element is 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 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,
+        };
+    }
+}
+exports.WebAssertVisibleBlock = WebAssertVisibleBlock;

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

@@ -0,0 +1,36 @@
+import { Block } from '../../base';
+import { BlockDefinition } from '../../../types';
+export { WebAssertVisibleBlock } from './WebAssertVisibleBlock';
+export { WebAssertNotVisibleBlock } from './WebAssertNotVisibleBlock';
+export { WebAssertAttachedBlock } from './WebAssertAttachedBlock';
+export { WebAssertEnabledBlock } from './WebAssertEnabledBlock';
+export { WebAssertDisabledBlock } from './WebAssertDisabledBlock';
+export { WebAssertEditableBlock } from './WebAssertEditableBlock';
+export { WebAssertEmptyBlock } from './WebAssertEmptyBlock';
+export { WebAssertFocusedBlock } from './WebAssertFocusedBlock';
+export { WebAssertInViewportBlock } from './WebAssertInViewportBlock';
+export { WebAssertCheckedBlock } from './WebAssertCheckedBlock';
+export { WebAssertTextContainsBlock } from './WebAssertTextContainsBlock';
+export { WebAssertTextEqualsBlock } from './WebAssertTextEqualsBlock';
+export { WebAssertValueBlock } from './WebAssertValueBlock';
+export { WebAssertValueContainsBlock } from './WebAssertValueContainsBlock';
+export { WebAssertAttributeBlock } from './WebAssertAttributeBlock';
+export { WebAssertClassBlock } from './WebAssertClassBlock';
+export { WebAssertCssBlock } from './WebAssertCssBlock';
+export { WebAssertIdBlock } from './WebAssertIdBlock';
+export { WebAssertCountBlock } from './WebAssertCountBlock';
+export { WebAssertAccessibleNameBlock } from './WebAssertAccessibleNameBlock';
+export { WebAssertAccessibleDescriptionBlock } from './WebAssertAccessibleDescriptionBlock';
+export { WebAssertRoleBlock } from './WebAssertRoleBlock';
+export { WebAssertUrlContainsBlock } from './WebAssertUrlContainsBlock';
+export { WebAssertUrlEqualsBlock } from './WebAssertUrlEqualsBlock';
+export { WebAssertTitleContainsBlock } from './WebAssertTitleContainsBlock';
+export { WebAssertTitleEqualsBlock } from './WebAssertTitleEqualsBlock';
+/**
+ * All assertion block class instances.
+ */
+export declare const assertionBlockClasses: Block[];
+/**
+ * Assertion blocks as BlockDefinition array for backward compatibility.
+ */
+export declare const assertionBlocks: BlockDefinition[];

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

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertionBlocks = exports.assertionBlockClasses = exports.WebAssertTitleEqualsBlock = exports.WebAssertTitleContainsBlock = exports.WebAssertUrlEqualsBlock = exports.WebAssertUrlContainsBlock = exports.WebAssertRoleBlock = exports.WebAssertAccessibleDescriptionBlock = exports.WebAssertAccessibleNameBlock = exports.WebAssertCountBlock = exports.WebAssertIdBlock = exports.WebAssertCssBlock = exports.WebAssertClassBlock = exports.WebAssertAttributeBlock = exports.WebAssertValueContainsBlock = exports.WebAssertValueBlock = exports.WebAssertTextEqualsBlock = exports.WebAssertTextContainsBlock = exports.WebAssertCheckedBlock = exports.WebAssertInViewportBlock = exports.WebAssertFocusedBlock = exports.WebAssertEmptyBlock = exports.WebAssertEditableBlock = exports.WebAssertDisabledBlock = exports.WebAssertEnabledBlock = exports.WebAssertAttachedBlock = exports.WebAssertNotVisibleBlock = exports.WebAssertVisibleBlock = void 0;
+// Visibility & State
+var WebAssertVisibleBlock_1 = require("./WebAssertVisibleBlock");
+Object.defineProperty(exports, "WebAssertVisibleBlock", { enumerable: true, get: function () { return WebAssertVisibleBlock_1.WebAssertVisibleBlock; } });
+var WebAssertNotVisibleBlock_1 = require("./WebAssertNotVisibleBlock");
+Object.defineProperty(exports, "WebAssertNotVisibleBlock", { enumerable: true, get: function () { return WebAssertNotVisibleBlock_1.WebAssertNotVisibleBlock; } });
+var WebAssertAttachedBlock_1 = require("./WebAssertAttachedBlock");
+Object.defineProperty(exports, "WebAssertAttachedBlock", { enumerable: true, get: function () { return WebAssertAttachedBlock_1.WebAssertAttachedBlock; } });
+var WebAssertEnabledBlock_1 = require("./WebAssertEnabledBlock");
+Object.defineProperty(exports, "WebAssertEnabledBlock", { enumerable: true, get: function () { return WebAssertEnabledBlock_1.WebAssertEnabledBlock; } });
+var WebAssertDisabledBlock_1 = require("./WebAssertDisabledBlock");
+Object.defineProperty(exports, "WebAssertDisabledBlock", { enumerable: true, get: function () { return WebAssertDisabledBlock_1.WebAssertDisabledBlock; } });
+var WebAssertEditableBlock_1 = require("./WebAssertEditableBlock");
+Object.defineProperty(exports, "WebAssertEditableBlock", { enumerable: true, get: function () { return WebAssertEditableBlock_1.WebAssertEditableBlock; } });
+var WebAssertEmptyBlock_1 = require("./WebAssertEmptyBlock");
+Object.defineProperty(exports, "WebAssertEmptyBlock", { enumerable: true, get: function () { return WebAssertEmptyBlock_1.WebAssertEmptyBlock; } });
+var WebAssertFocusedBlock_1 = require("./WebAssertFocusedBlock");
+Object.defineProperty(exports, "WebAssertFocusedBlock", { enumerable: true, get: function () { return WebAssertFocusedBlock_1.WebAssertFocusedBlock; } });
+var WebAssertInViewportBlock_1 = require("./WebAssertInViewportBlock");
+Object.defineProperty(exports, "WebAssertInViewportBlock", { enumerable: true, get: function () { return WebAssertInViewportBlock_1.WebAssertInViewportBlock; } });
+var WebAssertCheckedBlock_1 = require("./WebAssertCheckedBlock");
+Object.defineProperty(exports, "WebAssertCheckedBlock", { enumerable: true, get: function () { return WebAssertCheckedBlock_1.WebAssertCheckedBlock; } });
+// Text & Content
+var WebAssertTextContainsBlock_1 = require("./WebAssertTextContainsBlock");
+Object.defineProperty(exports, "WebAssertTextContainsBlock", { enumerable: true, get: function () { return WebAssertTextContainsBlock_1.WebAssertTextContainsBlock; } });
+var WebAssertTextEqualsBlock_1 = require("./WebAssertTextEqualsBlock");
+Object.defineProperty(exports, "WebAssertTextEqualsBlock", { enumerable: true, get: function () { return WebAssertTextEqualsBlock_1.WebAssertTextEqualsBlock; } });
+var WebAssertValueBlock_1 = require("./WebAssertValueBlock");
+Object.defineProperty(exports, "WebAssertValueBlock", { enumerable: true, get: function () { return WebAssertValueBlock_1.WebAssertValueBlock; } });
+var WebAssertValueContainsBlock_1 = require("./WebAssertValueContainsBlock");
+Object.defineProperty(exports, "WebAssertValueContainsBlock", { enumerable: true, get: function () { return WebAssertValueContainsBlock_1.WebAssertValueContainsBlock; } });
+// Attributes & Properties
+var WebAssertAttributeBlock_1 = require("./WebAssertAttributeBlock");
+Object.defineProperty(exports, "WebAssertAttributeBlock", { enumerable: true, get: function () { return WebAssertAttributeBlock_1.WebAssertAttributeBlock; } });
+var WebAssertClassBlock_1 = require("./WebAssertClassBlock");
+Object.defineProperty(exports, "WebAssertClassBlock", { enumerable: true, get: function () { return WebAssertClassBlock_1.WebAssertClassBlock; } });
+var WebAssertCssBlock_1 = require("./WebAssertCssBlock");
+Object.defineProperty(exports, "WebAssertCssBlock", { enumerable: true, get: function () { return WebAssertCssBlock_1.WebAssertCssBlock; } });
+var WebAssertIdBlock_1 = require("./WebAssertIdBlock");
+Object.defineProperty(exports, "WebAssertIdBlock", { enumerable: true, get: function () { return WebAssertIdBlock_1.WebAssertIdBlock; } });
+var WebAssertCountBlock_1 = require("./WebAssertCountBlock");
+Object.defineProperty(exports, "WebAssertCountBlock", { enumerable: true, get: function () { return WebAssertCountBlock_1.WebAssertCountBlock; } });
+// Accessibility
+var WebAssertAccessibleNameBlock_1 = require("./WebAssertAccessibleNameBlock");
+Object.defineProperty(exports, "WebAssertAccessibleNameBlock", { enumerable: true, get: function () { return WebAssertAccessibleNameBlock_1.WebAssertAccessibleNameBlock; } });
+var WebAssertAccessibleDescriptionBlock_1 = require("./WebAssertAccessibleDescriptionBlock");
+Object.defineProperty(exports, "WebAssertAccessibleDescriptionBlock", { enumerable: true, get: function () { return WebAssertAccessibleDescriptionBlock_1.WebAssertAccessibleDescriptionBlock; } });
+var WebAssertRoleBlock_1 = require("./WebAssertRoleBlock");
+Object.defineProperty(exports, "WebAssertRoleBlock", { enumerable: true, get: function () { return WebAssertRoleBlock_1.WebAssertRoleBlock; } });
+// Page-level
+var WebAssertUrlContainsBlock_1 = require("./WebAssertUrlContainsBlock");
+Object.defineProperty(exports, "WebAssertUrlContainsBlock", { enumerable: true, get: function () { return WebAssertUrlContainsBlock_1.WebAssertUrlContainsBlock; } });
+var WebAssertUrlEqualsBlock_1 = require("./WebAssertUrlEqualsBlock");
+Object.defineProperty(exports, "WebAssertUrlEqualsBlock", { enumerable: true, get: function () { return WebAssertUrlEqualsBlock_1.WebAssertUrlEqualsBlock; } });
+var WebAssertTitleContainsBlock_1 = require("./WebAssertTitleContainsBlock");
+Object.defineProperty(exports, "WebAssertTitleContainsBlock", { enumerable: true, get: function () { return WebAssertTitleContainsBlock_1.WebAssertTitleContainsBlock; } });
+var WebAssertTitleEqualsBlock_1 = require("./WebAssertTitleEqualsBlock");
+Object.defineProperty(exports, "WebAssertTitleEqualsBlock", { enumerable: true, get: function () { return WebAssertTitleEqualsBlock_1.WebAssertTitleEqualsBlock; } });
+// Imports for array
+const WebAssertVisibleBlock_2 = require("./WebAssertVisibleBlock");
+const WebAssertNotVisibleBlock_2 = require("./WebAssertNotVisibleBlock");
+const WebAssertAttachedBlock_2 = require("./WebAssertAttachedBlock");
+const WebAssertEnabledBlock_2 = require("./WebAssertEnabledBlock");
+const WebAssertDisabledBlock_2 = require("./WebAssertDisabledBlock");
+const WebAssertEditableBlock_2 = require("./WebAssertEditableBlock");
+const WebAssertEmptyBlock_2 = require("./WebAssertEmptyBlock");
+const WebAssertFocusedBlock_2 = require("./WebAssertFocusedBlock");
+const WebAssertInViewportBlock_2 = require("./WebAssertInViewportBlock");
+const WebAssertCheckedBlock_2 = require("./WebAssertCheckedBlock");
+const WebAssertTextContainsBlock_2 = require("./WebAssertTextContainsBlock");
+const WebAssertTextEqualsBlock_2 = require("./WebAssertTextEqualsBlock");
+const WebAssertValueBlock_2 = require("./WebAssertValueBlock");
+const WebAssertValueContainsBlock_2 = require("./WebAssertValueContainsBlock");
+const WebAssertAttributeBlock_2 = require("./WebAssertAttributeBlock");
+const WebAssertClassBlock_2 = require("./WebAssertClassBlock");
+const WebAssertCssBlock_2 = require("./WebAssertCssBlock");
+const WebAssertIdBlock_2 = require("./WebAssertIdBlock");
+const WebAssertCountBlock_2 = require("./WebAssertCountBlock");
+const WebAssertAccessibleNameBlock_2 = require("./WebAssertAccessibleNameBlock");
+const WebAssertAccessibleDescriptionBlock_2 = require("./WebAssertAccessibleDescriptionBlock");
+const WebAssertRoleBlock_2 = require("./WebAssertRoleBlock");
+const WebAssertUrlContainsBlock_2 = require("./WebAssertUrlContainsBlock");
+const WebAssertUrlEqualsBlock_2 = require("./WebAssertUrlEqualsBlock");
+const WebAssertTitleContainsBlock_2 = require("./WebAssertTitleContainsBlock");
+const WebAssertTitleEqualsBlock_2 = require("./WebAssertTitleEqualsBlock");
+/**
+ * All assertion block class instances.
+ */
+exports.assertionBlockClasses = [
+    // Visibility & State
+    new WebAssertVisibleBlock_2.WebAssertVisibleBlock(),
+    new WebAssertNotVisibleBlock_2.WebAssertNotVisibleBlock(),
+    new WebAssertAttachedBlock_2.WebAssertAttachedBlock(),
+    new WebAssertEnabledBlock_2.WebAssertEnabledBlock(),
+    new WebAssertDisabledBlock_2.WebAssertDisabledBlock(),
+    new WebAssertEditableBlock_2.WebAssertEditableBlock(),
+    new WebAssertEmptyBlock_2.WebAssertEmptyBlock(),
+    new WebAssertFocusedBlock_2.WebAssertFocusedBlock(),
+    new WebAssertInViewportBlock_2.WebAssertInViewportBlock(),
+    new WebAssertCheckedBlock_2.WebAssertCheckedBlock(),
+    // Text & Content
+    new WebAssertTextContainsBlock_2.WebAssertTextContainsBlock(),
+    new WebAssertTextEqualsBlock_2.WebAssertTextEqualsBlock(),
+    new WebAssertValueBlock_2.WebAssertValueBlock(),
+    new WebAssertValueContainsBlock_2.WebAssertValueContainsBlock(),
+    // Attributes & Properties
+    new WebAssertAttributeBlock_2.WebAssertAttributeBlock(),
+    new WebAssertClassBlock_2.WebAssertClassBlock(),
+    new WebAssertCssBlock_2.WebAssertCssBlock(),
+    new WebAssertIdBlock_2.WebAssertIdBlock(),
+    new WebAssertCountBlock_2.WebAssertCountBlock(),
+    // Accessibility
+    new WebAssertAccessibleNameBlock_2.WebAssertAccessibleNameBlock(),
+    new WebAssertAccessibleDescriptionBlock_2.WebAssertAccessibleDescriptionBlock(),
+    new WebAssertRoleBlock_2.WebAssertRoleBlock(),
+    // Page-level
+    new WebAssertUrlContainsBlock_2.WebAssertUrlContainsBlock(),
+    new WebAssertUrlEqualsBlock_2.WebAssertUrlEqualsBlock(),
+    new WebAssertTitleContainsBlock_2.WebAssertTitleContainsBlock(),
+    new WebAssertTitleEqualsBlock_2.WebAssertTitleEqualsBlock(),
+];
+/**
+ * Assertion blocks as BlockDefinition array for backward compatibility.
+ */
+exports.assertionBlocks = exports.assertionBlockClasses.map(block => block.toDefinition());

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

@@ -8,10 +8,26 @@
  * - assertions: Visibility, text, value, URL, title assertions
  */
 import { BlockDefinition } from '../../types';
+import { Block } from '../base';
 export * from './types';
 export * from './utils';
 export { navigationBlocks } from './navigation';
 export { interactionBlocks } from './interactions';
 export { retrievalBlocks } from './retrieval';
 export { assertionBlocks } from './assertions';
+export { navigationBlockClasses } from './navigation';
+export { interactionBlockClasses } from './interactions';
+export { retrievalBlockClasses } from './retrieval';
+export { assertionBlockClasses } from './assertions';
+export * from './navigation';
+export * from './interactions';
+export * from './retrieval';
+export * from './assertions';
+/**
+ * All Playwright block class instances.
+ */
+export declare const playwrightBlockClasses: Block[];
+/**
+ * Combined export of all Playwright blocks (BlockDefinition array for backward compatibility).
+ */
 export declare const playwrightBlocks: BlockDefinition[];

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

@@ -23,7 +23,7 @@ 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;
+exports.playwrightBlocks = exports.playwrightBlockClasses = exports.assertionBlockClasses = exports.retrievalBlockClasses = exports.interactionBlockClasses = exports.navigationBlockClasses = 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");
@@ -31,7 +31,7 @@ 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
+// Re-export individual block categories (BlockDefinition arrays)
 var navigation_2 = require("./navigation");
 Object.defineProperty(exports, "navigationBlocks", { enumerable: true, get: function () { return navigation_2.navigationBlocks; } });
 var interactions_2 = require("./interactions");
@@ -40,7 +40,32 @@ 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
+// Re-export block class arrays
+var navigation_3 = require("./navigation");
+Object.defineProperty(exports, "navigationBlockClasses", { enumerable: true, get: function () { return navigation_3.navigationBlockClasses; } });
+var interactions_3 = require("./interactions");
+Object.defineProperty(exports, "interactionBlockClasses", { enumerable: true, get: function () { return interactions_3.interactionBlockClasses; } });
+var retrieval_3 = require("./retrieval");
+Object.defineProperty(exports, "retrievalBlockClasses", { enumerable: true, get: function () { return retrieval_3.retrievalBlockClasses; } });
+var assertions_3 = require("./assertions");
+Object.defineProperty(exports, "assertionBlockClasses", { enumerable: true, get: function () { return assertions_3.assertionBlockClasses; } });
+// Re-export individual block classes
+__exportStar(require("./navigation"), exports);
+__exportStar(require("./interactions"), exports);
+__exportStar(require("./retrieval"), exports);
+__exportStar(require("./assertions"), exports);
+/**
+ * All Playwright block class instances.
+ */
+exports.playwrightBlockClasses = [
+    ...navigation_1.navigationBlockClasses,
+    ...interactions_1.interactionBlockClasses,
+    ...retrieval_1.retrievalBlockClasses,
+    ...assertions_1.assertionBlockClasses,
+];
+/**
+ * Combined export of all Playwright blocks (BlockDefinition array for backward compatibility).
+ */
 exports.playwrightBlocks = [
     ...navigation_1.navigationBlocks,
     ...interactions_1.interactionBlocks,

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Check or uncheck a checkbox (auto-waits).
+ */
+export declare class WebCheckboxBlock extends StatementBlock {
+    readonly type = "web_checkbox";
+    readonly category = "Web";
+    readonly color = "#E91E63";
+    readonly tooltip = "Check or uncheck a checkbox (auto-waits)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebCheckboxBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Check or uncheck a checkbox (auto-waits).
+ */
+class WebCheckboxBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_checkbox';
+        this.category = 'Web';
+        this.color = '#E91E63';
+        this.tooltip = 'Check or uncheck a checkbox (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'ACTION', type: 'field', fieldType: 'dropdown', options: [['Check', 'check'], ['Uncheck', 'uncheck']] },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const selector = (0, utils_1.resolveSelector)(params, context);
+        const action = params.ACTION;
+        const timeout = (0, utils_1.getTimeout)(context);
+        context.logger.info(`${action === 'check' ? 'Checking' : 'Unchecking'} ${selector}`);
+        const locator = page.locator(selector);
+        if (action === 'check') {
+            await locator.check({ timeout });
+        }
+        else {
+            await locator.uncheck({ timeout });
+        }
+        return {
+            _summary: `${action} ${params.SELECTOR}`,
+            selector,
+            action,
+        };
+    }
+}
+exports.WebCheckboxBlock = WebCheckboxBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Click on an element (auto-waits for element to be visible and stable).
+ */
+export declare class WebClickBlock extends StatementBlock {
+    readonly type = "web_click";
+    readonly category = "Web";
+    readonly color = "#E91E63";
+    readonly tooltip = "Click on an element (auto-waits for element to be visible and stable)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebClickBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Click on an element (auto-waits for element to be visible and stable).
+ */
+class WebClickBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_click';
+        this.category = 'Web';
+        this.color = '#E91E63';
+        this.tooltip = 'Click on an element (auto-waits for element to be visible and stable)';
+    }
+    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 timeout = (0, utils_1.getTimeout)(context);
+        context.logger.info(`Clicking: ${selector}`);
+        await page.locator(selector).click({ timeout });
+        return {
+            _summary: params.SELECTOR,
+            selector,
+        };
+    }
+}
+exports.WebClickBlock = WebClickBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Drag an element and drop it onto another element (auto-waits).
+ */
+export declare class WebDragAndDropBlock extends StatementBlock {
+    readonly type = "web_drag_and_drop";
+    readonly category = "Web";
+    readonly color = "#E91E63";
+    readonly tooltip = "Drag an element and drop it onto another element (auto-waits)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebDragAndDropBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Drag an element and drop it onto another element (auto-waits).
+ */
+class WebDragAndDropBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_drag_and_drop';
+        this.category = 'Web';
+        this.color = '#E91E63';
+        this.tooltip = 'Drag an element and drop it onto another element (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'TARGET', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const sourceSelector = (0, utils_1.resolveSelector)(params, context);
+        const targetSelector = (0, utils_1.resolveSelector)({ SELECTOR: params.TARGET }, context);
+        const timeout = (0, utils_1.getTimeout)(context);
+        context.logger.info(`Dragging ${sourceSelector} to ${targetSelector}`);
+        await page.locator(sourceSelector).dragTo(page.locator(targetSelector), { timeout });
+        return {
+            _summary: `${params.SELECTOR} → ${params.TARGET}`,
+            sourceSelector,
+            targetSelector,
+        };
+    }
+}
+exports.WebDragAndDropBlock = WebDragAndDropBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Fill an input field (clears existing value, auto-waits).
+ */
+export declare class WebFillBlock extends StatementBlock {
+    readonly type = "web_fill";
+    readonly category = "Web";
+    readonly color = "#E91E63";
+    readonly tooltip = "Fill an input field (clears existing value, auto-waits)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}