@testsmith/testblocks 0.9.4 → 0.9.7

package/dist/core/blocks/lifecycle/LifecycleTeardownBlock.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifecycleTeardownBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Teardown steps to run after the test.
+ */
+class LifecycleTeardownBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'lifecycle_teardown';
+        this.category = 'Lifecycle';
+        this.color = '#8E24AA';
+        this.tooltip = 'Teardown steps to run after the test';
+    }
+    getInputs() {
+        return [
+            { name: 'DESCRIPTION', type: 'field', fieldType: 'text', default: 'Teardown' },
+            { name: 'DO', type: 'statement' },
+        ];
+    }
+    async execute(params, context) {
+        context.logger.info(`Teardown: ${params.DESCRIPTION}`);
+        return { lifecycle: 'teardown', statement: 'DO' };
+    }
+}
+exports.LifecycleTeardownBlock = LifecycleTeardownBlock;

package/dist/core/blocks/lifecycle/TestCaseBlock.d.ts

@@ -0,0 +1,21 @@
+import { ContainerBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * A test case containing steps to execute.
+ */
+export declare class TestCaseBlock extends ContainerBlock {
+    readonly type = "test_case";
+    readonly category = "Tests";
+    readonly color = "#1E88E5";
+    readonly tooltip = "A test case containing steps to execute";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+    /**
+     * Custom Blockly JSON for test_case with multi-message layout.
+     */
+    toBlocklyJson(): Record<string, unknown>;
+    /**
+     * Custom init extension to add tooltip to soft assertions checkbox.
+     */
+    getBlocklyInitExtension(): (() => void) | undefined;
+}

package/dist/core/blocks/lifecycle/TestCaseBlock.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestCaseBlock = void 0;
+const base_1 = require("../base");
+/**
+ * A test case containing steps to execute.
+ */
+class TestCaseBlock extends base_1.ContainerBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'test_case';
+        this.category = 'Tests';
+        this.color = '#1E88E5';
+        this.tooltip = 'A test case containing steps to execute';
+    }
+    getInputs() {
+        return [
+            { name: 'NAME', type: 'field', fieldType: 'multiline', default: 'Test Case' },
+            { name: 'SOFT_ASSERTIONS', type: 'field', fieldType: 'checkbox', default: false },
+            { name: 'STEPS', type: 'statement' },
+        ];
+    }
+    async execute(params, _context) {
+        // Marker block - steps are executed by the executor
+        return { testCase: true, name: params.NAME, softAssertions: params.SOFT_ASSERTIONS, statement: 'STEPS' };
+    }
+    /**
+     * Custom Blockly JSON for test_case with multi-message layout.
+     */
+    toBlocklyJson() {
+        return {
+            type: this.type,
+            colour: this.color,
+            tooltip: this.tooltip || '',
+            helpUrl: this.helpUrl || '',
+            message0: 'Test %1 %2',
+            args0: [
+                {
+                    type: 'field_multiline_autocomplete',
+                    name: 'NAME',
+                    text: 'Test Case',
+                    spellcheck: false,
+                },
+                {
+                    type: 'field_checkbox',
+                    name: 'SOFT_ASSERTIONS',
+                    checked: false,
+                },
+            ],
+            message1: '%1',
+            args1: [
+                {
+                    type: 'input_statement',
+                    name: 'STEPS',
+                },
+            ],
+        };
+    }
+    /**
+     * Custom init extension to add tooltip to soft assertions checkbox.
+     */
+    getBlocklyInitExtension() {
+        return function () {
+            const block = this;
+            const softAssertionsField = block.getField('SOFT_ASSERTIONS');
+            if (softAssertionsField) {
+                softAssertionsField.setTooltip('Soft Assertions - continue test on assertion failure');
+            }
+        };
+    }
+}
+exports.TestCaseBlock = TestCaseBlock;

package/dist/core/blocks/lifecycle/TestCaseDataDrivenBlock.d.ts

@@ -0,0 +1,21 @@
+import { ContainerBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * A data-driven test case that runs for each row of data (CSV format).
+ */
+export declare class TestCaseDataDrivenBlock extends ContainerBlock {
+    readonly type = "test_case_data_driven";
+    readonly category = "Tests";
+    readonly color = "#1565C0";
+    readonly tooltip = "A data-driven test case that runs for each row of data (CSV format: header row, then data rows)";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+    /**
+     * Custom Blockly JSON for test_case_data_driven with multi-message layout.
+     */
+    toBlocklyJson(): Record<string, unknown>;
+    /**
+     * Custom init extension to add tooltip to soft assertions checkbox.
+     */
+    getBlocklyInitExtension(): (() => void) | undefined;
+}

package/dist/core/blocks/lifecycle/TestCaseDataDrivenBlock.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestCaseDataDrivenBlock = void 0;
+const base_1 = require("../base");
+/**
+ * A data-driven test case that runs for each row of data (CSV format).
+ */
+class TestCaseDataDrivenBlock extends base_1.ContainerBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'test_case_data_driven';
+        this.category = 'Tests';
+        this.color = '#1565C0';
+        this.tooltip = 'A data-driven test case that runs for each row of data (CSV format: header row, then data rows)';
+    }
+    getInputs() {
+        return [
+            { name: 'NAME', type: 'field', fieldType: 'text', default: 'Data-Driven Test' },
+            { name: 'SOFT_ASSERTIONS', type: 'field', fieldType: 'checkbox', default: false },
+            { name: 'DATA', type: 'field', fieldType: 'multiline', default: 'username,password,expected\nuser1,pass1,true\nuser2,pass2,false' },
+            { name: 'STEPS', type: 'statement' },
+        ];
+    }
+    async execute(params, _context) {
+        // Marker block - actual data parsing and execution handled by executor
+        const csvData = params.DATA;
+        const rows = csvData.trim().split('\n').map(row => row.split(',').map(cell => cell.trim()));
+        if (rows.length < 2) {
+            return { testCase: true, name: params.NAME, softAssertions: params.SOFT_ASSERTIONS, dataDriven: true, data: [], statement: 'STEPS' };
+        }
+        const headers = rows[0];
+        const data = rows.slice(1).map((row, index) => {
+            const values = {};
+            headers.forEach((header, i) => {
+                let value = row[i] || '';
+                // Try to parse as boolean or number
+                if (value === 'true')
+                    value = true;
+                else if (value === 'false')
+                    value = false;
+                else if (!isNaN(Number(value)) && value !== '')
+                    value = Number(value);
+                values[header] = value;
+            });
+            return { name: `Row ${index + 1}`, values };
+        });
+        return { testCase: true, name: params.NAME, softAssertions: params.SOFT_ASSERTIONS, dataDriven: true, data, statement: 'STEPS' };
+    }
+    /**
+     * Custom Blockly JSON for test_case_data_driven with multi-message layout.
+     */
+    toBlocklyJson() {
+        return {
+            type: this.type,
+            colour: this.color,
+            tooltip: this.tooltip || '',
+            helpUrl: this.helpUrl || '',
+            message0: 'Data-Driven Test %1 %2',
+            args0: [
+                {
+                    type: 'field_input_autocomplete',
+                    name: 'NAME',
+                    text: 'Data-Driven Test',
+                },
+                {
+                    type: 'field_checkbox',
+                    name: 'SOFT_ASSERTIONS',
+                    checked: false,
+                },
+            ],
+            message1: 'Data %1',
+            args1: [
+                {
+                    type: 'field_multiline_autocomplete',
+                    name: 'DATA',
+                    text: 'username,password,expected\nuser1,pass1,true\nuser2,pass2,false',
+                    spellcheck: false,
+                },
+            ],
+            message2: '%1',
+            args2: [
+                {
+                    type: 'input_statement',
+                    name: 'STEPS',
+                },
+            ],
+        };
+    }
+    /**
+     * Custom init extension to add tooltip to soft assertions checkbox.
+     */
+    getBlocklyInitExtension() {
+        return function () {
+            const block = this;
+            const softAssertionsField = block.getField('SOFT_ASSERTIONS');
+            if (softAssertionsField) {
+                softAssertionsField.setTooltip('Soft Assertions - continue test on assertion failure');
+            }
+        };
+    }
+}
+exports.TestCaseDataDrivenBlock = TestCaseDataDrivenBlock;

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

@@ -0,0 +1,21 @@
+import { Block } from '../base';
+import { BlockDefinition } from '../../types';
+export { TestCaseBlock } from './TestCaseBlock';
+export { TestCaseDataDrivenBlock } from './TestCaseDataDrivenBlock';
+export { LifecycleBeforeAllBlock } from './LifecycleBeforeAllBlock';
+export { LifecycleAfterAllBlock } from './LifecycleAfterAllBlock';
+export { LifecycleBeforeEachBlock } from './LifecycleBeforeEachBlock';
+export { LifecycleAfterEachBlock } from './LifecycleAfterEachBlock';
+export { LifecycleSetupBlock } from './LifecycleSetupBlock';
+export { LifecycleTeardownBlock } from './LifecycleTeardownBlock';
+export { LifecycleOnFailureBlock } from './LifecycleOnFailureBlock';
+export { LifecycleSkipIfBlock } from './LifecycleSkipIfBlock';
+export { LifecycleRetryBlock } from './LifecycleRetryBlock';
+/**
+ * All Lifecycle block class instances.
+ */
+export declare const lifecycleBlockClasses: Block[];
+/**
+ * Lifecycle blocks as BlockDefinition array for backward compatibility.
+ */
+export declare const lifecycleBlocks: BlockDefinition[];

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lifecycleBlocks = exports.lifecycleBlockClasses = exports.LifecycleRetryBlock = exports.LifecycleSkipIfBlock = exports.LifecycleOnFailureBlock = exports.LifecycleTeardownBlock = exports.LifecycleSetupBlock = exports.LifecycleAfterEachBlock = exports.LifecycleBeforeEachBlock = exports.LifecycleAfterAllBlock = exports.LifecycleBeforeAllBlock = exports.TestCaseDataDrivenBlock = exports.TestCaseBlock = void 0;
+// Test case blocks
+var TestCaseBlock_1 = require("./TestCaseBlock");
+Object.defineProperty(exports, "TestCaseBlock", { enumerable: true, get: function () { return TestCaseBlock_1.TestCaseBlock; } });
+var TestCaseDataDrivenBlock_1 = require("./TestCaseDataDrivenBlock");
+Object.defineProperty(exports, "TestCaseDataDrivenBlock", { enumerable: true, get: function () { return TestCaseDataDrivenBlock_1.TestCaseDataDrivenBlock; } });
+// Lifecycle hooks
+var LifecycleBeforeAllBlock_1 = require("./LifecycleBeforeAllBlock");
+Object.defineProperty(exports, "LifecycleBeforeAllBlock", { enumerable: true, get: function () { return LifecycleBeforeAllBlock_1.LifecycleBeforeAllBlock; } });
+var LifecycleAfterAllBlock_1 = require("./LifecycleAfterAllBlock");
+Object.defineProperty(exports, "LifecycleAfterAllBlock", { enumerable: true, get: function () { return LifecycleAfterAllBlock_1.LifecycleAfterAllBlock; } });
+var LifecycleBeforeEachBlock_1 = require("./LifecycleBeforeEachBlock");
+Object.defineProperty(exports, "LifecycleBeforeEachBlock", { enumerable: true, get: function () { return LifecycleBeforeEachBlock_1.LifecycleBeforeEachBlock; } });
+var LifecycleAfterEachBlock_1 = require("./LifecycleAfterEachBlock");
+Object.defineProperty(exports, "LifecycleAfterEachBlock", { enumerable: true, get: function () { return LifecycleAfterEachBlock_1.LifecycleAfterEachBlock; } });
+// In-test lifecycle blocks
+var LifecycleSetupBlock_1 = require("./LifecycleSetupBlock");
+Object.defineProperty(exports, "LifecycleSetupBlock", { enumerable: true, get: function () { return LifecycleSetupBlock_1.LifecycleSetupBlock; } });
+var LifecycleTeardownBlock_1 = require("./LifecycleTeardownBlock");
+Object.defineProperty(exports, "LifecycleTeardownBlock", { enumerable: true, get: function () { return LifecycleTeardownBlock_1.LifecycleTeardownBlock; } });
+var LifecycleOnFailureBlock_1 = require("./LifecycleOnFailureBlock");
+Object.defineProperty(exports, "LifecycleOnFailureBlock", { enumerable: true, get: function () { return LifecycleOnFailureBlock_1.LifecycleOnFailureBlock; } });
+var LifecycleSkipIfBlock_1 = require("./LifecycleSkipIfBlock");
+Object.defineProperty(exports, "LifecycleSkipIfBlock", { enumerable: true, get: function () { return LifecycleSkipIfBlock_1.LifecycleSkipIfBlock; } });
+var LifecycleRetryBlock_1 = require("./LifecycleRetryBlock");
+Object.defineProperty(exports, "LifecycleRetryBlock", { enumerable: true, get: function () { return LifecycleRetryBlock_1.LifecycleRetryBlock; } });
+// Import all block classes
+const TestCaseBlock_2 = require("./TestCaseBlock");
+const TestCaseDataDrivenBlock_2 = require("./TestCaseDataDrivenBlock");
+const LifecycleBeforeAllBlock_2 = require("./LifecycleBeforeAllBlock");
+const LifecycleAfterAllBlock_2 = require("./LifecycleAfterAllBlock");
+const LifecycleBeforeEachBlock_2 = require("./LifecycleBeforeEachBlock");
+const LifecycleAfterEachBlock_2 = require("./LifecycleAfterEachBlock");
+const LifecycleSetupBlock_2 = require("./LifecycleSetupBlock");
+const LifecycleTeardownBlock_2 = require("./LifecycleTeardownBlock");
+const LifecycleOnFailureBlock_2 = require("./LifecycleOnFailureBlock");
+const LifecycleSkipIfBlock_2 = require("./LifecycleSkipIfBlock");
+const LifecycleRetryBlock_2 = require("./LifecycleRetryBlock");
+/**
+ * All Lifecycle block class instances.
+ */
+exports.lifecycleBlockClasses = [
+    // Test case blocks
+    new TestCaseBlock_2.TestCaseBlock(),
+    new TestCaseDataDrivenBlock_2.TestCaseDataDrivenBlock(),
+    // Suite-level lifecycle hooks
+    new LifecycleBeforeAllBlock_2.LifecycleBeforeAllBlock(),
+    new LifecycleAfterAllBlock_2.LifecycleAfterAllBlock(),
+    new LifecycleBeforeEachBlock_2.LifecycleBeforeEachBlock(),
+    new LifecycleAfterEachBlock_2.LifecycleAfterEachBlock(),
+    // In-test lifecycle blocks
+    new LifecycleSetupBlock_2.LifecycleSetupBlock(),
+    new LifecycleTeardownBlock_2.LifecycleTeardownBlock(),
+    new LifecycleOnFailureBlock_2.LifecycleOnFailureBlock(),
+    new LifecycleSkipIfBlock_2.LifecycleSkipIfBlock(),
+    new LifecycleRetryBlock_2.LifecycleRetryBlock(),
+];
+/**
+ * Lifecycle blocks as BlockDefinition array for backward compatibility.
+ */
+exports.lifecycleBlocks = exports.lifecycleBlockClasses.map(block => block.toDefinition());

package/dist/core/blocks/logic/LogicArrayBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Create an array.
+ */
+export declare class LogicArrayBlock extends ValueBlock {
+    readonly type = "logic_array";
+    readonly category = "Logic";
+    readonly color = "#795548";
+    readonly tooltip = "Create an array";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/logic/LogicArrayBlock.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicArrayBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Create an array.
+ */
+class LogicArrayBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_array';
+        this.category = 'Logic';
+        this.color = '#795548';
+        this.tooltip = 'Create an array';
+        this.output = { type: 'Array' };
+    }
+    getInputs() {
+        return [
+            { name: 'JSON', type: 'field', fieldType: 'text', default: '[]' },
+        ];
+    }
+    async execute(params, context) {
+        const json = (0, utils_1.resolveVariables)(params.JSON, context);
+        return JSON.parse(json);
+    }
+}
+exports.LogicArrayBlock = LogicArrayBlock;

package/dist/core/blocks/logic/LogicAssertBlock.d.ts

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

package/dist/core/blocks/logic/LogicAssertBlock.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicAssertBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+const assertions_1 = require("../assertions");
+/**
+ * Assert a condition is true.
+ */
+class LogicAssertBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_assert';
+        this.category = 'Logic';
+        this.color = '#FF9800';
+        this.tooltip = 'Assert a condition is true';
+    }
+    getInputs() {
+        return [
+            { name: 'CONDITION', type: 'value', check: 'Boolean', required: true },
+            { name: 'MESSAGE', type: 'field', fieldType: 'text', default: 'Assertion failed' },
+        ];
+    }
+    async execute(params, context) {
+        const condition = params.CONDITION;
+        const message = (0, utils_1.resolveVariables)(params.MESSAGE, context);
+        (0, assertions_1.handleAssertion)(context, condition, message, { stepType: 'logic_assert', expected: true, actual: condition });
+        context.logger.info('✓ Assertion passed');
+        return undefined;
+    }
+}
+exports.LogicAssertBlock = LogicAssertBlock;

package/dist/core/blocks/logic/LogicBooleanBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * A boolean value.
+ */
+export declare class LogicBooleanBlock extends ValueBlock {
+    readonly type = "logic_boolean";
+    readonly category = "Logic";
+    readonly color = "#795548";
+    readonly tooltip = "A boolean value";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/logic/LogicBooleanBlock.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicBooleanBlock = void 0;
+const base_1 = require("../base");
+/**
+ * A boolean value.
+ */
+class LogicBooleanBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_boolean';
+        this.category = 'Logic';
+        this.color = '#795548';
+        this.tooltip = 'A boolean value';
+        this.output = { type: 'Boolean' };
+    }
+    getInputs() {
+        return [
+            { name: 'BOOL', type: 'field', fieldType: 'dropdown', options: [['true', 'true'], ['false', 'false']] },
+        ];
+    }
+    async execute(params, _context) {
+        return params.BOOL === 'true';
+    }
+}
+exports.LogicBooleanBlock = LogicBooleanBlock;

package/dist/core/blocks/logic/LogicBooleanOpBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Combine boolean values.
+ */
+export declare class LogicBooleanOpBlock extends ValueBlock {
+    readonly type = "logic_boolean_op";
+    readonly category = "Logic";
+    readonly color = "#5C6BC0";
+    readonly tooltip = "Combine boolean values";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/logic/LogicBooleanOpBlock.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicBooleanOpBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Combine boolean values.
+ */
+class LogicBooleanOpBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_boolean_op';
+        this.category = 'Logic';
+        this.color = '#5C6BC0';
+        this.tooltip = 'Combine boolean values';
+        this.output = { type: 'Boolean' };
+    }
+    getInputs() {
+        return [
+            { name: 'A', type: 'value', check: 'Boolean', required: true },
+            { name: 'OP', type: 'field', fieldType: 'dropdown', options: [['and', 'and'], ['or', 'or']] },
+            { name: 'B', type: 'value', check: 'Boolean', required: true },
+        ];
+    }
+    async execute(params, _context) {
+        const a = params.A;
+        const b = params.B;
+        const op = params.OP;
+        return op === 'and' ? a && b : a || b;
+    }
+}
+exports.LogicBooleanOpBlock = LogicBooleanOpBlock;

package/dist/core/blocks/logic/LogicCommentBlock.d.ts

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Add a comment (does nothing).
+ */
+export declare class LogicCommentBlock extends StatementBlock {
+    readonly type = "logic_comment";
+    readonly category = "Logic";
+    readonly color = "#9E9E9E";
+    readonly tooltip = "Add a comment (does nothing)";
+    getInputs(): BlockInput[];
+    execute(_params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/logic/LogicCommentBlock.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicCommentBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Add a comment (does nothing).
+ */
+class LogicCommentBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_comment';
+        this.category = 'Logic';
+        this.color = '#9E9E9E';
+        this.tooltip = 'Add a comment (does nothing)';
+    }
+    getInputs() {
+        return [
+            { name: 'TEXT', type: 'field', fieldType: 'text', default: 'Comment' },
+        ];
+    }
+    async execute(_params, _context) {
+        // No-op
+        return undefined;
+    }
+}
+exports.LogicCommentBlock = LogicCommentBlock;

package/dist/core/blocks/logic/LogicCompareBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Compare two values.
+ */
+export declare class LogicCompareBlock extends ValueBlock {
+    readonly type = "logic_compare";
+    readonly category = "Logic";
+    readonly color = "#5C6BC0";
+    readonly tooltip = "Compare two values";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/logic/LogicCompareBlock.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicCompareBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Compare two values.
+ */
+class LogicCompareBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_compare';
+        this.category = 'Logic';
+        this.color = '#5C6BC0';
+        this.tooltip = 'Compare two values';
+        this.output = { type: 'Boolean' };
+    }
+    getInputs() {
+        return [
+            { name: 'A', type: 'value', required: true },
+            { name: 'OP', type: 'field', fieldType: 'dropdown', options: [['=', 'eq'], ['≠', 'neq'], ['<', 'lt'], ['≤', 'lte'], ['>', 'gt'], ['≥', 'gte'], ['contains', 'contains']] },
+            { name: 'B', type: 'value', required: true },
+        ];
+    }
+    async execute(params, _context) {
+        const a = params.A;
+        const b = params.B;
+        const op = params.OP;
+        switch (op) {
+            case 'eq':
+                return JSON.stringify(a) === JSON.stringify(b);
+            case 'neq':
+                return JSON.stringify(a) !== JSON.stringify(b);
+            case 'lt':
+                return a < b;
+            case 'lte':
+                return a <= b;
+            case 'gt':
+                return a > b;
+            case 'gte':
+                return a >= b;
+            case 'contains':
+                if (typeof a === 'string')
+                    return a.includes(b);
+                if (Array.isArray(a))
+                    return a.includes(b);
+                return false;
+            default:
+                return false;
+        }
+    }
+}
+exports.LogicCompareBlock = LogicCompareBlock;

package/dist/core/blocks/logic/LogicFailBlock.d.ts

@@ -0,0 +1,16 @@
+import { Block } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Fail the test with a message.
+ * Note: This block has previousStatement but no nextStatement.
+ */
+export declare class LogicFailBlock extends Block {
+    readonly type = "logic_fail";
+    readonly category = "Logic";
+    readonly color = "#f44336";
+    readonly tooltip = "Fail the test with a message";
+    readonly previousStatement = true;
+    readonly nextStatement = false;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}