@testsmith/testblocks 0.9.4 → 0.9.7

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

@@ -1,16 +1,77 @@
+/**
+ * Block Registry - Class-Based Architecture
+ *
+ * This module provides the central registry for all blocks.
+ * It supports both class-based blocks (new architecture) and
+ * legacy BlockDefinition arrays (for backward compatibility).
+ */
+import { BlockDefinition } from '../types';
+import { Block } from './base';
+export * from './base';
+export * from './utils';
+export { handleAssertion, flushSoftAssertionErrors, getSoftAssertionErrors, clearSoftAssertionErrors } from './assertions';
+export { registerProcedure, getProcedure, clearProcedures } from './procedures';
 export { apiBlocks } from './api';
-export { playwrightBlocks } from './playwright';
 export { logicBlocks } from './logic';
+export { dataDrivenBlocks } from './data';
+export { procedureBlocks } from './procedures';
 export { lifecycleBlocks } from './lifecycle';
-export { dataDrivenBlocks } from './data-driven';
-export { procedureBlocks, registerProcedure, getProcedure, clearProcedures } from './procedures';
-export { handleAssertion, flushSoftAssertionErrors, getSoftAssertionErrors, clearSoftAssertionErrors } from './assertions';
-import { BlockDefinition } from '../types';
+export { playwrightBlocks } from './playwright';
+export { apiBlockClasses } from './api';
+export { logicBlockClasses } from './logic';
+export { dataBlockClasses } from './data';
+export { procedureBlockClasses } from './procedures';
+export { lifecycleBlockClasses } from './lifecycle';
+export { playwrightBlockClasses } from './playwright';
+/**
+ * All block class instances.
+ */
+export declare const allBlockClasses: Block[];
+/**
+ * All built-in blocks as BlockDefinition array.
+ */
 export declare const builtInBlocks: BlockDefinition[];
+/**
+ * Block registry for runtime lookup.
+ */
 export declare const blockRegistry: Map<string, BlockDefinition>;
+/**
+ * Block class registry for direct class access.
+ */
+export declare const blockClassRegistry: Map<string, Block>;
+/**
+ * Register a single block (legacy BlockDefinition).
+ */
 export declare function registerBlock(block: BlockDefinition): void;
+/**
+ * Register multiple blocks.
+ */
 export declare function registerBlocks(blocks: BlockDefinition[]): void;
+/**
+ * Register a block class.
+ */
+export declare function registerBlockClass(block: Block): void;
+/**
+ * Get a block definition by type.
+ */
 export declare function getBlock(type: string): BlockDefinition | undefined;
+/**
+ * Get a block class by type.
+ */
+export declare function getBlockClass(type: string): Block | undefined;
+/**
+ * Get all registered blocks.
+ */
 export declare function getAllBlocks(): BlockDefinition[];
+/**
+ * Get all block classes.
+ */
+export declare function getAllBlockClasses(): Block[];
+/**
+ * Get blocks by category.
+ */
 export declare function getBlocksByCategory(category: string): BlockDefinition[];
+/**
+ * Get all categories.
+ */
 export declare function getCategories(): string[];

package/dist/core/blocks/index.js

@@ -1,74 +1,173 @@
 "use strict";
+/**
+ * Block Registry - Class-Based Architecture
+ *
+ * This module provides the central registry for all blocks.
+ * It supports both class-based blocks (new architecture) and
+ * legacy BlockDefinition arrays (for backward compatibility).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.blockRegistry = exports.builtInBlocks = exports.clearSoftAssertionErrors = exports.getSoftAssertionErrors = exports.flushSoftAssertionErrors = exports.handleAssertion = exports.clearProcedures = exports.getProcedure = exports.registerProcedure = exports.procedureBlocks = exports.dataDrivenBlocks = exports.lifecycleBlocks = exports.logicBlocks = exports.playwrightBlocks = exports.apiBlocks = void 0;
+exports.blockClassRegistry = exports.blockRegistry = exports.builtInBlocks = exports.allBlockClasses = exports.playwrightBlockClasses = exports.lifecycleBlockClasses = exports.procedureBlockClasses = exports.dataBlockClasses = exports.logicBlockClasses = exports.apiBlockClasses = exports.playwrightBlocks = exports.lifecycleBlocks = exports.procedureBlocks = exports.dataDrivenBlocks = exports.logicBlocks = exports.apiBlocks = exports.clearProcedures = exports.getProcedure = exports.registerProcedure = exports.clearSoftAssertionErrors = exports.getSoftAssertionErrors = exports.flushSoftAssertionErrors = exports.handleAssertion = void 0;
 exports.registerBlock = registerBlock;
 exports.registerBlocks = registerBlocks;
+exports.registerBlockClass = registerBlockClass;
 exports.getBlock = getBlock;
+exports.getBlockClass = getBlockClass;
 exports.getAllBlocks = getAllBlocks;
+exports.getAllBlockClasses = getAllBlockClasses;
 exports.getBlocksByCategory = getBlocksByCategory;
 exports.getCategories = getCategories;
-var api_1 = require("./api");
-Object.defineProperty(exports, "apiBlocks", { enumerable: true, get: function () { return api_1.apiBlocks; } });
-var playwright_1 = require("./playwright");
-Object.defineProperty(exports, "playwrightBlocks", { enumerable: true, get: function () { return playwright_1.playwrightBlocks; } });
-var logic_1 = require("./logic");
-Object.defineProperty(exports, "logicBlocks", { enumerable: true, get: function () { return logic_1.logicBlocks; } });
-var lifecycle_1 = require("./lifecycle");
-Object.defineProperty(exports, "lifecycleBlocks", { enumerable: true, get: function () { return lifecycle_1.lifecycleBlocks; } });
-var data_driven_1 = require("./data-driven");
-Object.defineProperty(exports, "dataDrivenBlocks", { enumerable: true, get: function () { return data_driven_1.dataDrivenBlocks; } });
-var procedures_1 = require("./procedures");
-Object.defineProperty(exports, "procedureBlocks", { enumerable: true, get: function () { return procedures_1.procedureBlocks; } });
-Object.defineProperty(exports, "registerProcedure", { enumerable: true, get: function () { return procedures_1.registerProcedure; } });
-Object.defineProperty(exports, "getProcedure", { enumerable: true, get: function () { return procedures_1.getProcedure; } });
-Object.defineProperty(exports, "clearProcedures", { enumerable: true, get: function () { return procedures_1.clearProcedures; } });
+// Export base classes
+__exportStar(require("./base"), exports);
+// Export utility functions
+__exportStar(require("./utils"), exports);
+// Export assertion functions
 var assertions_1 = require("./assertions");
 Object.defineProperty(exports, "handleAssertion", { enumerable: true, get: function () { return assertions_1.handleAssertion; } });
 Object.defineProperty(exports, "flushSoftAssertionErrors", { enumerable: true, get: function () { return assertions_1.flushSoftAssertionErrors; } });
 Object.defineProperty(exports, "getSoftAssertionErrors", { enumerable: true, get: function () { return assertions_1.getSoftAssertionErrors; } });
 Object.defineProperty(exports, "clearSoftAssertionErrors", { enumerable: true, get: function () { return assertions_1.clearSoftAssertionErrors; } });
-const api_2 = require("./api");
-const playwright_2 = require("./playwright");
-const logic_2 = require("./logic");
-const lifecycle_2 = require("./lifecycle");
-const data_driven_2 = require("./data-driven");
+// Export procedure registry functions
+var procedures_1 = require("./procedures");
+Object.defineProperty(exports, "registerProcedure", { enumerable: true, get: function () { return procedures_1.registerProcedure; } });
+Object.defineProperty(exports, "getProcedure", { enumerable: true, get: function () { return procedures_1.getProcedure; } });
+Object.defineProperty(exports, "clearProcedures", { enumerable: true, get: function () { return procedures_1.clearProcedures; } });
+// Import class-based blocks
+const api_1 = require("./api");
+const logic_1 = require("./logic");
+const data_1 = require("./data");
 const procedures_2 = require("./procedures");
-// All built-in blocks
+const lifecycle_1 = require("./lifecycle");
+const playwright_1 = require("./playwright");
+// Re-export block definitions for backward compatibility
+var api_2 = require("./api");
+Object.defineProperty(exports, "apiBlocks", { enumerable: true, get: function () { return api_2.apiBlocks; } });
+var logic_2 = require("./logic");
+Object.defineProperty(exports, "logicBlocks", { enumerable: true, get: function () { return logic_2.logicBlocks; } });
+var data_2 = require("./data");
+Object.defineProperty(exports, "dataDrivenBlocks", { enumerable: true, get: function () { return data_2.dataDrivenBlocks; } });
+var procedures_3 = require("./procedures");
+Object.defineProperty(exports, "procedureBlocks", { enumerable: true, get: function () { return procedures_3.procedureBlocks; } });
+var lifecycle_2 = require("./lifecycle");
+Object.defineProperty(exports, "lifecycleBlocks", { enumerable: true, get: function () { return lifecycle_2.lifecycleBlocks; } });
+var playwright_2 = require("./playwright");
+Object.defineProperty(exports, "playwrightBlocks", { enumerable: true, get: function () { return playwright_2.playwrightBlocks; } });
+// Re-export block classes for direct access
+var api_3 = require("./api");
+Object.defineProperty(exports, "apiBlockClasses", { enumerable: true, get: function () { return api_3.apiBlockClasses; } });
+var logic_3 = require("./logic");
+Object.defineProperty(exports, "logicBlockClasses", { enumerable: true, get: function () { return logic_3.logicBlockClasses; } });
+var data_3 = require("./data");
+Object.defineProperty(exports, "dataBlockClasses", { enumerable: true, get: function () { return data_3.dataBlockClasses; } });
+var procedures_4 = require("./procedures");
+Object.defineProperty(exports, "procedureBlockClasses", { enumerable: true, get: function () { return procedures_4.procedureBlockClasses; } });
+var lifecycle_3 = require("./lifecycle");
+Object.defineProperty(exports, "lifecycleBlockClasses", { enumerable: true, get: function () { return lifecycle_3.lifecycleBlockClasses; } });
+var playwright_3 = require("./playwright");
+Object.defineProperty(exports, "playwrightBlockClasses", { enumerable: true, get: function () { return playwright_3.playwrightBlockClasses; } });
+/**
+ * All block class instances.
+ */
+exports.allBlockClasses = [
+    ...api_1.apiBlockClasses,
+    ...logic_1.logicBlockClasses,
+    ...data_1.dataBlockClasses,
+    ...procedures_2.procedureBlockClasses,
+    ...lifecycle_1.lifecycleBlockClasses,
+    ...playwright_1.playwrightBlockClasses,
+];
+/**
+ * All built-in blocks as BlockDefinition array.
+ */
 exports.builtInBlocks = [
-    ...api_2.apiBlocks,
-    ...playwright_2.playwrightBlocks,
-    ...logic_2.logicBlocks,
-    ...lifecycle_2.lifecycleBlocks,
-    ...data_driven_2.dataDrivenBlocks,
+    ...api_1.apiBlocks,
+    ...playwright_1.playwrightBlocks,
+    ...logic_1.logicBlocks,
+    ...lifecycle_1.lifecycleBlocks,
+    ...data_1.dataDrivenBlocks,
     ...procedures_2.procedureBlocks,
 ];
-// Block registry for runtime lookup
+/**
+ * Block registry for runtime lookup.
+ */
 exports.blockRegistry = new Map();
-// Initialize registry with built-in blocks
+/**
+ * Block class registry for direct class access.
+ */
+exports.blockClassRegistry = new Map();
+// Initialize registries with built-in blocks
 exports.builtInBlocks.forEach(block => {
     exports.blockRegistry.set(block.type, block);
 });
-// Function to register custom blocks (for plugins)
+exports.allBlockClasses.forEach(block => {
+    exports.blockClassRegistry.set(block.type, block);
+});
+/**
+ * Register a single block (legacy BlockDefinition).
+ */
 function registerBlock(block) {
     exports.blockRegistry.set(block.type, block);
 }
-// Function to register multiple blocks
+/**
+ * Register multiple blocks.
+ */
 function registerBlocks(blocks) {
     blocks.forEach(block => registerBlock(block));
 }
-// Get a block definition by type
+/**
+ * Register a block class.
+ */
+function registerBlockClass(block) {
+    exports.blockClassRegistry.set(block.type, block);
+    exports.blockRegistry.set(block.type, block.toDefinition());
+}
+/**
+ * Get a block definition by type.
+ */
 function getBlock(type) {
     return exports.blockRegistry.get(type);
 }
-// Get all registered blocks
+/**
+ * Get a block class by type.
+ */
+function getBlockClass(type) {
+    return exports.blockClassRegistry.get(type);
+}
+/**
+ * Get all registered blocks.
+ */
 function getAllBlocks() {
     return Array.from(exports.blockRegistry.values());
 }
-// Get blocks by category
+/**
+ * Get all block classes.
+ */
+function getAllBlockClasses() {
+    return Array.from(exports.blockClassRegistry.values());
+}
+/**
+ * Get blocks by category.
+ */
 function getBlocksByCategory(category) {
     return getAllBlocks().filter(block => block.category === category);
 }
-// Get all categories
+/**
+ * Get all categories.
+ */
 function getCategories() {
     const categories = new Set();
     getAllBlocks().forEach(block => categories.add(block.category));

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

@@ -0,0 +1,15 @@
+import { Block } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Steps to run once after all tests in the suite.
+ */
+export declare class LifecycleAfterAllBlock extends Block {
+    readonly type = "lifecycle_after_all";
+    readonly category = "Lifecycle";
+    readonly color = "#8E24AA";
+    readonly tooltip = "Steps to run once after all tests in the suite";
+    readonly previousStatement = false;
+    readonly nextStatement = false;
+    getInputs(): BlockInput[];
+    execute(_params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifecycleAfterAllBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Steps to run once after all tests in the suite.
+ */
+class LifecycleAfterAllBlock extends base_1.Block {
+    constructor() {
+        super(...arguments);
+        this.type = 'lifecycle_after_all';
+        this.category = 'Lifecycle';
+        this.color = '#8E24AA';
+        this.tooltip = 'Steps to run once after all tests in the suite';
+        this.previousStatement = false;
+        this.nextStatement = false;
+    }
+    getInputs() {
+        return [
+            { name: 'DO', type: 'statement' },
+        ];
+    }
+    async execute(_params, _context) {
+        return { lifecycle: 'afterAll', statement: 'DO' };
+    }
+}
+exports.LifecycleAfterAllBlock = LifecycleAfterAllBlock;

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

@@ -0,0 +1,15 @@
+import { Block } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Steps to run after each test.
+ */
+export declare class LifecycleAfterEachBlock extends Block {
+    readonly type = "lifecycle_after_each";
+    readonly category = "Lifecycle";
+    readonly color = "#8E24AA";
+    readonly tooltip = "Steps to run after each test";
+    readonly previousStatement = false;
+    readonly nextStatement = false;
+    getInputs(): BlockInput[];
+    execute(_params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifecycleAfterEachBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Steps to run after each test.
+ */
+class LifecycleAfterEachBlock extends base_1.Block {
+    constructor() {
+        super(...arguments);
+        this.type = 'lifecycle_after_each';
+        this.category = 'Lifecycle';
+        this.color = '#8E24AA';
+        this.tooltip = 'Steps to run after each test';
+        this.previousStatement = false;
+        this.nextStatement = false;
+    }
+    getInputs() {
+        return [
+            { name: 'DO', type: 'statement' },
+        ];
+    }
+    async execute(_params, _context) {
+        return { lifecycle: 'afterEach', statement: 'DO' };
+    }
+}
+exports.LifecycleAfterEachBlock = LifecycleAfterEachBlock;

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

@@ -0,0 +1,15 @@
+import { Block } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Steps to run once before all tests in the suite.
+ */
+export declare class LifecycleBeforeAllBlock extends Block {
+    readonly type = "lifecycle_before_all";
+    readonly category = "Lifecycle";
+    readonly color = "#8E24AA";
+    readonly tooltip = "Steps to run once before all tests in the suite";
+    readonly previousStatement = false;
+    readonly nextStatement = false;
+    getInputs(): BlockInput[];
+    execute(_params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifecycleBeforeAllBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Steps to run once before all tests in the suite.
+ */
+class LifecycleBeforeAllBlock extends base_1.Block {
+    constructor() {
+        super(...arguments);
+        this.type = 'lifecycle_before_all';
+        this.category = 'Lifecycle';
+        this.color = '#8E24AA';
+        this.tooltip = 'Steps to run once before all tests in the suite';
+        this.previousStatement = false;
+        this.nextStatement = false;
+    }
+    getInputs() {
+        return [
+            { name: 'DO', type: 'statement' },
+        ];
+    }
+    async execute(_params, _context) {
+        // Marker block - actual execution handled by executor
+        return { lifecycle: 'beforeAll', statement: 'DO' };
+    }
+}
+exports.LifecycleBeforeAllBlock = LifecycleBeforeAllBlock;

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

@@ -0,0 +1,15 @@
+import { Block } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Steps to run before each test.
+ */
+export declare class LifecycleBeforeEachBlock extends Block {
+    readonly type = "lifecycle_before_each";
+    readonly category = "Lifecycle";
+    readonly color = "#8E24AA";
+    readonly tooltip = "Steps to run before each test";
+    readonly previousStatement = false;
+    readonly nextStatement = false;
+    getInputs(): BlockInput[];
+    execute(_params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifecycleBeforeEachBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Steps to run before each test.
+ */
+class LifecycleBeforeEachBlock extends base_1.Block {
+    constructor() {
+        super(...arguments);
+        this.type = 'lifecycle_before_each';
+        this.category = 'Lifecycle';
+        this.color = '#8E24AA';
+        this.tooltip = 'Steps to run before each test';
+        this.previousStatement = false;
+        this.nextStatement = false;
+    }
+    getInputs() {
+        return [
+            { name: 'DO', type: 'statement' },
+        ];
+    }
+    async execute(_params, _context) {
+        return { lifecycle: 'beforeEach', statement: 'DO' };
+    }
+}
+exports.LifecycleBeforeEachBlock = LifecycleBeforeEachBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Steps to run only if the test fails.
+ */
+export declare class LifecycleOnFailureBlock extends StatementBlock {
+    readonly type = "lifecycle_on_failure";
+    readonly category = "Lifecycle";
+    readonly color = "#C62828";
+    readonly tooltip = "Steps to run only if the test fails";
+    getInputs(): BlockInput[];
+    execute(_params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifecycleOnFailureBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Steps to run only if the test fails.
+ */
+class LifecycleOnFailureBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'lifecycle_on_failure';
+        this.category = 'Lifecycle';
+        this.color = '#C62828';
+        this.tooltip = 'Steps to run only if the test fails';
+    }
+    getInputs() {
+        return [
+            { name: 'DO', type: 'statement' },
+        ];
+    }
+    async execute(_params, _context) {
+        return { lifecycle: 'onFailure', statement: 'DO' };
+    }
+}
+exports.LifecycleOnFailureBlock = LifecycleOnFailureBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Retry steps on failure.
+ */
+export declare class LifecycleRetryBlock extends StatementBlock {
+    readonly type = "lifecycle_retry";
+    readonly category = "Lifecycle";
+    readonly color = "#FF6F00";
+    readonly tooltip = "Retry steps on failure";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifecycleRetryBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Retry steps on failure.
+ */
+class LifecycleRetryBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'lifecycle_retry';
+        this.category = 'Lifecycle';
+        this.color = '#FF6F00';
+        this.tooltip = 'Retry steps on failure';
+    }
+    getInputs() {
+        return [
+            { name: 'TIMES', type: 'field', fieldType: 'number', default: 3 },
+            { name: 'DELAY', type: 'field', fieldType: 'number', default: 1000 },
+            { name: 'DO', type: 'statement' },
+        ];
+    }
+    async execute(params, _context) {
+        const times = params.TIMES;
+        const delay = params.DELAY;
+        return { retry: true, times, delay, statement: 'DO' };
+    }
+}
+exports.LifecycleRetryBlock = LifecycleRetryBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Setup steps to run before the test.
+ */
+export declare class LifecycleSetupBlock extends StatementBlock {
+    readonly type = "lifecycle_setup";
+    readonly category = "Lifecycle";
+    readonly color = "#8E24AA";
+    readonly tooltip = "Setup steps to run before the test";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

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

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

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Skip the rest of the test if condition is true.
+ */
+export declare class LifecycleSkipIfBlock extends StatementBlock {
+    readonly type = "lifecycle_skip_if";
+    readonly category = "Lifecycle";
+    readonly color = "#757575";
+    readonly tooltip = "Skip the rest of the test if condition is true";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LifecycleSkipIfBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Skip the rest of the test if condition is true.
+ */
+class LifecycleSkipIfBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'lifecycle_skip_if';
+        this.category = 'Lifecycle';
+        this.color = '#757575';
+        this.tooltip = 'Skip the rest of the test if condition is true';
+    }
+    getInputs() {
+        return [
+            { name: 'CONDITION', type: 'value', check: 'Boolean', required: true },
+            { name: 'REASON', type: 'field', fieldType: 'text', default: 'Condition not met' },
+        ];
+    }
+    async execute(params, _context) {
+        const condition = params.CONDITION;
+        const reason = params.REASON;
+        if (condition) {
+            throw { skip: true, reason };
+        }
+        return undefined;
+    }
+}
+exports.LifecycleSkipIfBlock = LifecycleSkipIfBlock;

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

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Teardown steps to run after the test.
+ */
+export declare class LifecycleTeardownBlock extends StatementBlock {
+    readonly type = "lifecycle_teardown";
+    readonly category = "Lifecycle";
+    readonly color = "#8E24AA";
+    readonly tooltip = "Teardown steps to run after the test";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}