@testsmith/testblocks 0.9.4 → 0.9.7

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicFailBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Fail the test with a message.
+ * Note: This block has previousStatement but no nextStatement.
+ */
+class LogicFailBlock extends base_1.Block {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_fail';
+        this.category = 'Logic';
+        this.color = '#f44336';
+        this.tooltip = 'Fail the test with a message';
+        this.previousStatement = true;
+        this.nextStatement = false;
+    }
+    getInputs() {
+        return [
+            { name: 'MESSAGE', type: 'field', fieldType: 'text', default: 'Test failed' },
+        ];
+    }
+    async execute(params, context) {
+        const message = (0, utils_1.resolveVariables)(params.MESSAGE, context);
+        throw new Error(message);
+    }
+}
+exports.LogicFailBlock = LogicFailBlock;

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

@@ -0,0 +1,13 @@
+import { ControlFlowBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Iterate over an array.
+ */
+export declare class LogicForeachBlock extends ControlFlowBlock {
+    readonly type = "logic_foreach";
+    readonly category = "Logic";
+    readonly color = "#5C6BC0";
+    readonly tooltip = "Iterate over an array";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicForeachBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Iterate over an array.
+ */
+class LogicForeachBlock extends base_1.ControlFlowBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_foreach';
+        this.category = 'Logic';
+        this.color = '#5C6BC0';
+        this.tooltip = 'Iterate over an array';
+    }
+    getInputs() {
+        return [
+            { name: 'ARRAY', type: 'value', check: 'Array', required: true },
+            { name: 'VAR', type: 'field', fieldType: 'text', default: 'item', required: true },
+            { name: 'DO', type: 'statement' },
+        ];
+    }
+    async execute(params, _context) {
+        const array = params.ARRAY;
+        const varName = params.VAR;
+        return { loop: true, array, varName, statement: 'DO' };
+    }
+}
+exports.LogicForeachBlock = LogicForeachBlock;

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicGetVariableBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Get a variable value.
+ */
+class LogicGetVariableBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_get_variable';
+        this.category = 'Logic';
+        this.color = '#795548';
+        this.tooltip = 'Get a variable value';
+        this.output = { type: ['String', 'Number', 'Boolean', 'Object', 'Array'] };
+    }
+    getInputs() {
+        return [
+            { name: 'NAME', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const name = params.NAME;
+        return context.variables.get(name);
+    }
+}
+exports.LogicGetVariableBlock = LogicGetVariableBlock;

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

@@ -0,0 +1,13 @@
+import { ControlFlowBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Execute blocks if condition is true.
+ */
+export declare class LogicIfBlock extends ControlFlowBlock {
+    readonly type = "logic_if";
+    readonly category = "Logic";
+    readonly color = "#5C6BC0";
+    readonly tooltip = "Execute blocks if condition is true";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicIfBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Execute blocks if condition is true.
+ */
+class LogicIfBlock extends base_1.ControlFlowBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_if';
+        this.category = 'Logic';
+        this.color = '#5C6BC0';
+        this.tooltip = 'Execute blocks if condition is true';
+    }
+    getInputs() {
+        return [
+            { name: 'CONDITION', type: 'value', check: 'Boolean', required: true },
+            { name: 'DO', type: 'statement' },
+            { name: 'ELSE', type: 'statement' },
+        ];
+    }
+    async execute(params, _context) {
+        const condition = params.CONDITION;
+        if (condition && params.DO) {
+            // Execute DO block - handled by executor
+            return { branch: 'DO' };
+        }
+        else if (!condition && params.ELSE) {
+            // Execute ELSE block - handled by executor
+            return { branch: 'ELSE' };
+        }
+        return undefined;
+    }
+}
+exports.LogicIfBlock = LogicIfBlock;

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

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

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicLogBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Log a message.
+ */
+class LogicLogBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_log';
+        this.category = 'Logic';
+        this.color = '#607D8B';
+        this.tooltip = 'Log a message';
+    }
+    getInputs() {
+        return [
+            { name: 'LEVEL', type: 'field', fieldType: 'dropdown', options: [['Info', 'info'], ['Warning', 'warn'], ['Error', 'error'], ['Debug', 'debug']] },
+            { name: 'MESSAGE', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const level = params.LEVEL || 'info';
+        const message = (0, utils_1.resolveVariables)(params.MESSAGE, context);
+        context.logger[level](message);
+        return { _message: message, _summary: message };
+    }
+}
+exports.LogicLogBlock = LogicLogBlock;

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicNotBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Negate a boolean value.
+ */
+class LogicNotBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_not';
+        this.category = 'Logic';
+        this.color = '#5C6BC0';
+        this.tooltip = 'Negate a boolean value';
+        this.output = { type: 'Boolean' };
+    }
+    getInputs() {
+        return [
+            { name: 'VALUE', type: 'value', check: 'Boolean', required: true },
+        ];
+    }
+    async execute(params, _context) {
+        return !params.VALUE;
+    }
+}
+exports.LogicNotBlock = LogicNotBlock;

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

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

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

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

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

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

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicObjectBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Create a JSON object.
+ */
+class LogicObjectBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_object';
+        this.category = 'Logic';
+        this.color = '#795548';
+        this.tooltip = 'Create a JSON object';
+        this.output = { type: 'Object' };
+    }
+    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.LogicObjectBlock = LogicObjectBlock;

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

@@ -0,0 +1,13 @@
+import { ControlFlowBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Repeat blocks a specified number of times.
+ */
+export declare class LogicRepeatBlock extends ControlFlowBlock {
+    readonly type = "logic_repeat";
+    readonly category = "Logic";
+    readonly color = "#5C6BC0";
+    readonly tooltip = "Repeat blocks a specified number of times";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicRepeatBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Repeat blocks a specified number of times.
+ */
+class LogicRepeatBlock extends base_1.ControlFlowBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_repeat';
+        this.category = 'Logic';
+        this.color = '#5C6BC0';
+        this.tooltip = 'Repeat blocks a specified number of times';
+    }
+    getInputs() {
+        return [
+            { name: 'TIMES', type: 'field', fieldType: 'number', default: 10, required: true },
+            { name: 'DO', type: 'statement' },
+        ];
+    }
+    async execute(params, _context) {
+        const times = params.TIMES;
+        return { loop: true, times, statement: 'DO' };
+    }
+}
+exports.LogicRepeatBlock = LogicRepeatBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Set a variable value.
+ */
+export declare class LogicSetVariableBlock extends StatementBlock {
+    readonly type = "logic_set_variable";
+    readonly category = "Logic";
+    readonly color = "#795548";
+    readonly tooltip = "Set a variable value";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicSetVariableBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Set a variable value.
+ */
+class LogicSetVariableBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_set_variable';
+        this.category = 'Logic';
+        this.color = '#795548';
+        this.tooltip = 'Set a variable value';
+    }
+    getInputs() {
+        return [
+            { name: 'NAME', type: 'field', fieldType: 'text', required: true },
+            { name: 'VALUE', type: 'value', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const name = params.NAME;
+        let value = params.VALUE;
+        // If the value is a block result with _value, extract just the value
+        if (value && typeof value === 'object' && '_value' in value) {
+            value = value._value;
+        }
+        context.variables.set(name, value);
+        context.logger.debug(`Set variable ${name} = ${JSON.stringify(value)}`);
+        return undefined;
+    }
+}
+exports.LogicSetVariableBlock = LogicSetVariableBlock;

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicTextBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * A text value.
+ */
+class LogicTextBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_text';
+        this.category = 'Logic';
+        this.color = '#795548';
+        this.tooltip = 'A text value';
+        this.output = { type: 'String' };
+    }
+    getInputs() {
+        return [
+            { name: 'TEXT', type: 'field', fieldType: 'text', default: '' },
+        ];
+    }
+    async execute(params, context) {
+        return (0, utils_1.resolveVariables)(params.TEXT, context);
+    }
+}
+exports.LogicTextBlock = LogicTextBlock;

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

@@ -0,0 +1,13 @@
+import { ControlFlowBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Handle errors gracefully.
+ */
+export declare class LogicTryCatchBlock extends ControlFlowBlock {
+    readonly type = "logic_try_catch";
+    readonly category = "Logic";
+    readonly color = "#5C6BC0";
+    readonly tooltip = "Handle errors gracefully";
+    getInputs(): BlockInput[];
+    execute(_params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogicTryCatchBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Handle errors gracefully.
+ */
+class LogicTryCatchBlock extends base_1.ControlFlowBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'logic_try_catch';
+        this.category = 'Logic';
+        this.color = '#5C6BC0';
+        this.tooltip = 'Handle errors gracefully';
+    }
+    getInputs() {
+        return [
+            { name: 'TRY', type: 'statement' },
+            { name: 'CATCH', type: 'statement' },
+        ];
+    }
+    async execute(_params, _context) {
+        return { tryCatch: true };
+    }
+}
+exports.LogicTryCatchBlock = LogicTryCatchBlock;

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

@@ -0,0 +1,28 @@
+import { Block } from '../base';
+import { BlockDefinition } from '../../types';
+export { LogicSetVariableBlock } from './LogicSetVariableBlock';
+export { LogicGetVariableBlock } from './LogicGetVariableBlock';
+export { LogicIfBlock } from './LogicIfBlock';
+export { LogicRepeatBlock } from './LogicRepeatBlock';
+export { LogicForeachBlock } from './LogicForeachBlock';
+export { LogicTryCatchBlock } from './LogicTryCatchBlock';
+export { LogicCompareBlock } from './LogicCompareBlock';
+export { LogicBooleanOpBlock } from './LogicBooleanOpBlock';
+export { LogicNotBlock } from './LogicNotBlock';
+export { LogicTextBlock } from './LogicTextBlock';
+export { LogicNumberBlock } from './LogicNumberBlock';
+export { LogicBooleanBlock } from './LogicBooleanBlock';
+export { LogicObjectBlock } from './LogicObjectBlock';
+export { LogicArrayBlock } from './LogicArrayBlock';
+export { LogicLogBlock } from './LogicLogBlock';
+export { LogicCommentBlock } from './LogicCommentBlock';
+export { LogicFailBlock } from './LogicFailBlock';
+export { LogicAssertBlock } from './LogicAssertBlock';
+/**
+ * All Logic block class instances.
+ */
+export declare const logicBlockClasses: Block[];
+/**
+ * Logic blocks as BlockDefinition array for backward compatibility.
+ */
+export declare const logicBlocks: BlockDefinition[];

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logicBlocks = exports.logicBlockClasses = exports.LogicAssertBlock = exports.LogicFailBlock = exports.LogicCommentBlock = exports.LogicLogBlock = exports.LogicArrayBlock = exports.LogicObjectBlock = exports.LogicBooleanBlock = exports.LogicNumberBlock = exports.LogicTextBlock = exports.LogicNotBlock = exports.LogicBooleanOpBlock = exports.LogicCompareBlock = exports.LogicTryCatchBlock = exports.LogicForeachBlock = exports.LogicRepeatBlock = exports.LogicIfBlock = exports.LogicGetVariableBlock = exports.LogicSetVariableBlock = void 0;
+// Variable blocks
+var LogicSetVariableBlock_1 = require("./LogicSetVariableBlock");
+Object.defineProperty(exports, "LogicSetVariableBlock", { enumerable: true, get: function () { return LogicSetVariableBlock_1.LogicSetVariableBlock; } });
+var LogicGetVariableBlock_1 = require("./LogicGetVariableBlock");
+Object.defineProperty(exports, "LogicGetVariableBlock", { enumerable: true, get: function () { return LogicGetVariableBlock_1.LogicGetVariableBlock; } });
+// Control flow blocks
+var LogicIfBlock_1 = require("./LogicIfBlock");
+Object.defineProperty(exports, "LogicIfBlock", { enumerable: true, get: function () { return LogicIfBlock_1.LogicIfBlock; } });
+var LogicRepeatBlock_1 = require("./LogicRepeatBlock");
+Object.defineProperty(exports, "LogicRepeatBlock", { enumerable: true, get: function () { return LogicRepeatBlock_1.LogicRepeatBlock; } });
+var LogicForeachBlock_1 = require("./LogicForeachBlock");
+Object.defineProperty(exports, "LogicForeachBlock", { enumerable: true, get: function () { return LogicForeachBlock_1.LogicForeachBlock; } });
+var LogicTryCatchBlock_1 = require("./LogicTryCatchBlock");
+Object.defineProperty(exports, "LogicTryCatchBlock", { enumerable: true, get: function () { return LogicTryCatchBlock_1.LogicTryCatchBlock; } });
+// Comparison and boolean blocks
+var LogicCompareBlock_1 = require("./LogicCompareBlock");
+Object.defineProperty(exports, "LogicCompareBlock", { enumerable: true, get: function () { return LogicCompareBlock_1.LogicCompareBlock; } });
+var LogicBooleanOpBlock_1 = require("./LogicBooleanOpBlock");
+Object.defineProperty(exports, "LogicBooleanOpBlock", { enumerable: true, get: function () { return LogicBooleanOpBlock_1.LogicBooleanOpBlock; } });
+var LogicNotBlock_1 = require("./LogicNotBlock");
+Object.defineProperty(exports, "LogicNotBlock", { enumerable: true, get: function () { return LogicNotBlock_1.LogicNotBlock; } });
+// Value blocks
+var LogicTextBlock_1 = require("./LogicTextBlock");
+Object.defineProperty(exports, "LogicTextBlock", { enumerable: true, get: function () { return LogicTextBlock_1.LogicTextBlock; } });
+var LogicNumberBlock_1 = require("./LogicNumberBlock");
+Object.defineProperty(exports, "LogicNumberBlock", { enumerable: true, get: function () { return LogicNumberBlock_1.LogicNumberBlock; } });
+var LogicBooleanBlock_1 = require("./LogicBooleanBlock");
+Object.defineProperty(exports, "LogicBooleanBlock", { enumerable: true, get: function () { return LogicBooleanBlock_1.LogicBooleanBlock; } });
+var LogicObjectBlock_1 = require("./LogicObjectBlock");
+Object.defineProperty(exports, "LogicObjectBlock", { enumerable: true, get: function () { return LogicObjectBlock_1.LogicObjectBlock; } });
+var LogicArrayBlock_1 = require("./LogicArrayBlock");
+Object.defineProperty(exports, "LogicArrayBlock", { enumerable: true, get: function () { return LogicArrayBlock_1.LogicArrayBlock; } });
+// Utility blocks
+var LogicLogBlock_1 = require("./LogicLogBlock");
+Object.defineProperty(exports, "LogicLogBlock", { enumerable: true, get: function () { return LogicLogBlock_1.LogicLogBlock; } });
+var LogicCommentBlock_1 = require("./LogicCommentBlock");
+Object.defineProperty(exports, "LogicCommentBlock", { enumerable: true, get: function () { return LogicCommentBlock_1.LogicCommentBlock; } });
+var LogicFailBlock_1 = require("./LogicFailBlock");
+Object.defineProperty(exports, "LogicFailBlock", { enumerable: true, get: function () { return LogicFailBlock_1.LogicFailBlock; } });
+var LogicAssertBlock_1 = require("./LogicAssertBlock");
+Object.defineProperty(exports, "LogicAssertBlock", { enumerable: true, get: function () { return LogicAssertBlock_1.LogicAssertBlock; } });
+// Import all block classes
+const LogicSetVariableBlock_2 = require("./LogicSetVariableBlock");
+const LogicGetVariableBlock_2 = require("./LogicGetVariableBlock");
+const LogicIfBlock_2 = require("./LogicIfBlock");
+const LogicRepeatBlock_2 = require("./LogicRepeatBlock");
+const LogicForeachBlock_2 = require("./LogicForeachBlock");
+const LogicTryCatchBlock_2 = require("./LogicTryCatchBlock");
+const LogicCompareBlock_2 = require("./LogicCompareBlock");
+const LogicBooleanOpBlock_2 = require("./LogicBooleanOpBlock");
+const LogicNotBlock_2 = require("./LogicNotBlock");
+const LogicTextBlock_2 = require("./LogicTextBlock");
+const LogicNumberBlock_2 = require("./LogicNumberBlock");
+const LogicBooleanBlock_2 = require("./LogicBooleanBlock");
+const LogicObjectBlock_2 = require("./LogicObjectBlock");
+const LogicArrayBlock_2 = require("./LogicArrayBlock");
+const LogicLogBlock_2 = require("./LogicLogBlock");
+const LogicCommentBlock_2 = require("./LogicCommentBlock");
+const LogicFailBlock_2 = require("./LogicFailBlock");
+const LogicAssertBlock_2 = require("./LogicAssertBlock");
+/**
+ * All Logic block class instances.
+ */
+exports.logicBlockClasses = [
+    // Variable blocks
+    new LogicSetVariableBlock_2.LogicSetVariableBlock(),
+    new LogicGetVariableBlock_2.LogicGetVariableBlock(),
+    // Control flow
+    new LogicIfBlock_2.LogicIfBlock(),
+    new LogicCompareBlock_2.LogicCompareBlock(),
+    new LogicBooleanOpBlock_2.LogicBooleanOpBlock(),
+    new LogicNotBlock_2.LogicNotBlock(),
+    new LogicRepeatBlock_2.LogicRepeatBlock(),
+    new LogicForeachBlock_2.LogicForeachBlock(),
+    new LogicTryCatchBlock_2.LogicTryCatchBlock(),
+    // Utility
+    new LogicLogBlock_2.LogicLogBlock(),
+    new LogicCommentBlock_2.LogicCommentBlock(),
+    // Value blocks
+    new LogicTextBlock_2.LogicTextBlock(),
+    new LogicNumberBlock_2.LogicNumberBlock(),
+    new LogicBooleanBlock_2.LogicBooleanBlock(),
+    new LogicObjectBlock_2.LogicObjectBlock(),
+    new LogicArrayBlock_2.LogicArrayBlock(),
+    // Assertion/fail
+    new LogicFailBlock_2.LogicFailBlock(),
+    new LogicAssertBlock_2.LogicAssertBlock(),
+];
+/**
+ * Logic blocks as BlockDefinition array for backward compatibility.
+ */
+exports.logicBlocks = exports.logicBlockClasses.map(block => block.toDefinition());