@testsmith/testblocks 0.9.4 → 0.9.7

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebFillBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Fill an input field (clears existing value, auto-waits).
+ */
+class WebFillBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_fill';
+        this.category = 'Web';
+        this.color = '#E91E63';
+        this.tooltip = 'Fill an input field (clears existing 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 value = (0, utils_1.resolveVariables)(params.VALUE, context);
+        const timeout = (0, utils_1.getTimeout)(context);
+        context.logger.info(`Filling ${selector} with "${value}"`);
+        await page.locator(selector).fill(value, { timeout });
+        const displayValue = value.length > 30 ? value.substring(0, 30) + '...' : value;
+        return {
+            _summary: `${params.SELECTOR} = "${displayValue}"`,
+            selector,
+            value,
+        };
+    }
+}
+exports.WebFillBlock = WebFillBlock;

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebPressKeyBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Press a keyboard key (auto-waits).
+ */
+class WebPressKeyBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_press_key';
+        this.category = 'Web';
+        this.color = '#E91E63';
+        this.tooltip = 'Press a keyboard key (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'KEY', type: 'field', fieldType: 'dropdown', options: [['Enter', 'Enter'], ['Tab', 'Tab'], ['Escape', 'Escape'], ['Backspace', 'Backspace'], ['ArrowUp', 'ArrowUp'], ['ArrowDown', 'ArrowDown'], ['ArrowLeft', 'ArrowLeft'], ['ArrowRight', 'ArrowRight']] },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const selector = (0, utils_1.resolveSelector)(params, context);
+        const key = params.KEY;
+        const timeout = (0, utils_1.getTimeout)(context);
+        context.logger.info(`Pressing ${key} on ${selector}`);
+        await page.locator(selector).press(key, { timeout });
+        return {
+            _summary: `${key} on ${params.SELECTOR}`,
+            selector,
+            key,
+        };
+    }
+}
+exports.WebPressKeyBlock = WebPressKeyBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Scroll an element into view if needed (auto-waits for element to be attached).
+ */
+export declare class WebScrollIntoViewBlock extends StatementBlock {
+    readonly type = "web_scroll_into_view";
+    readonly category = "Web";
+    readonly color = "#E91E63";
+    readonly tooltip = "Scroll an element into view if needed (auto-waits for element to be attached)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebScrollIntoViewBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Scroll an element into view if needed (auto-waits for element to be attached).
+ */
+class WebScrollIntoViewBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_scroll_into_view';
+        this.category = 'Web';
+        this.color = '#E91E63';
+        this.tooltip = 'Scroll an element into view if needed (auto-waits for element to be attached)';
+    }
+    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(`Scrolling ${selector} into view`);
+        await page.locator(selector).scrollIntoViewIfNeeded({ timeout });
+        return {
+            _summary: params.SELECTOR,
+            selector,
+        };
+    }
+}
+exports.WebScrollIntoViewBlock = WebScrollIntoViewBlock;

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

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

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSelectBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Select an option from a dropdown (auto-waits).
+ */
+class WebSelectBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_select';
+        this.category = 'Web';
+        this.color = '#E91E63';
+        this.tooltip = 'Select an option from a dropdown (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 value = (0, utils_1.resolveVariables)(params.VALUE, context);
+        const timeout = (0, utils_1.getTimeout)(context);
+        context.logger.info(`Selecting "${value}" in ${selector}`);
+        await page.locator(selector).selectOption(value, { timeout });
+        return {
+            _summary: `${params.SELECTOR} = "${value}"`,
+            selector,
+            value,
+        };
+    }
+}
+exports.WebSelectBlock = WebSelectBlock;

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

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

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebTypeBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Type text character by character (auto-waits).
+ */
+class WebTypeBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_type';
+        this.category = 'Web';
+        this.color = '#E91E63';
+        this.tooltip = 'Type text character by character (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'TEXT', type: 'field', fieldType: 'text', required: true },
+            { name: 'DELAY', type: 'field', fieldType: 'number', default: 50 },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const selector = (0, utils_1.resolveSelector)(params, context);
+        const text = (0, utils_1.resolveVariables)(params.TEXT, context);
+        const delay = params.DELAY;
+        const timeout = (0, utils_1.getTimeout)(context);
+        context.logger.info(`Typing "${text}" into ${selector}`);
+        await page.locator(selector).pressSequentially(text, { delay, timeout });
+        const displayText = text.length > 30 ? text.substring(0, 30) + '...' : text;
+        return {
+            _summary: `${params.SELECTOR} = "${displayText}"`,
+            selector,
+            text,
+            delay,
+        };
+    }
+}
+exports.WebTypeBlock = WebTypeBlock;

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

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

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebUploadFileBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Upload a file to a file input element (auto-waits).
+ */
+class WebUploadFileBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_upload_file';
+        this.category = 'Web';
+        this.color = '#E91E63';
+        this.tooltip = 'Upload a file to a file input element (auto-waits)';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'FILE_PATH', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const selector = (0, utils_1.resolveSelector)(params, context);
+        const filePath = (0, utils_1.resolveVariables)(params.FILE_PATH, context);
+        const timeout = (0, utils_1.getTimeout)(context);
+        context.logger.info(`Uploading file "${filePath}" to ${selector}`);
+        await page.locator(selector).setInputFiles(filePath, { timeout });
+        const fileName = filePath.split(/[/\\]/).pop() || filePath;
+        return {
+            _summary: `${params.SELECTOR} <- "${fileName}"`,
+            selector,
+            filePath,
+            fileName,
+        };
+    }
+}
+exports.WebUploadFileBlock = WebUploadFileBlock;

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

@@ -0,0 +1,21 @@
+import { Block } from '../../base';
+import { BlockDefinition } from '../../../types';
+export { WebClickBlock } from './WebClickBlock';
+export { WebFillBlock } from './WebFillBlock';
+export { WebTypeBlock } from './WebTypeBlock';
+export { WebPressKeyBlock } from './WebPressKeyBlock';
+export { WebSelectBlock } from './WebSelectBlock';
+export { WebCheckboxBlock } from './WebCheckboxBlock';
+export { WebHoverBlock } from './WebHoverBlock';
+export { WebUploadFileBlock } from './WebUploadFileBlock';
+export { WebFocusBlock } from './WebFocusBlock';
+export { WebDragAndDropBlock } from './WebDragAndDropBlock';
+export { WebScrollIntoViewBlock } from './WebScrollIntoViewBlock';
+/**
+ * All interaction block class instances.
+ */
+export declare const interactionBlockClasses: Block[];
+/**
+ * Interaction blocks as BlockDefinition array for backward compatibility.
+ */
+export declare const interactionBlocks: BlockDefinition[];

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interactionBlocks = exports.interactionBlockClasses = exports.WebScrollIntoViewBlock = exports.WebDragAndDropBlock = exports.WebFocusBlock = exports.WebUploadFileBlock = exports.WebHoverBlock = exports.WebCheckboxBlock = exports.WebSelectBlock = exports.WebPressKeyBlock = exports.WebTypeBlock = exports.WebFillBlock = exports.WebClickBlock = void 0;
+var WebClickBlock_1 = require("./WebClickBlock");
+Object.defineProperty(exports, "WebClickBlock", { enumerable: true, get: function () { return WebClickBlock_1.WebClickBlock; } });
+var WebFillBlock_1 = require("./WebFillBlock");
+Object.defineProperty(exports, "WebFillBlock", { enumerable: true, get: function () { return WebFillBlock_1.WebFillBlock; } });
+var WebTypeBlock_1 = require("./WebTypeBlock");
+Object.defineProperty(exports, "WebTypeBlock", { enumerable: true, get: function () { return WebTypeBlock_1.WebTypeBlock; } });
+var WebPressKeyBlock_1 = require("./WebPressKeyBlock");
+Object.defineProperty(exports, "WebPressKeyBlock", { enumerable: true, get: function () { return WebPressKeyBlock_1.WebPressKeyBlock; } });
+var WebSelectBlock_1 = require("./WebSelectBlock");
+Object.defineProperty(exports, "WebSelectBlock", { enumerable: true, get: function () { return WebSelectBlock_1.WebSelectBlock; } });
+var WebCheckboxBlock_1 = require("./WebCheckboxBlock");
+Object.defineProperty(exports, "WebCheckboxBlock", { enumerable: true, get: function () { return WebCheckboxBlock_1.WebCheckboxBlock; } });
+var WebHoverBlock_1 = require("./WebHoverBlock");
+Object.defineProperty(exports, "WebHoverBlock", { enumerable: true, get: function () { return WebHoverBlock_1.WebHoverBlock; } });
+var WebUploadFileBlock_1 = require("./WebUploadFileBlock");
+Object.defineProperty(exports, "WebUploadFileBlock", { enumerable: true, get: function () { return WebUploadFileBlock_1.WebUploadFileBlock; } });
+var WebFocusBlock_1 = require("./WebFocusBlock");
+Object.defineProperty(exports, "WebFocusBlock", { enumerable: true, get: function () { return WebFocusBlock_1.WebFocusBlock; } });
+var WebDragAndDropBlock_1 = require("./WebDragAndDropBlock");
+Object.defineProperty(exports, "WebDragAndDropBlock", { enumerable: true, get: function () { return WebDragAndDropBlock_1.WebDragAndDropBlock; } });
+var WebScrollIntoViewBlock_1 = require("./WebScrollIntoViewBlock");
+Object.defineProperty(exports, "WebScrollIntoViewBlock", { enumerable: true, get: function () { return WebScrollIntoViewBlock_1.WebScrollIntoViewBlock; } });
+const WebClickBlock_2 = require("./WebClickBlock");
+const WebFillBlock_2 = require("./WebFillBlock");
+const WebTypeBlock_2 = require("./WebTypeBlock");
+const WebPressKeyBlock_2 = require("./WebPressKeyBlock");
+const WebSelectBlock_2 = require("./WebSelectBlock");
+const WebCheckboxBlock_2 = require("./WebCheckboxBlock");
+const WebHoverBlock_2 = require("./WebHoverBlock");
+const WebUploadFileBlock_2 = require("./WebUploadFileBlock");
+const WebFocusBlock_2 = require("./WebFocusBlock");
+const WebDragAndDropBlock_2 = require("./WebDragAndDropBlock");
+const WebScrollIntoViewBlock_2 = require("./WebScrollIntoViewBlock");
+/**
+ * All interaction block class instances.
+ */
+exports.interactionBlockClasses = [
+    new WebClickBlock_2.WebClickBlock(),
+    new WebFillBlock_2.WebFillBlock(),
+    new WebTypeBlock_2.WebTypeBlock(),
+    new WebPressKeyBlock_2.WebPressKeyBlock(),
+    new WebSelectBlock_2.WebSelectBlock(),
+    new WebCheckboxBlock_2.WebCheckboxBlock(),
+    new WebHoverBlock_2.WebHoverBlock(),
+    new WebUploadFileBlock_2.WebUploadFileBlock(),
+    new WebFocusBlock_2.WebFocusBlock(),
+    new WebDragAndDropBlock_2.WebDragAndDropBlock(),
+    new WebScrollIntoViewBlock_2.WebScrollIntoViewBlock(),
+];
+/**
+ * Interaction blocks as BlockDefinition array for backward compatibility.
+ */
+exports.interactionBlocks = exports.interactionBlockClasses.map(block => block.toDefinition());

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Navigate to a URL.
+ */
+export declare class WebNavigateBlock extends StatementBlock {
+    readonly type = "web_navigate";
+    readonly category = "Web";
+    readonly color = "#E91E63";
+    readonly tooltip = "Navigate to a URL";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/playwright/navigation/WebNavigateBlock.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebNavigateBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Navigate to a URL.
+ */
+class WebNavigateBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_navigate';
+        this.category = 'Web';
+        this.color = '#E91E63';
+        this.tooltip = 'Navigate to a URL';
+    }
+    getInputs() {
+        return [
+            { name: 'URL', type: 'field', fieldType: 'text', required: true },
+            { name: 'WAIT_UNTIL', type: 'field', fieldType: 'dropdown', options: [['Load', 'load'], ['DOM Content Loaded', 'domcontentloaded'], ['Network Idle', 'networkidle']], default: 'load' },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const url = (0, utils_1.resolveVariables)(params.URL, context);
+        const waitUntil = params.WAIT_UNTIL;
+        context.logger.info(`Navigating to ${url}`);
+        await page.goto(url, { waitUntil });
+        return {
+            _summary: url,
+            url,
+            waitUntil,
+        };
+    }
+}
+exports.WebNavigateBlock = WebNavigateBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Take a screenshot.
+ */
+export declare class WebScreenshotBlock extends StatementBlock {
+    readonly type = "web_screenshot";
+    readonly category = "Web";
+    readonly color = "#607D8B";
+    readonly tooltip = "Take a screenshot";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/playwright/navigation/WebScreenshotBlock.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebScreenshotBlock = void 0;
+const base_1 = require("../../base");
+/**
+ * Take a screenshot.
+ */
+class WebScreenshotBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_screenshot';
+        this.category = 'Web';
+        this.color = '#607D8B';
+        this.tooltip = 'Take a screenshot';
+    }
+    getInputs() {
+        return [
+            { name: 'NAME', type: 'field', fieldType: 'text', default: 'screenshot' },
+            { name: 'FULL_PAGE', type: 'field', fieldType: 'checkbox', default: false },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const name = params.NAME;
+        const fullPage = params.FULL_PAGE;
+        context.logger.info(`Taking screenshot: ${name}`);
+        const buffer = await page.screenshot({ fullPage });
+        return {
+            _summary: `${name}${fullPage ? ' (full page)' : ''}`,
+            name,
+            fullPage,
+            buffer: buffer.toString('base64'),
+        };
+    }
+}
+exports.WebScreenshotBlock = WebScreenshotBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Wait for a specified time.
+ */
+export declare class WebWaitBlock extends StatementBlock {
+    readonly type = "web_wait";
+    readonly category = "Web";
+    readonly color = "#9C27B0";
+    readonly tooltip = "Wait for a specified time";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/playwright/navigation/WebWaitBlock.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebWaitBlock = void 0;
+const base_1 = require("../../base");
+/**
+ * Wait for a specified time.
+ */
+class WebWaitBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_wait';
+        this.category = 'Web';
+        this.color = '#9C27B0';
+        this.tooltip = 'Wait for a specified time';
+    }
+    getInputs() {
+        return [
+            { name: 'MILLISECONDS', type: 'field', fieldType: 'number', default: 1000 },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const ms = params.MILLISECONDS;
+        context.logger.info(`Waiting ${ms}ms`);
+        await page.waitForTimeout(ms);
+        return {
+            _summary: `${ms}ms`,
+            milliseconds: ms,
+        };
+    }
+}
+exports.WebWaitBlock = WebWaitBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Wait for an element to appear/disappear.
+ */
+export declare class WebWaitForElementBlock extends StatementBlock {
+    readonly type = "web_wait_for_element";
+    readonly category = "Web";
+    readonly color = "#9C27B0";
+    readonly tooltip = "Wait for an element to appear/disappear";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}