testblocks 0.1.0

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

@@ -0,0 +1,5 @@
+import { BlockDefinition, ProcedureDefinition } from '../types';
+export declare function registerProcedure(name: string, procedure: ProcedureDefinition): void;
+export declare function getProcedure(name: string): ProcedureDefinition | undefined;
+export declare function clearProcedures(): void;
+export declare const procedureBlocks: BlockDefinition[];

package/dist/core/blocks/procedures.js

@@ -0,0 +1,321 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.procedureBlocks = void 0;
+exports.registerProcedure = registerProcedure;
+exports.getProcedure = getProcedure;
+exports.clearProcedures = clearProcedures;
+// Procedure registry for runtime
+const procedureRegistry = new Map();
+function registerProcedure(name, procedure) {
+    procedureRegistry.set(name, procedure);
+}
+function getProcedure(name) {
+    return procedureRegistry.get(name);
+}
+function clearProcedures() {
+    procedureRegistry.clear();
+}
+// Procedure Blocks - Custom Reusable Actions
+exports.procedureBlocks = [
+    // Define a procedure (function)
+    {
+        type: 'procedure_define',
+        category: 'Procedures',
+        color: '#9C27B0',
+        tooltip: 'Define a reusable procedure with parameters',
+        inputs: [
+            { name: 'NAME', type: 'field', fieldType: 'text', required: true },
+            { name: 'DESCRIPTION', type: 'field', fieldType: 'text', default: '' },
+            { name: 'PARAMS', type: 'field', fieldType: 'text', default: '' }, // comma-separated: "username, password, timeout"
+            { name: 'DO', type: 'statement' },
+        ],
+        execute: async (params, context) => {
+            const name = params.NAME;
+            const description = params.DESCRIPTION;
+            const paramsStr = params.PARAMS;
+            // Parse parameters
+            const procedureParams = paramsStr
+                .split(',')
+                .map(p => p.trim())
+                .filter(p => p)
+                .map(p => {
+                // Support type annotations: "username:string", "count:number"
+                const [paramName, paramType] = p.split(':').map(s => s.trim());
+                return {
+                    name: paramName,
+                    type: paramType || 'any',
+                };
+            });
+            // Register the procedure
+            const procedure = {
+                name,
+                description,
+                params: procedureParams,
+                steps: [], // Steps will be extracted by the executor
+            };
+            registerProcedure(name, procedure);
+            if (context.procedures) {
+                context.procedures.set(name, procedure);
+            }
+            context.logger.debug(`Defined procedure: ${name}(${procedureParams.map(p => p.name).join(', ')})`);
+            return { procedureDefine: true, name, procedure };
+        },
+    },
+    // Call a procedure
+    {
+        type: 'procedure_call',
+        category: 'Procedures',
+        color: '#9C27B0',
+        tooltip: 'Call a defined procedure',
+        inputs: [
+            { name: 'NAME', type: 'field', fieldType: 'text', required: true },
+            { name: 'ARGS', type: 'field', fieldType: 'text', default: '' }, // JSON object or comma-separated values
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const name = params.NAME;
+            const argsStr = resolveVariables(params.ARGS, context);
+            // Look up procedure
+            const procedure = context.procedures?.get(name) || getProcedure(name);
+            if (!procedure) {
+                throw new Error(`Procedure not found: ${name}`);
+            }
+            // Parse arguments
+            let args = {};
+            if (argsStr.trim()) {
+                try {
+                    // Try JSON format first: {"username": "test", "password": "123"}
+                    args = JSON.parse(argsStr);
+                }
+                catch {
+                    // Fall back to comma-separated values matching parameter order
+                    const values = argsStr.split(',').map(v => {
+                        const trimmed = v.trim();
+                        try {
+                            return JSON.parse(trimmed);
+                        }
+                        catch {
+                            return trimmed;
+                        }
+                    });
+                    if (procedure.params) {
+                        procedure.params.forEach((param, index) => {
+                            if (index < values.length) {
+                                args[param.name] = values[index];
+                            }
+                            else if (param.default !== undefined) {
+                                args[param.name] = param.default;
+                            }
+                        });
+                    }
+                }
+            }
+            context.logger.info(`Calling procedure: ${name}`);
+            return { procedureCall: true, name, args, procedure };
+        },
+    },
+    // Call procedure with return value
+    {
+        type: 'procedure_call_with_return',
+        category: 'Procedures',
+        color: '#9C27B0',
+        tooltip: 'Call a procedure and get return value',
+        inputs: [
+            { name: 'NAME', type: 'field', fieldType: 'text', required: true },
+            { name: 'ARGS', type: 'field', fieldType: 'text', default: '' },
+        ],
+        output: { type: ['String', 'Number', 'Boolean', 'Object', 'Array'] },
+        execute: async (params, context) => {
+            const name = params.NAME;
+            const argsStr = resolveVariables(params.ARGS, context);
+            const procedure = context.procedures?.get(name) || getProcedure(name);
+            if (!procedure) {
+                throw new Error(`Procedure not found: ${name}`);
+            }
+            let args = {};
+            if (argsStr.trim()) {
+                try {
+                    args = JSON.parse(argsStr);
+                }
+                catch {
+                    const values = argsStr.split(',').map(v => v.trim());
+                    if (procedure.params) {
+                        procedure.params.forEach((param, index) => {
+                            if (index < values.length) {
+                                args[param.name] = values[index];
+                            }
+                        });
+                    }
+                }
+            }
+            return { procedureCall: true, name, args, procedure, expectReturn: true };
+        },
+    },
+    // Return from procedure
+    {
+        type: 'procedure_return',
+        category: 'Procedures',
+        color: '#9C27B0',
+        tooltip: 'Return a value from a procedure',
+        inputs: [
+            { name: 'VALUE', type: 'value' },
+        ],
+        previousStatement: true,
+        execute: async (params, _context) => {
+            const value = params.VALUE;
+            return { procedureReturn: true, value };
+        },
+    },
+    // Get procedure parameter
+    {
+        type: 'procedure_get_param',
+        category: 'Procedures',
+        color: '#9C27B0',
+        tooltip: 'Get a procedure parameter value',
+        inputs: [
+            { name: 'NAME', type: 'field', fieldType: 'text', required: true },
+        ],
+        output: { type: ['String', 'Number', 'Boolean', 'Object', 'Array'] },
+        execute: async (params, context) => {
+            const name = params.NAME;
+            // Parameters are stored in variables with a prefix
+            const value = context.variables.get(`__param_${name}`);
+            if (value === undefined) {
+                // Check regular variables as fallback
+                return context.variables.get(name);
+            }
+            return value;
+        },
+    },
+    // Define inline procedure (lambda-style)
+    {
+        type: 'procedure_inline',
+        category: 'Procedures',
+        color: '#9C27B0',
+        tooltip: 'Define and immediately use an inline procedure',
+        inputs: [
+            { name: 'PARAMS', type: 'field', fieldType: 'text', default: '' },
+            { name: 'DO', type: 'statement' },
+        ],
+        output: { type: 'Procedure' },
+        execute: async (params, _context) => {
+            return {
+                inlineProcedure: true,
+                params: params.PARAMS.split(',').map(p => p.trim()).filter(p => p),
+                statement: 'DO',
+            };
+        },
+    },
+    // Apply/Map procedure to array
+    {
+        type: 'procedure_map',
+        category: 'Procedures',
+        color: '#9C27B0',
+        tooltip: 'Apply a procedure to each item in an array',
+        inputs: [
+            { name: 'ARRAY', type: 'value', check: 'Array', required: true },
+            { name: 'PROCEDURE', type: 'field', fieldType: 'text', required: true },
+            { name: 'ITEM_PARAM', type: 'field', fieldType: 'text', default: 'item' },
+        ],
+        output: { type: 'Array' },
+        execute: async (params, _context) => {
+            const array = params.ARRAY;
+            const procedureName = params.PROCEDURE;
+            const itemParam = params.ITEM_PARAM;
+            return {
+                procedureMap: true,
+                array,
+                procedureName,
+                itemParam,
+            };
+        },
+    },
+    // Common action blocks - frequently used patterns
+    // Login procedure template
+    {
+        type: 'procedure_login',
+        category: 'Procedures',
+        color: '#AB47BC',
+        tooltip: 'Common login action with username and password',
+        inputs: [
+            { name: 'USERNAME_SELECTOR', type: 'field', fieldType: 'text', default: '#username' },
+            { name: 'PASSWORD_SELECTOR', type: 'field', fieldType: 'text', default: '#password' },
+            { name: 'SUBMIT_SELECTOR', type: 'field', fieldType: 'text', default: 'button[type="submit"]' },
+            { name: 'USERNAME', type: 'value', check: 'String', required: true },
+            { name: 'PASSWORD', type: 'value', check: 'String', required: true },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, _context) => {
+            // This is a compound action that expands to multiple steps
+            return {
+                compoundAction: 'login',
+                steps: [
+                    { type: 'web_fill', params: { SELECTOR: params.USERNAME_SELECTOR, VALUE: params.USERNAME } },
+                    { type: 'web_fill', params: { SELECTOR: params.PASSWORD_SELECTOR, VALUE: params.PASSWORD } },
+                    { type: 'web_click', params: { SELECTOR: params.SUBMIT_SELECTOR } },
+                ],
+            };
+        },
+    },
+    // Wait for element and click
+    {
+        type: 'procedure_wait_and_click',
+        category: 'Procedures',
+        color: '#AB47BC',
+        tooltip: 'Wait for element to be visible then click',
+        inputs: [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'TIMEOUT', type: 'field', fieldType: 'number', default: 30000 },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, _context) => {
+            return {
+                compoundAction: 'waitAndClick',
+                steps: [
+                    { type: 'web_wait_for_element', params: { SELECTOR: params.SELECTOR, STATE: 'visible', TIMEOUT: params.TIMEOUT } },
+                    { type: 'web_click', params: { SELECTOR: params.SELECTOR } },
+                ],
+            };
+        },
+    },
+    // Fill form fields from object
+    {
+        type: 'procedure_fill_form',
+        category: 'Procedures',
+        color: '#AB47BC',
+        tooltip: 'Fill multiple form fields from a data object',
+        inputs: [
+            { name: 'FIELDS', type: 'value', check: 'Object', required: true },
+        ],
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, _context) => {
+            const fields = params.FIELDS;
+            const steps = Object.entries(fields).map(([selector, value]) => ({
+                type: 'web_fill',
+                params: { SELECTOR: selector, VALUE: value },
+            }));
+            return { compoundAction: 'fillForm', steps };
+        },
+    },
+];
+// Helper function
+function resolveVariables(text, context) {
+    return text.replace(/\$\{(\w+)\}/g, (_, varName) => {
+        // Check param prefix first
+        const paramValue = context.variables.get(`__param_${varName}`);
+        if (paramValue !== undefined) {
+            return String(paramValue);
+        }
+        // Then check current data
+        if (context.currentData?.values[varName] !== undefined) {
+            return String(context.currentData.values[varName]);
+        }
+        // Then regular variables
+        const value = context.variables.get(varName);
+        return value !== undefined ? String(value) : '';
+    });
+}

package/dist/core/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './blocks';
+export * from './plugins';
+export { builtInBlocks, blockRegistry, registerBlock, registerBlocks, getBlock, getAllBlocks, getBlocksByCategory, getCategories, } from './blocks';
+export { registerPlugin, getPlugin, getAllPlugins, getAllPluginBlocks, unregisterPlugin, createPlugin, createBlock, createActionBlock, createValueBlock, createAssertionBlock, } from './plugins';

package/dist/core/index.js

@@ -0,0 +1,44 @@
+"use strict";
+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.createAssertionBlock = exports.createValueBlock = exports.createActionBlock = exports.createBlock = exports.createPlugin = exports.unregisterPlugin = exports.getAllPluginBlocks = exports.getAllPlugins = exports.getPlugin = exports.registerPlugin = exports.getCategories = exports.getBlocksByCategory = exports.getAllBlocks = exports.getBlock = exports.registerBlocks = exports.registerBlock = exports.blockRegistry = exports.builtInBlocks = void 0;
+// Types
+__exportStar(require("./types"), exports);
+// Blocks
+__exportStar(require("./blocks"), exports);
+// Plugins
+__exportStar(require("./plugins"), exports);
+// Re-export specific items for convenience
+var blocks_1 = require("./blocks");
+Object.defineProperty(exports, "builtInBlocks", { enumerable: true, get: function () { return blocks_1.builtInBlocks; } });
+Object.defineProperty(exports, "blockRegistry", { enumerable: true, get: function () { return blocks_1.blockRegistry; } });
+Object.defineProperty(exports, "registerBlock", { enumerable: true, get: function () { return blocks_1.registerBlock; } });
+Object.defineProperty(exports, "registerBlocks", { enumerable: true, get: function () { return blocks_1.registerBlocks; } });
+Object.defineProperty(exports, "getBlock", { enumerable: true, get: function () { return blocks_1.getBlock; } });
+Object.defineProperty(exports, "getAllBlocks", { enumerable: true, get: function () { return blocks_1.getAllBlocks; } });
+Object.defineProperty(exports, "getBlocksByCategory", { enumerable: true, get: function () { return blocks_1.getBlocksByCategory; } });
+Object.defineProperty(exports, "getCategories", { enumerable: true, get: function () { return blocks_1.getCategories; } });
+var plugins_1 = require("./plugins");
+Object.defineProperty(exports, "registerPlugin", { enumerable: true, get: function () { return plugins_1.registerPlugin; } });
+Object.defineProperty(exports, "getPlugin", { enumerable: true, get: function () { return plugins_1.getPlugin; } });
+Object.defineProperty(exports, "getAllPlugins", { enumerable: true, get: function () { return plugins_1.getAllPlugins; } });
+Object.defineProperty(exports, "getAllPluginBlocks", { enumerable: true, get: function () { return plugins_1.getAllPluginBlocks; } });
+Object.defineProperty(exports, "unregisterPlugin", { enumerable: true, get: function () { return plugins_1.unregisterPlugin; } });
+Object.defineProperty(exports, "createPlugin", { enumerable: true, get: function () { return plugins_1.createPlugin; } });
+Object.defineProperty(exports, "createBlock", { enumerable: true, get: function () { return plugins_1.createBlock; } });
+Object.defineProperty(exports, "createActionBlock", { enumerable: true, get: function () { return plugins_1.createActionBlock; } });
+Object.defineProperty(exports, "createValueBlock", { enumerable: true, get: function () { return plugins_1.createValueBlock; } });
+Object.defineProperty(exports, "createAssertionBlock", { enumerable: true, get: function () { return plugins_1.createAssertionBlock; } });

package/dist/core/plugins.d.ts

@@ -0,0 +1,66 @@
+import { Plugin, BlockDefinition, ExecutionContext } from './types';
+export declare function registerPlugin(plugin: Plugin): void;
+export declare function getPlugin(name: string): Plugin | undefined;
+export declare function getAllPlugins(): Plugin[];
+export declare function getAllPluginBlocks(): BlockDefinition[];
+export declare function unregisterPlugin(name: string): boolean;
+export declare function createPlugin(config: {
+    name: string;
+    version: string;
+    description?: string;
+    blocks?: BlockDefinition[];
+    hooks?: Plugin['hooks'];
+}): Plugin;
+export declare function createBlock(config: {
+    type: string;
+    category: string;
+    color?: string;
+    tooltip?: string;
+    helpUrl?: string;
+    inputs: BlockDefinition['inputs'];
+    output?: BlockDefinition['output'];
+    previousStatement?: boolean;
+    nextStatement?: boolean;
+    execute: BlockDefinition['execute'];
+}): BlockDefinition;
+/**
+ * Create an action block - executes an action, can be chained with other blocks
+ * Has previous/next statements, no output value
+ */
+export declare function createActionBlock(config: {
+    type: string;
+    category: string;
+    color?: string;
+    tooltip?: string;
+    inputs: BlockDefinition['inputs'];
+    execute: (params: Record<string, unknown>, context: ExecutionContext) => Promise<unknown>;
+}): BlockDefinition;
+/**
+ * Create a value block - returns a value that can be used as input to other blocks
+ * Has output, no previous/next statements
+ */
+export declare function createValueBlock(config: {
+    type: string;
+    category: string;
+    color?: string;
+    tooltip?: string;
+    inputs: BlockDefinition['inputs'];
+    outputType: string | string[];
+    execute: (params: Record<string, unknown>, context: ExecutionContext) => Promise<unknown>;
+}): BlockDefinition;
+/**
+ * Create an assertion block - validates a condition
+ * Throws an error if assertion fails
+ */
+export declare function createAssertionBlock(config: {
+    type: string;
+    category?: string;
+    color?: string;
+    tooltip?: string;
+    inputs: BlockDefinition['inputs'];
+    assert: (params: Record<string, unknown>, context: ExecutionContext) => Promise<{
+        pass: boolean;
+        message?: string;
+    }>;
+}): BlockDefinition;
+export type { Plugin, BlockDefinition, ExecutionContext };

package/dist/core/plugins.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPlugin = registerPlugin;
+exports.getPlugin = getPlugin;
+exports.getAllPlugins = getAllPlugins;
+exports.getAllPluginBlocks = getAllPluginBlocks;
+exports.unregisterPlugin = unregisterPlugin;
+exports.createPlugin = createPlugin;
+exports.createBlock = createBlock;
+exports.createActionBlock = createActionBlock;
+exports.createValueBlock = createValueBlock;
+exports.createAssertionBlock = createAssertionBlock;
+const blocks_1 = require("./blocks");
+// Plugin registry
+const pluginRegistry = new Map();
+// Register a plugin
+function registerPlugin(plugin) {
+    if (pluginRegistry.has(plugin.name)) {
+        console.warn(`Plugin "${plugin.name}" is already registered. Overwriting...`);
+    }
+    pluginRegistry.set(plugin.name, plugin);
+    // Register the plugin's blocks
+    if (plugin.blocks && plugin.blocks.length > 0) {
+        (0, blocks_1.registerBlocks)(plugin.blocks);
+    }
+    console.log(`Plugin registered: ${plugin.name} v${plugin.version}`);
+}
+// Get a registered plugin
+function getPlugin(name) {
+    return pluginRegistry.get(name);
+}
+// Get all registered plugins
+function getAllPlugins() {
+    return Array.from(pluginRegistry.values());
+}
+// Get all plugin blocks
+function getAllPluginBlocks() {
+    const blocks = [];
+    for (const plugin of pluginRegistry.values()) {
+        blocks.push(...plugin.blocks);
+    }
+    return blocks;
+}
+// Unregister a plugin
+function unregisterPlugin(name) {
+    return pluginRegistry.delete(name);
+}
+// Create a plugin helper
+function createPlugin(config) {
+    return {
+        name: config.name,
+        version: config.version,
+        description: config.description,
+        blocks: config.blocks || [],
+        hooks: config.hooks,
+    };
+}
+// Helper to create a custom block easily
+function createBlock(config) {
+    return {
+        type: config.type,
+        category: config.category,
+        color: config.color || '#607D8B',
+        tooltip: config.tooltip,
+        helpUrl: config.helpUrl,
+        inputs: config.inputs,
+        output: config.output,
+        previousStatement: config.previousStatement,
+        nextStatement: config.nextStatement,
+        execute: config.execute,
+    };
+}
+/**
+ * Create an action block - executes an action, can be chained with other blocks
+ * Has previous/next statements, no output value
+ */
+function createActionBlock(config) {
+    return createBlock({
+        ...config,
+        previousStatement: true,
+        nextStatement: true,
+    });
+}
+/**
+ * Create a value block - returns a value that can be used as input to other blocks
+ * Has output, no previous/next statements
+ */
+function createValueBlock(config) {
+    return createBlock({
+        ...config,
+        output: { type: config.outputType },
+        previousStatement: false,
+        nextStatement: false,
+    });
+}
+/**
+ * Create an assertion block - validates a condition
+ * Throws an error if assertion fails
+ */
+function createAssertionBlock(config) {
+    return createBlock({
+        type: config.type,
+        category: config.category || 'Assertions',
+        color: config.color || '#E91E63',
+        tooltip: config.tooltip,
+        inputs: config.inputs,
+        previousStatement: true,
+        nextStatement: true,
+        execute: async (params, context) => {
+            const result = await config.assert(params, context);
+            if (!result.pass) {
+                throw new Error(result.message || `Assertion failed: ${config.type}`);
+            }
+            context.logger.info(`✓ ${config.tooltip || config.type}`);
+            return result;
+        },
+    });
+}