@testsmith/testblocks 0.9.4 → 0.9.7

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

@@ -0,0 +1,5 @@
+export { Block } from './Block';
+export { StatementBlock } from './StatementBlock';
+export { ValueBlock } from './ValueBlock';
+export { ContainerBlock } from './ContainerBlock';
+export { ControlFlowBlock } from './ControlFlowBlock';

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlFlowBlock = exports.ContainerBlock = exports.ValueBlock = exports.StatementBlock = exports.Block = void 0;
+var Block_1 = require("./Block");
+Object.defineProperty(exports, "Block", { enumerable: true, get: function () { return Block_1.Block; } });
+var StatementBlock_1 = require("./StatementBlock");
+Object.defineProperty(exports, "StatementBlock", { enumerable: true, get: function () { return StatementBlock_1.StatementBlock; } });
+var ValueBlock_1 = require("./ValueBlock");
+Object.defineProperty(exports, "ValueBlock", { enumerable: true, get: function () { return ValueBlock_1.ValueBlock; } });
+var ContainerBlock_1 = require("./ContainerBlock");
+Object.defineProperty(exports, "ContainerBlock", { enumerable: true, get: function () { return ContainerBlock_1.ContainerBlock; } });
+var ControlFlowBlock_1 = require("./ControlFlowBlock");
+Object.defineProperty(exports, "ControlFlowBlock", { enumerable: true, get: function () { return ControlFlowBlock_1.ControlFlowBlock; } });

package/dist/core/blocks/data/DataCsvBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Parse CSV-style data (first row as headers).
+ */
+export declare class DataCsvBlock extends ValueBlock {
+    readonly type = "data_csv";
+    readonly category = "Data";
+    readonly color = "#00897B";
+    readonly tooltip = "Parse CSV-style data (first row as headers)";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/data/DataCsvBlock.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataCsvBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Parse CSV-style data (first row as headers).
+ */
+class DataCsvBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'data_csv';
+        this.category = 'Data';
+        this.color = '#00897B';
+        this.tooltip = 'Parse CSV-style data (first row as headers)';
+        this.output = { type: 'Array' };
+    }
+    getInputs() {
+        return [
+            { name: 'CSV', type: 'field', fieldType: 'text', default: 'name,value\ntest1,100\ntest2,200' },
+        ];
+    }
+    async execute(params, context) {
+        const csv = (0, utils_1.resolveVariables)(params.CSV, context);
+        const lines = csv.split('\n').filter(l => l.trim());
+        if (lines.length < 2) {
+            return [];
+        }
+        const headers = lines[0].split(',').map(h => h.trim());
+        return lines.slice(1).map((line, index) => {
+            const values = line.split(',').map(v => {
+                const trimmed = v.trim();
+                try {
+                    return JSON.parse(trimmed);
+                }
+                catch {
+                    return trimmed;
+                }
+            });
+            const obj = {};
+            headers.forEach((header, i) => {
+                obj[header] = values[i];
+            });
+            return {
+                name: `Row ${index + 1}`,
+                values: obj,
+            };
+        });
+    }
+}
+exports.DataCsvBlock = DataCsvBlock;

package/dist/core/blocks/data/DataDefineBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Define test data sets for data-driven testing.
+ */
+export declare class DataDefineBlock extends ValueBlock {
+    readonly type = "data_define";
+    readonly category = "Data";
+    readonly color = "#00897B";
+    readonly tooltip = "Define test data sets for data-driven testing";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/data/DataDefineBlock.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataDefineBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Define test data sets for data-driven testing.
+ */
+class DataDefineBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'data_define';
+        this.category = 'Data';
+        this.color = '#00897B';
+        this.tooltip = 'Define test data sets for data-driven testing';
+        this.output = { type: 'Array' };
+    }
+    getInputs() {
+        return [
+            { name: 'DATA_JSON', type: 'field', fieldType: 'text', default: '[{"name": "test1", "value": 1}]' },
+        ];
+    }
+    async execute(params, context) {
+        const json = (0, utils_1.resolveVariables)(params.DATA_JSON, context);
+        return JSON.parse(json);
+    }
+}
+exports.DataDefineBlock = DataDefineBlock;

package/dist/core/blocks/data/DataForeachBlock.d.ts

@@ -0,0 +1,13 @@
+import { ControlFlowBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Run steps for each item in a data set.
+ */
+export declare class DataForeachBlock extends ControlFlowBlock {
+    readonly type = "data_foreach";
+    readonly category = "Data";
+    readonly color = "#00897B";
+    readonly tooltip = "Run steps for each item in a data set";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/data/DataForeachBlock.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataForeachBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Run steps for each item in a data set.
+ */
+class DataForeachBlock extends base_1.ControlFlowBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'data_foreach';
+        this.category = 'Data';
+        this.color = '#00897B';
+        this.tooltip = 'Run steps for each item in a data set';
+    }
+    getInputs() {
+        return [
+            { name: 'DATA', type: 'value', check: 'Array', required: true },
+            { name: 'ITEM_VAR', type: 'field', fieldType: 'text', default: 'item' },
+            { name: 'INDEX_VAR', type: 'field', fieldType: 'text', default: 'index' },
+            { name: 'DO', type: 'statement' },
+        ];
+    }
+    async execute(params, _context) {
+        const data = params.DATA;
+        const itemVar = params.ITEM_VAR;
+        const indexVar = params.INDEX_VAR;
+        return {
+            dataLoop: true,
+            data,
+            itemVar,
+            indexVar,
+            statement: 'DO',
+        };
+    }
+}
+exports.DataForeachBlock = DataForeachBlock;

package/dist/core/blocks/data/DataFromVariableBlock.d.ts

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

package/dist/core/blocks/data/DataFromVariableBlock.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataFromVariableBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Get test data from a variable.
+ */
+class DataFromVariableBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'data_from_variable';
+        this.category = 'Data';
+        this.color = '#00897B';
+        this.tooltip = 'Get test data from a variable';
+        this.output = { type: '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.DataFromVariableBlock = DataFromVariableBlock;

package/dist/core/blocks/data/DataGetCurrentBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Get a value from the current data set.
+ */
+export declare class DataGetCurrentBlock extends ValueBlock {
+    readonly type = "data_get_current";
+    readonly category = "Data";
+    readonly color = "#00897B";
+    readonly tooltip = "Get a value from the current data set";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/data/DataGetCurrentBlock.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataGetCurrentBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Get a value from the current data set.
+ */
+class DataGetCurrentBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'data_get_current';
+        this.category = 'Data';
+        this.color = '#00897B';
+        this.tooltip = 'Get a value from the current data set';
+        this.output = { type: ['String', 'Number', 'Boolean', 'Object', 'Array'] };
+    }
+    getInputs() {
+        return [
+            { name: 'KEY', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const key = params.KEY;
+        if (!context.currentData) {
+            throw new Error('No data set available. This block must be used inside a data-driven test.');
+        }
+        const value = context.currentData.values[key];
+        if (value === undefined) {
+            context.logger.warn(`Data key "${key}" not found in current data set`);
+        }
+        return value;
+    }
+}
+exports.DataGetCurrentBlock = DataGetCurrentBlock;

package/dist/core/blocks/data/DataGetIndexBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Get the current data iteration index (0-based).
+ */
+export declare class DataGetIndexBlock extends ValueBlock {
+    readonly type = "data_get_index";
+    readonly category = "Data";
+    readonly color = "#00897B";
+    readonly tooltip = "Get the current data iteration index (0-based)";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(_params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/data/DataGetIndexBlock.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataGetIndexBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Get the current data iteration index (0-based).
+ */
+class DataGetIndexBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'data_get_index';
+        this.category = 'Data';
+        this.color = '#00897B';
+        this.tooltip = 'Get the current data iteration index (0-based)';
+        this.output = { type: 'Number' };
+    }
+    getInputs() {
+        return [];
+    }
+    async execute(_params, context) {
+        return context.dataIndex ?? 0;
+    }
+}
+exports.DataGetIndexBlock = DataGetIndexBlock;

package/dist/core/blocks/data/DataGetNameBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Get the name of the current data set.
+ */
+export declare class DataGetNameBlock extends ValueBlock {
+    readonly type = "data_get_name";
+    readonly category = "Data";
+    readonly color = "#00897B";
+    readonly tooltip = "Get the name of the current data set";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(_params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/data/DataGetNameBlock.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataGetNameBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Get the name of the current data set.
+ */
+class DataGetNameBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'data_get_name';
+        this.category = 'Data';
+        this.color = '#00897B';
+        this.tooltip = 'Get the name of the current data set';
+        this.output = { type: 'String' };
+    }
+    getInputs() {
+        return [];
+    }
+    async execute(_params, context) {
+        return context.currentData?.name ?? `Iteration ${(context.dataIndex ?? 0) + 1}`;
+    }
+}
+exports.DataGetNameBlock = DataGetNameBlock;

package/dist/core/blocks/data/DataRangeBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Generate a range of numbers as data.
+ */
+export declare class DataRangeBlock extends ValueBlock {
+    readonly type = "data_range";
+    readonly category = "Data";
+    readonly color = "#00897B";
+    readonly tooltip = "Generate a range of numbers as data";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, _context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/data/DataRangeBlock.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataRangeBlock = void 0;
+const base_1 = require("../base");
+/**
+ * Generate a range of numbers as data.
+ */
+class DataRangeBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'data_range';
+        this.category = 'Data';
+        this.color = '#00897B';
+        this.tooltip = 'Generate a range of numbers as data';
+        this.output = { type: 'Array' };
+    }
+    getInputs() {
+        return [
+            { name: 'START', type: 'field', fieldType: 'number', default: 1 },
+            { name: 'END', type: 'field', fieldType: 'number', default: 10 },
+            { name: 'STEP', type: 'field', fieldType: 'number', default: 1 },
+            { name: 'VAR_NAME', type: 'field', fieldType: 'text', default: 'n' },
+        ];
+    }
+    async execute(params, _context) {
+        const start = params.START;
+        const end = params.END;
+        const step = params.STEP;
+        const varName = params.VAR_NAME;
+        const result = [];
+        for (let i = start; i <= end; i += step) {
+            result.push({
+                name: `${varName}=${i}`,
+                values: { [varName]: i },
+            });
+        }
+        return result;
+    }
+}
+exports.DataRangeBlock = DataRangeBlock;

package/dist/core/blocks/data/DataRowBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Create a single data row with key-value pairs.
+ */
+export declare class DataRowBlock extends ValueBlock {
+    readonly type = "data_row";
+    readonly category = "Data";
+    readonly color = "#00897B";
+    readonly tooltip = "Create a single data row with key-value pairs";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/data/DataRowBlock.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataRowBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Create a single data row with key-value pairs.
+ */
+class DataRowBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'data_row';
+        this.category = 'Data';
+        this.color = '#00897B';
+        this.tooltip = 'Create a single data row with key-value pairs';
+        this.output = { type: 'Object' };
+    }
+    getInputs() {
+        return [
+            { name: 'NAME', type: 'field', fieldType: 'text', default: '' },
+            { name: 'JSON', type: 'field', fieldType: 'text', default: '{}' },
+        ];
+    }
+    async execute(params, context) {
+        const name = params.NAME;
+        const json = (0, utils_1.resolveVariables)(params.JSON, context);
+        return {
+            name: name || undefined,
+            values: JSON.parse(json),
+        };
+    }
+}
+exports.DataRowBlock = DataRowBlock;

package/dist/core/blocks/data/DataTableBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Create a data table with headers and rows.
+ */
+export declare class DataTableBlock extends ValueBlock {
+    readonly type = "data_table";
+    readonly category = "Data";
+    readonly color = "#00897B";
+    readonly tooltip = "Create a data table with headers and rows";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/data/DataTableBlock.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTableBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+/**
+ * Create a data table with headers and rows.
+ */
+class DataTableBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'data_table';
+        this.category = 'Data';
+        this.color = '#00897B';
+        this.tooltip = 'Create a data table with headers and rows';
+        this.output = { type: 'Array' };
+    }
+    getInputs() {
+        return [
+            { name: 'HEADERS', type: 'field', fieldType: 'text', default: 'username, password, expected' },
+            { name: 'ROWS', type: 'field', fieldType: 'text', default: 'user1, pass1, true\nuser2, pass2, false' },
+        ];
+    }
+    async execute(params, context) {
+        const headersStr = params.HEADERS;
+        const rowsStr = (0, utils_1.resolveVariables)(params.ROWS, context);
+        const headers = headersStr.split(',').map(h => h.trim());
+        const rows = rowsStr.split('\n').filter(r => r.trim());
+        return rows.map((row, index) => {
+            const values = row.split(',').map(v => {
+                const trimmed = v.trim();
+                // Try to parse as JSON for numbers, booleans, etc.
+                try {
+                    return JSON.parse(trimmed);
+                }
+                catch {
+                    return trimmed;
+                }
+            });
+            const obj = {};
+            headers.forEach((header, i) => {
+                obj[header] = values[i];
+            });
+            return {
+                name: `Row ${index + 1}`,
+                values: obj,
+            };
+        });
+    }
+}
+exports.DataTableBlock = DataTableBlock;

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

@@ -0,0 +1,20 @@
+import { Block } from '../base';
+import { BlockDefinition } from '../../types';
+export { DataDefineBlock } from './DataDefineBlock';
+export { DataFromVariableBlock } from './DataFromVariableBlock';
+export { DataRowBlock } from './DataRowBlock';
+export { DataTableBlock } from './DataTableBlock';
+export { DataCsvBlock } from './DataCsvBlock';
+export { DataRangeBlock } from './DataRangeBlock';
+export { DataGetCurrentBlock } from './DataGetCurrentBlock';
+export { DataGetIndexBlock } from './DataGetIndexBlock';
+export { DataGetNameBlock } from './DataGetNameBlock';
+export { DataForeachBlock } from './DataForeachBlock';
+/**
+ * All Data block class instances.
+ */
+export declare const dataBlockClasses: Block[];
+/**
+ * Data-driven blocks as BlockDefinition array for backward compatibility.
+ */
+export declare const dataDrivenBlocks: BlockDefinition[];

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataDrivenBlocks = exports.dataBlockClasses = exports.DataForeachBlock = exports.DataGetNameBlock = exports.DataGetIndexBlock = exports.DataGetCurrentBlock = exports.DataRangeBlock = exports.DataCsvBlock = exports.DataTableBlock = exports.DataRowBlock = exports.DataFromVariableBlock = exports.DataDefineBlock = void 0;
+// Data definition blocks
+var DataDefineBlock_1 = require("./DataDefineBlock");
+Object.defineProperty(exports, "DataDefineBlock", { enumerable: true, get: function () { return DataDefineBlock_1.DataDefineBlock; } });
+var DataFromVariableBlock_1 = require("./DataFromVariableBlock");
+Object.defineProperty(exports, "DataFromVariableBlock", { enumerable: true, get: function () { return DataFromVariableBlock_1.DataFromVariableBlock; } });
+var DataRowBlock_1 = require("./DataRowBlock");
+Object.defineProperty(exports, "DataRowBlock", { enumerable: true, get: function () { return DataRowBlock_1.DataRowBlock; } });
+var DataTableBlock_1 = require("./DataTableBlock");
+Object.defineProperty(exports, "DataTableBlock", { enumerable: true, get: function () { return DataTableBlock_1.DataTableBlock; } });
+var DataCsvBlock_1 = require("./DataCsvBlock");
+Object.defineProperty(exports, "DataCsvBlock", { enumerable: true, get: function () { return DataCsvBlock_1.DataCsvBlock; } });
+var DataRangeBlock_1 = require("./DataRangeBlock");
+Object.defineProperty(exports, "DataRangeBlock", { enumerable: true, get: function () { return DataRangeBlock_1.DataRangeBlock; } });
+// Data access blocks
+var DataGetCurrentBlock_1 = require("./DataGetCurrentBlock");
+Object.defineProperty(exports, "DataGetCurrentBlock", { enumerable: true, get: function () { return DataGetCurrentBlock_1.DataGetCurrentBlock; } });
+var DataGetIndexBlock_1 = require("./DataGetIndexBlock");
+Object.defineProperty(exports, "DataGetIndexBlock", { enumerable: true, get: function () { return DataGetIndexBlock_1.DataGetIndexBlock; } });
+var DataGetNameBlock_1 = require("./DataGetNameBlock");
+Object.defineProperty(exports, "DataGetNameBlock", { enumerable: true, get: function () { return DataGetNameBlock_1.DataGetNameBlock; } });
+// Control flow
+var DataForeachBlock_1 = require("./DataForeachBlock");
+Object.defineProperty(exports, "DataForeachBlock", { enumerable: true, get: function () { return DataForeachBlock_1.DataForeachBlock; } });
+// Import all block classes
+const DataDefineBlock_2 = require("./DataDefineBlock");
+const DataFromVariableBlock_2 = require("./DataFromVariableBlock");
+const DataRowBlock_2 = require("./DataRowBlock");
+const DataTableBlock_2 = require("./DataTableBlock");
+const DataCsvBlock_2 = require("./DataCsvBlock");
+const DataRangeBlock_2 = require("./DataRangeBlock");
+const DataGetCurrentBlock_2 = require("./DataGetCurrentBlock");
+const DataGetIndexBlock_2 = require("./DataGetIndexBlock");
+const DataGetNameBlock_2 = require("./DataGetNameBlock");
+const DataForeachBlock_2 = require("./DataForeachBlock");
+/**
+ * All Data block class instances.
+ */
+exports.dataBlockClasses = [
+    // Data definition
+    new DataDefineBlock_2.DataDefineBlock(),
+    new DataFromVariableBlock_2.DataFromVariableBlock(),
+    new DataGetCurrentBlock_2.DataGetCurrentBlock(),
+    new DataGetIndexBlock_2.DataGetIndexBlock(),
+    new DataGetNameBlock_2.DataGetNameBlock(),
+    new DataForeachBlock_2.DataForeachBlock(),
+    new DataRowBlock_2.DataRowBlock(),
+    new DataTableBlock_2.DataTableBlock(),
+    new DataCsvBlock_2.DataCsvBlock(),
+    new DataRangeBlock_2.DataRangeBlock(),
+];
+/**
+ * Data-driven blocks as BlockDefinition array for backward compatibility.
+ */
+exports.dataDrivenBlocks = exports.dataBlockClasses.map(block => block.toDefinition());