@testsmith/testblocks 0.9.4 → 0.9.7

package/dist/core/blocks/api/ApiPostBlock.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiPostBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Perform HTTP POST request and store response.
+ */
+class ApiPostBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'api_post';
+        this.category = 'API';
+        this.color = '#4CAF50';
+        this.tooltip = 'Perform HTTP POST request and store response';
+    }
+    getInputs() {
+        return [
+            { name: 'URL', type: 'field', fieldType: 'text', required: true },
+            { name: 'BODY', type: 'field', fieldType: 'text', default: '{}' },
+            { name: 'HEADERS', type: 'field', fieldType: 'text', default: '' },
+        ];
+    }
+    async execute(params, context) {
+        const url = (0, utils_1.resolveVariables)(params.URL, context);
+        const bodyStr = (0, utils_1.resolveVariables)(params.BODY || '{}', context);
+        const inlineHeaders = (0, utils_1.mergeHeaders)(context, params.HEADERS);
+        let body;
+        try {
+            body = JSON.parse(bodyStr);
+        }
+        catch {
+            body = bodyStr;
+        }
+        context.logger.info(`POST ${url}`);
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...inlineHeaders },
+            body: typeof body === 'string' ? body : JSON.stringify(body),
+            signal: context.abortSignal,
+        });
+        const parsed = await (0, utils_1.parseResponse)(response);
+        (0, utils_1.storeResponse)(context, parsed);
+        return parsed;
+    }
+}
+exports.ApiPostBlock = ApiPostBlock;

package/dist/core/blocks/api/ApiPutBlock.d.ts

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Perform HTTP PUT request and store response.
+ */
+export declare class ApiPutBlock extends StatementBlock {
+    readonly type = "api_put";
+    readonly category = "API";
+    readonly color = "#4CAF50";
+    readonly tooltip = "Perform HTTP PUT request and store response";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/api/ApiPutBlock.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiPutBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Perform HTTP PUT request and store response.
+ */
+class ApiPutBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'api_put';
+        this.category = 'API';
+        this.color = '#4CAF50';
+        this.tooltip = 'Perform HTTP PUT request and store response';
+    }
+    getInputs() {
+        return [
+            { name: 'URL', type: 'field', fieldType: 'text', required: true },
+            { name: 'BODY', type: 'field', fieldType: 'text', default: '{}' },
+            { name: 'HEADERS', type: 'field', fieldType: 'text', default: '' },
+        ];
+    }
+    async execute(params, context) {
+        const url = (0, utils_1.resolveVariables)(params.URL, context);
+        const bodyStr = (0, utils_1.resolveVariables)(params.BODY || '{}', context);
+        const inlineHeaders = (0, utils_1.mergeHeaders)(context, params.HEADERS);
+        let body;
+        try {
+            body = JSON.parse(bodyStr);
+        }
+        catch {
+            body = bodyStr;
+        }
+        context.logger.info(`PUT ${url}`);
+        const response = await fetch(url, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json', ...inlineHeaders },
+            body: typeof body === 'string' ? body : JSON.stringify(body),
+            signal: context.abortSignal,
+        });
+        const parsed = await (0, utils_1.parseResponse)(response);
+        (0, utils_1.storeResponse)(context, parsed);
+        return parsed;
+    }
+}
+exports.ApiPutBlock = ApiPutBlock;

package/dist/core/blocks/api/ApiSetHeaderBlock.d.ts

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Set a single request header that applies to subsequent requests.
+ */
+export declare class ApiSetHeaderBlock extends StatementBlock {
+    readonly type = "api_set_header";
+    readonly category = "API";
+    readonly color = "#7B1FA2";
+    readonly tooltip = "Set a request header (applies to subsequent requests)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/api/ApiSetHeaderBlock.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiSetHeaderBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Set a single request header that applies to subsequent requests.
+ */
+class ApiSetHeaderBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'api_set_header';
+        this.category = 'API';
+        this.color = '#7B1FA2';
+        this.tooltip = 'Set a request header (applies to subsequent requests)';
+    }
+    getInputs() {
+        return [
+            { name: 'NAME', type: 'field', fieldType: 'text', required: true, default: 'Authorization' },
+            { name: 'VALUE', type: 'field', fieldType: 'text', required: true, default: 'Bearer token' },
+        ];
+    }
+    async execute(params, context) {
+        const name = params.NAME;
+        const value = (0, utils_1.resolveVariables)(params.VALUE, context);
+        const headers = (0, utils_1.getContextHeaders)(context);
+        headers[name] = value;
+        (0, utils_1.setContextHeaders)(context, headers);
+        context.logger.info(`Set header: ${name}: ${value.substring(0, 30)}${value.length > 30 ? '...' : ''}`);
+        return {
+            _summary: `${name}: ${value.substring(0, 30)}${value.length > 30 ? '...' : ''}`,
+            name,
+            value,
+        };
+    }
+}
+exports.ApiSetHeaderBlock = ApiSetHeaderBlock;

package/dist/core/blocks/api/ApiSetHeadersBlock.d.ts

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Set multiple request headers from a JSON object.
+ */
+export declare class ApiSetHeadersBlock extends StatementBlock {
+    readonly type = "api_set_headers";
+    readonly category = "API";
+    readonly color = "#7B1FA2";
+    readonly tooltip = "Set multiple request headers from JSON object";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/api/ApiSetHeadersBlock.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiSetHeadersBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Set multiple request headers from a JSON object.
+ */
+class ApiSetHeadersBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'api_set_headers';
+        this.category = 'API';
+        this.color = '#7B1FA2';
+        this.tooltip = 'Set multiple request headers from JSON object';
+    }
+    getInputs() {
+        return [
+            { name: 'HEADERS', type: 'field', fieldType: 'text', required: true, default: '{"Content-Type": "application/json"}' },
+        ];
+    }
+    async execute(params, context) {
+        const headersStr = (0, utils_1.resolveVariables)(params.HEADERS, context);
+        try {
+            const newHeaders = JSON.parse(headersStr);
+            const headers = (0, utils_1.getContextHeaders)(context);
+            Object.assign(headers, newHeaders);
+            (0, utils_1.setContextHeaders)(context, headers);
+            const headerNames = Object.keys(newHeaders).join(', ');
+            context.logger.info(`Set headers: ${headerNames}`);
+            return {
+                _summary: `Set ${Object.keys(newHeaders).length} headers`,
+                headers: newHeaders,
+            };
+        }
+        catch {
+            throw new Error(`Invalid JSON for headers: ${headersStr}`);
+        }
+    }
+}
+exports.ApiSetHeadersBlock = ApiSetHeadersBlock;

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

@@ -0,0 +1,25 @@
+import { Block } from '../base';
+import { BlockDefinition } from '../../types';
+export { ApiSetHeaderBlock } from './ApiSetHeaderBlock';
+export { ApiSetHeadersBlock } from './ApiSetHeadersBlock';
+export { ApiClearHeadersBlock } from './ApiClearHeadersBlock';
+export { ApiGetBlock } from './ApiGetBlock';
+export { ApiPostBlock } from './ApiPostBlock';
+export { ApiPutBlock } from './ApiPutBlock';
+export { ApiPatchBlock } from './ApiPatchBlock';
+export { ApiDeleteBlock } from './ApiDeleteBlock';
+export { ApiAssertStatusBlock } from './ApiAssertStatusBlock';
+export { ApiAssertBodyContainsBlock } from './ApiAssertBodyContainsBlock';
+export { ApiExtractJsonPathBlock } from './ApiExtractJsonPathBlock';
+export { ApiExtractXPathBlock } from './ApiExtractXPathBlock';
+export { ApiExtractBlock } from './ApiExtractBlock';
+export { ApiHeadersBlock } from './ApiHeadersBlock';
+export { ApiJsonBodyBlock } from './ApiJsonBodyBlock';
+/**
+ * All API block class instances.
+ */
+export declare const apiBlockClasses: Block[];
+/**
+ * API blocks as BlockDefinition array for backward compatibility.
+ */
+export declare const apiBlocks: BlockDefinition[];

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiBlocks = exports.apiBlockClasses = exports.ApiJsonBodyBlock = exports.ApiHeadersBlock = exports.ApiExtractBlock = exports.ApiExtractXPathBlock = exports.ApiExtractJsonPathBlock = exports.ApiAssertBodyContainsBlock = exports.ApiAssertStatusBlock = exports.ApiDeleteBlock = exports.ApiPatchBlock = exports.ApiPutBlock = exports.ApiPostBlock = exports.ApiGetBlock = exports.ApiClearHeadersBlock = exports.ApiSetHeadersBlock = exports.ApiSetHeaderBlock = void 0;
+// Header management blocks
+var ApiSetHeaderBlock_1 = require("./ApiSetHeaderBlock");
+Object.defineProperty(exports, "ApiSetHeaderBlock", { enumerable: true, get: function () { return ApiSetHeaderBlock_1.ApiSetHeaderBlock; } });
+var ApiSetHeadersBlock_1 = require("./ApiSetHeadersBlock");
+Object.defineProperty(exports, "ApiSetHeadersBlock", { enumerable: true, get: function () { return ApiSetHeadersBlock_1.ApiSetHeadersBlock; } });
+var ApiClearHeadersBlock_1 = require("./ApiClearHeadersBlock");
+Object.defineProperty(exports, "ApiClearHeadersBlock", { enumerable: true, get: function () { return ApiClearHeadersBlock_1.ApiClearHeadersBlock; } });
+// HTTP method blocks
+var ApiGetBlock_1 = require("./ApiGetBlock");
+Object.defineProperty(exports, "ApiGetBlock", { enumerable: true, get: function () { return ApiGetBlock_1.ApiGetBlock; } });
+var ApiPostBlock_1 = require("./ApiPostBlock");
+Object.defineProperty(exports, "ApiPostBlock", { enumerable: true, get: function () { return ApiPostBlock_1.ApiPostBlock; } });
+var ApiPutBlock_1 = require("./ApiPutBlock");
+Object.defineProperty(exports, "ApiPutBlock", { enumerable: true, get: function () { return ApiPutBlock_1.ApiPutBlock; } });
+var ApiPatchBlock_1 = require("./ApiPatchBlock");
+Object.defineProperty(exports, "ApiPatchBlock", { enumerable: true, get: function () { return ApiPatchBlock_1.ApiPatchBlock; } });
+var ApiDeleteBlock_1 = require("./ApiDeleteBlock");
+Object.defineProperty(exports, "ApiDeleteBlock", { enumerable: true, get: function () { return ApiDeleteBlock_1.ApiDeleteBlock; } });
+// Assertion blocks
+var ApiAssertStatusBlock_1 = require("./ApiAssertStatusBlock");
+Object.defineProperty(exports, "ApiAssertStatusBlock", { enumerable: true, get: function () { return ApiAssertStatusBlock_1.ApiAssertStatusBlock; } });
+var ApiAssertBodyContainsBlock_1 = require("./ApiAssertBodyContainsBlock");
+Object.defineProperty(exports, "ApiAssertBodyContainsBlock", { enumerable: true, get: function () { return ApiAssertBodyContainsBlock_1.ApiAssertBodyContainsBlock; } });
+// Extraction blocks
+var ApiExtractJsonPathBlock_1 = require("./ApiExtractJsonPathBlock");
+Object.defineProperty(exports, "ApiExtractJsonPathBlock", { enumerable: true, get: function () { return ApiExtractJsonPathBlock_1.ApiExtractJsonPathBlock; } });
+var ApiExtractXPathBlock_1 = require("./ApiExtractXPathBlock");
+Object.defineProperty(exports, "ApiExtractXPathBlock", { enumerable: true, get: function () { return ApiExtractXPathBlock_1.ApiExtractXPathBlock; } });
+var ApiExtractBlock_1 = require("./ApiExtractBlock");
+Object.defineProperty(exports, "ApiExtractBlock", { enumerable: true, get: function () { return ApiExtractBlock_1.ApiExtractBlock; } });
+// Value blocks
+var ApiHeadersBlock_1 = require("./ApiHeadersBlock");
+Object.defineProperty(exports, "ApiHeadersBlock", { enumerable: true, get: function () { return ApiHeadersBlock_1.ApiHeadersBlock; } });
+var ApiJsonBodyBlock_1 = require("./ApiJsonBodyBlock");
+Object.defineProperty(exports, "ApiJsonBodyBlock", { enumerable: true, get: function () { return ApiJsonBodyBlock_1.ApiJsonBodyBlock; } });
+// Import all block classes
+const ApiSetHeaderBlock_2 = require("./ApiSetHeaderBlock");
+const ApiSetHeadersBlock_2 = require("./ApiSetHeadersBlock");
+const ApiClearHeadersBlock_2 = require("./ApiClearHeadersBlock");
+const ApiGetBlock_2 = require("./ApiGetBlock");
+const ApiPostBlock_2 = require("./ApiPostBlock");
+const ApiPutBlock_2 = require("./ApiPutBlock");
+const ApiPatchBlock_2 = require("./ApiPatchBlock");
+const ApiDeleteBlock_2 = require("./ApiDeleteBlock");
+const ApiAssertStatusBlock_2 = require("./ApiAssertStatusBlock");
+const ApiAssertBodyContainsBlock_2 = require("./ApiAssertBodyContainsBlock");
+const ApiExtractJsonPathBlock_2 = require("./ApiExtractJsonPathBlock");
+const ApiExtractXPathBlock_2 = require("./ApiExtractXPathBlock");
+const ApiExtractBlock_2 = require("./ApiExtractBlock");
+const ApiHeadersBlock_2 = require("./ApiHeadersBlock");
+const ApiJsonBodyBlock_2 = require("./ApiJsonBodyBlock");
+/**
+ * All API block class instances.
+ */
+exports.apiBlockClasses = [
+    // Header management
+    new ApiSetHeaderBlock_2.ApiSetHeaderBlock(),
+    new ApiSetHeadersBlock_2.ApiSetHeadersBlock(),
+    new ApiClearHeadersBlock_2.ApiClearHeadersBlock(),
+    // HTTP methods
+    new ApiGetBlock_2.ApiGetBlock(),
+    new ApiPostBlock_2.ApiPostBlock(),
+    new ApiPutBlock_2.ApiPutBlock(),
+    new ApiPatchBlock_2.ApiPatchBlock(),
+    new ApiDeleteBlock_2.ApiDeleteBlock(),
+    // Assertions
+    new ApiAssertStatusBlock_2.ApiAssertStatusBlock(),
+    new ApiAssertBodyContainsBlock_2.ApiAssertBodyContainsBlock(),
+    // Extraction
+    new ApiExtractJsonPathBlock_2.ApiExtractJsonPathBlock(),
+    new ApiExtractXPathBlock_2.ApiExtractXPathBlock(),
+    new ApiExtractBlock_2.ApiExtractBlock(),
+    // Value blocks
+    new ApiHeadersBlock_2.ApiHeadersBlock(),
+    new ApiJsonBodyBlock_2.ApiJsonBodyBlock(),
+];
+/**
+ * API blocks as BlockDefinition array for backward compatibility.
+ */
+exports.apiBlocks = exports.apiBlockClasses.map(block => block.toDefinition());

package/dist/core/blocks/base/Block.d.ts

@@ -0,0 +1,59 @@
+import { BlockDefinition, BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Abstract base class for all blocks.
+ * Encapsulates block definition, Blockly JSON generation, and execution logic.
+ */
+export declare abstract class Block {
+    /** Unique block type identifier (e.g., 'api_get') */
+    abstract readonly type: string;
+    /** Category for toolbox organization */
+    abstract readonly category: string;
+    /** Hex color for visual appearance */
+    abstract readonly color: string;
+    /** UI tooltip on hover */
+    readonly tooltip?: string;
+    /** Documentation URL */
+    readonly helpUrl?: string;
+    /** Can be chained after another block */
+    readonly previousStatement: boolean;
+    /** Can chain to next block */
+    readonly nextStatement: boolean;
+    /** Output type if this is a value block */
+    readonly output?: BlockOutput;
+    /**
+     * Get the inputs for this block.
+     * Override in subclasses to define block inputs.
+     */
+    abstract getInputs(): BlockInput[];
+    /**
+     * Execute the block logic.
+     * @param params - The parameter values from the block fields
+     * @param context - The execution context
+     * @returns The execution result
+     */
+    abstract execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+    /**
+     * Convert this block to a BlockDefinition for backward compatibility.
+     * This allows the class-based blocks to work with the existing registry system.
+     */
+    toDefinition(): BlockDefinition;
+    /**
+     * Generate Blockly JSON definition for this block.
+     * Override in subclasses for custom Blockly layouts.
+     */
+    toBlocklyJson(): Record<string, unknown>;
+    /**
+     * Get the block label for display in Blockly.
+     * Override for custom labels.
+     */
+    protected getBlockLabel(): string;
+    /**
+     * Create a Blockly field argument from a BlockInput.
+     */
+    protected createFieldArg(input: BlockInput): unknown;
+    /**
+     * Get the Blockly init extension function for custom initialization.
+     * Override for custom init behavior (e.g., adding tooltips to fields).
+     */
+    getBlocklyInitExtension(): (() => void) | undefined;
+}

package/dist/core/blocks/base/Block.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Block = void 0;
+/**
+ * Abstract base class for all blocks.
+ * Encapsulates block definition, Blockly JSON generation, and execution logic.
+ */
+class Block {
+    constructor() {
+        /** Can be chained after another block */
+        this.previousStatement = false;
+        /** Can chain to next block */
+        this.nextStatement = false;
+    }
+    /**
+     * Convert this block to a BlockDefinition for backward compatibility.
+     * This allows the class-based blocks to work with the existing registry system.
+     */
+    toDefinition() {
+        return {
+            type: this.type,
+            category: this.category,
+            color: this.color,
+            tooltip: this.tooltip,
+            helpUrl: this.helpUrl,
+            inputs: this.getInputs(),
+            output: this.output,
+            previousStatement: this.previousStatement || undefined,
+            nextStatement: this.nextStatement || undefined,
+            execute: this.execute.bind(this),
+        };
+    }
+    /**
+     * Generate Blockly JSON definition for this block.
+     * Override in subclasses for custom Blockly layouts.
+     */
+    toBlocklyJson() {
+        const blockJson = {
+            type: this.type,
+            colour: this.color,
+            tooltip: this.tooltip || '',
+            helpUrl: this.helpUrl || '',
+        };
+        // Build message and args
+        let message = this.getBlockLabel();
+        const args = [];
+        let argIndex = 0;
+        this.getInputs().forEach((input) => {
+            if (input.type === 'field') {
+                message += ` %${++argIndex}`;
+                args.push(this.createFieldArg(input));
+            }
+            else if (input.type === 'value') {
+                message += ` %${++argIndex}`;
+                args.push({
+                    type: 'input_value',
+                    name: input.name,
+                    check: input.check,
+                });
+            }
+            else if (input.type === 'statement') {
+                message += ` %${++argIndex}`;
+                args.push({
+                    type: 'input_statement',
+                    name: input.name,
+                });
+            }
+        });
+        blockJson.message0 = message;
+        blockJson.args0 = args;
+        if (this.output) {
+            blockJson.output = this.output.type;
+        }
+        if (this.previousStatement) {
+            blockJson.previousStatement = null;
+        }
+        if (this.nextStatement) {
+            blockJson.nextStatement = null;
+        }
+        return blockJson;
+    }
+    /**
+     * Get the block label for display in Blockly.
+     * Override for custom labels.
+     */
+    getBlockLabel() {
+        // Convert type like 'api_get' to 'GET' or 'web_navigate' to 'Navigate'
+        const parts = this.type.split('_');
+        const prefix = parts[0];
+        if (prefix === 'api' || prefix === 'web' || prefix === 'logic') {
+            return parts.slice(1).map(p => p.charAt(0).toUpperCase() + p.slice(1)).join(' ');
+        }
+        if (prefix === 'snippet' || prefix === 'custom') {
+            return parts.slice(1).map(p => p.charAt(0).toUpperCase() + p.slice(1)).join(' ');
+        }
+        return parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join(' ');
+    }
+    /**
+     * Create a Blockly field argument from a BlockInput.
+     */
+    createFieldArg(input) {
+        const baseArg = { name: input.name };
+        switch (input.fieldType) {
+            case 'text':
+                return {
+                    ...baseArg,
+                    type: 'field_input_autocomplete',
+                    text: input.default !== undefined ? String(input.default) : '',
+                };
+            case 'number':
+                return {
+                    ...baseArg,
+                    type: 'field_number',
+                    value: input.default !== undefined ? Number(input.default) : 0,
+                };
+            case 'dropdown':
+                return {
+                    ...baseArg,
+                    type: 'field_dropdown',
+                    options: input.options || [],
+                };
+            case 'checkbox':
+                return {
+                    ...baseArg,
+                    type: 'field_checkbox',
+                    checked: input.default === true,
+                };
+            case 'multiline':
+                return {
+                    ...baseArg,
+                    type: 'field_multiline_autocomplete',
+                    text: input.default !== undefined ? String(input.default) : '',
+                    spellcheck: false,
+                };
+            default:
+                return {
+                    ...baseArg,
+                    type: 'field_input_autocomplete',
+                    text: '',
+                };
+        }
+    }
+    /**
+     * Get the Blockly init extension function for custom initialization.
+     * Override for custom init behavior (e.g., adding tooltips to fields).
+     */
+    getBlocklyInitExtension() {
+        return undefined;
+    }
+}
+exports.Block = Block;

package/dist/core/blocks/base/ContainerBlock.d.ts

@@ -0,0 +1,14 @@
+import { Block } from './Block';
+/**
+ * Base class for container blocks with custom multi-message layouts.
+ * Used for blocks like test_case, lifecycle hooks that need special Blockly layouts.
+ */
+export declare abstract class ContainerBlock extends Block {
+    readonly previousStatement: boolean;
+    readonly nextStatement: boolean;
+    /**
+     * Override toBlocklyJson for custom multi-message layout.
+     * Subclasses should implement their specific layout.
+     */
+    abstract toBlocklyJson(): Record<string, unknown>;
+}

package/dist/core/blocks/base/ContainerBlock.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerBlock = void 0;
+const Block_1 = require("./Block");
+/**
+ * Base class for container blocks with custom multi-message layouts.
+ * Used for blocks like test_case, lifecycle hooks that need special Blockly layouts.
+ */
+class ContainerBlock extends Block_1.Block {
+    constructor() {
+        super(...arguments);
+        this.previousStatement = false;
+        this.nextStatement = false;
+    }
+}
+exports.ContainerBlock = ContainerBlock;

package/dist/core/blocks/base/ControlFlowBlock.d.ts

@@ -0,0 +1,13 @@
+import { StatementBlock } from './StatementBlock';
+/**
+ * Base class for control flow blocks that return branch/loop instructions.
+ * Extends StatementBlock with special return types for executor handling.
+ *
+ * Control flow blocks include:
+ * - logic_if (returns { branch: 'DO' | 'ELSE' })
+ * - logic_repeat (returns { loop: true, times, statement })
+ * - logic_foreach (returns { loop: true, array, varName, statement })
+ * - logic_try_catch (returns { tryCatch: true })
+ */
+export declare abstract class ControlFlowBlock extends StatementBlock {
+}

package/dist/core/blocks/base/ControlFlowBlock.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlFlowBlock = void 0;
+const StatementBlock_1 = require("./StatementBlock");
+/**
+ * Base class for control flow blocks that return branch/loop instructions.
+ * Extends StatementBlock with special return types for executor handling.
+ *
+ * Control flow blocks include:
+ * - logic_if (returns { branch: 'DO' | 'ELSE' })
+ * - logic_repeat (returns { loop: true, times, statement })
+ * - logic_foreach (returns { loop: true, array, varName, statement })
+ * - logic_try_catch (returns { tryCatch: true })
+ */
+class ControlFlowBlock extends StatementBlock_1.StatementBlock {
+}
+exports.ControlFlowBlock = ControlFlowBlock;

package/dist/core/blocks/base/StatementBlock.d.ts

@@ -0,0 +1,9 @@
+import { Block } from './Block';
+/**
+ * Base class for statement blocks that chain together sequentially.
+ * Has previousStatement and nextStatement connections enabled.
+ */
+export declare abstract class StatementBlock extends Block {
+    readonly previousStatement: boolean;
+    readonly nextStatement: boolean;
+}

package/dist/core/blocks/base/StatementBlock.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatementBlock = void 0;
+const Block_1 = require("./Block");
+/**
+ * Base class for statement blocks that chain together sequentially.
+ * Has previousStatement and nextStatement connections enabled.
+ */
+class StatementBlock extends Block_1.Block {
+    constructor() {
+        super(...arguments);
+        this.previousStatement = true;
+        this.nextStatement = true;
+    }
+}
+exports.StatementBlock = StatementBlock;

package/dist/core/blocks/base/ValueBlock.d.ts

@@ -0,0 +1,12 @@
+import { Block } from './Block';
+import { BlockOutput } from '../../types';
+/**
+ * Base class for value blocks that output a value.
+ * Has no statement connections, only output.
+ */
+export declare abstract class ValueBlock extends Block {
+    readonly previousStatement: boolean;
+    readonly nextStatement: boolean;
+    /** Output type - must be defined by subclasses */
+    abstract readonly output: BlockOutput;
+}

package/dist/core/blocks/base/ValueBlock.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueBlock = void 0;
+const Block_1 = require("./Block");
+/**
+ * Base class for value blocks that output a value.
+ * Has no statement connections, only output.
+ */
+class ValueBlock extends Block_1.Block {
+    constructor() {
+        super(...arguments);
+        this.previousStatement = false;
+        this.nextStatement = false;
+    }
+}
+exports.ValueBlock = ValueBlock;