@testsmith/testblocks 0.9.4 → 0.9.7

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertAttachedBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that an element is attached to the DOM (auto-waits).
+ */
+class WebAssertAttachedBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_attached';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that an element is attached to the DOM (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 attached`);
+        await (0, utils_1.executeWebAssertion)(context, async () => { await expect(locator).toBeAttached({ timeout }); }, `Expected element ${displaySelector} to be attached`, { stepType: 'web_assert_attached', expected: 'attached', actual: 'detached' });
+        context.logger.info(`✓ Element ${displaySelector} is attached`);
+        return {
+            _summary: `${displaySelector} is attached`,
+            selector,
+            isAttached: true,
+        };
+    }
+}
+exports.WebAssertAttachedBlock = WebAssertAttachedBlock;

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertClassBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that an element has a specific CSS class (auto-waits).
+ */
+class WebAssertClassBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_class';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that an element has a specific CSS class (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'CLASS', 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 expectedClass = (0, utils_1.resolveVariables)(params.CLASS, context);
+        const timeout = (0, utils_1.getTimeout)(context);
+        const expect = await (0, utils_1.getExpect)();
+        const locator = page.locator(selector);
+        // Use regex to match class anywhere in the class attribute
+        const classPattern = new RegExp(`(^|\\s)${expectedClass}($|\\s)`);
+        context.logger.info(`Asserting ${displaySelector} has class "${expectedClass}"`);
+        await (0, utils_1.executeWebAssertion)(context, async () => { await expect(locator).toHaveClass(classPattern, { timeout }); }, `Expected element ${displaySelector} to have class "${expectedClass}"`, { stepType: 'web_assert_class', expected: expectedClass });
+        context.logger.info(`✓ Element ${displaySelector} has class "${expectedClass}"`);
+        return {
+            _summary: `has class "${expectedClass}"`,
+            selector,
+            expectedClass,
+        };
+    }
+}
+exports.WebAssertClassBlock = WebAssertClassBlock;

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

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

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertCountBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that a selector matches a specific number of elements (auto-waits).
+ */
+class WebAssertCountBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_count';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that a selector matches a specific number of elements (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'COUNT', type: 'field', fieldType: 'number', required: true, default: 1 },
+        ];
+    }
+    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 expectedCount = params.COUNT;
+        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 count ${expectedCount}`);
+        await (0, utils_1.executeWebAssertion)(context, async () => { await expect(locator).toHaveCount(expectedCount, { timeout }); }, `Expected ${displaySelector} to have ${expectedCount} elements`, { stepType: 'web_assert_count', expected: expectedCount });
+        context.logger.info(`✓ Selector ${displaySelector} has ${expectedCount} elements`);
+        return {
+            _summary: `${expectedCount} elements`,
+            selector,
+            expectedCount,
+        };
+    }
+}
+exports.WebAssertCountBlock = WebAssertCountBlock;

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

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

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

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

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

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

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertDisabledBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that an element is disabled (auto-waits).
+ */
+class WebAssertDisabledBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_disabled';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that an element is disabled (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 disabled`);
+        await (0, utils_1.executeWebAssertion)(context, async () => { await expect(locator).toBeDisabled({ timeout }); }, `Expected element ${displaySelector} to be disabled`, { stepType: 'web_assert_disabled', expected: 'disabled', actual: 'enabled' });
+        context.logger.info(`✓ Element ${displaySelector} is disabled`);
+        return {
+            _summary: `${displaySelector} is disabled`,
+            selector,
+            isDisabled: true,
+        };
+    }
+}
+exports.WebAssertDisabledBlock = WebAssertDisabledBlock;

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

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

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

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

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

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

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebAssertEmptyBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Assert that a container element is empty (auto-waits).
+ */
+class WebAssertEmptyBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_assert_empty';
+        this.category = 'Web';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert that a container element is empty (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 empty`);
+        await (0, utils_1.executeWebAssertion)(context, async () => { await expect(locator).toBeEmpty({ timeout }); }, `Expected element ${displaySelector} to be empty`, { stepType: 'web_assert_empty', expected: 'empty', actual: 'not empty' });
+        context.logger.info(`✓ Element ${displaySelector} is empty`);
+        return {
+            _summary: `${displaySelector} is empty`,
+            selector,
+            isEmpty: true,
+        };
+    }
+}
+exports.WebAssertEmptyBlock = WebAssertEmptyBlock;

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

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