testchimp-runner-core 0.1.21 → 0.1.22

package/dist/utils/pom-denormalizer.js

@@ -0,0 +1,754 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PomDenormalizer = void 0;
+exports.denormalizePomSteps = denormalizePomSteps;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const parser_1 = require("@babel/parser");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const t = __importStar(require("@babel/types"));
+const generator_1 = __importDefault(require("@babel/generator"));
+const SUPPORTED_STATEMENT_TYPES = new Set([
+    'ExpressionStatement',
+    'VariableDeclaration',
+    'EmptyStatement'
+]);
+const UNSUPPORTED_STATEMENT_TYPES = new Set([
+    'IfStatement',
+    'ForStatement',
+    'ForInStatement',
+    'ForOfStatement',
+    'WhileStatement',
+    'DoWhileStatement',
+    'SwitchStatement',
+    'TryStatement',
+    'ReturnStatement',
+    'ThrowStatement',
+    'BreakStatement',
+    'ContinueStatement',
+    'LabeledStatement',
+    'WithStatement',
+    'FunctionDeclaration',
+    'ClassDeclaration'
+]);
+class PomDenormalizer {
+    static denormalizeStatements(statements, options) {
+        if (!options.enabled) {
+            return statements;
+        }
+        if (!options.originalScript || !options.tempDir) {
+            if (options.logger) {
+                options.logger('[PomDenormalizer] Skipping - missing originalScript or tempDir', 'warn');
+            }
+            return statements;
+        }
+        const testFileDir = options.testFileDir || path.join(options.tempDir, 'tests');
+        const importBindings = this.collectImportBindings(options.originalScript, options.logger);
+        const moduleCache = new Map();
+        const varToClassName = this.collectVariableToClassMap(statements, options.logger);
+        if (options.logger) {
+            options.logger(`[PomDenormalizer] Starting denormalization: ${statements.length} statements, ` +
+                `${importBindings.size} imports, ${varToClassName.size} variable-to-class mappings`, 'log');
+        }
+        const result = [];
+        let nonVariableCount = 0;
+        let pomTargetsFound = 0;
+        let pomTargetsExpanded = 0;
+        for (const stmt of statements) {
+            const isVariable = stmt.isVariableDeclaration || false;
+            const fallbackStepId = !isVariable ? `step-${nonVariableCount + 1}` : undefined;
+            const baseStepId = stmt.id || fallbackStepId || '';
+            if (!isVariable) {
+                nonVariableCount += 1;
+            }
+            const resolvedTarget = this.resolvePomTarget(stmt, importBindings, varToClassName, moduleCache, testFileDir, options.logger);
+            if (!resolvedTarget) {
+                result.push(stmt);
+                continue;
+            }
+            pomTargetsFound++;
+            if (options.logger) {
+                options.logger(`[PomDenormalizer] Found POM target: ${resolvedTarget.callLabel}`, 'log');
+            }
+            const expandedStatements = this.expandPomTarget(resolvedTarget, stmt, baseStepId, options.logger);
+            if (!expandedStatements) {
+                if (options.logger) {
+                    options.logger(`[PomDenormalizer] Failed to expand POM target: ${resolvedTarget.callLabel}`, 'warn');
+                }
+                result.push(stmt);
+                continue;
+            }
+            pomTargetsExpanded++;
+            result.push(...expandedStatements);
+        }
+        if (options.logger) {
+            const expansionCount = result.length - statements.length;
+            if (pomTargetsFound > 0) {
+                options.logger(`[PomDenormalizer] Found ${pomTargetsFound} POM target(s), expanded ${pomTargetsExpanded}, ` +
+                    `total statements: ${statements.length} -> ${result.length} (${expansionCount > 0 ? '+' : ''}${expansionCount})`, 'log');
+            }
+            else {
+                options.logger(`[PomDenormalizer] No POM targets found in ${statements.length} statements`, 'log');
+            }
+        }
+        return result;
+    }
+    static resolvePomTarget(stmt, importBindings, varToClassName, moduleCache, testFileDir, logger) {
+        if (!stmt.code || stmt.isVariableDeclaration) {
+            return null;
+        }
+        const parsed = this.parseSingleStatement(stmt.code, logger);
+        if (!parsed || !t.isExpressionStatement(parsed)) {
+            return null;
+        }
+        const awaitExpr = parsed.expression;
+        if (!t.isAwaitExpression(awaitExpr)) {
+            return null;
+        }
+        const callExpr = awaitExpr.argument;
+        if (!t.isCallExpression(callExpr)) {
+            return null;
+        }
+        // Debug logging for POM call detection
+        const isPomCall = (t.isIdentifier(callExpr.callee) && importBindings.has(callExpr.callee.name)) ||
+            (t.isMemberExpression(callExpr.callee) &&
+                t.isIdentifier(callExpr.callee.object) &&
+                varToClassName.has(callExpr.callee.object.name));
+        if (isPomCall && logger) {
+            const callLabel = t.isIdentifier(callExpr.callee)
+                ? callExpr.callee.name
+                : t.isMemberExpression(callExpr.callee) && t.isIdentifier(callExpr.callee.object) && t.isIdentifier(callExpr.callee.property)
+                    ? `${callExpr.callee.object.name}.${callExpr.callee.property.name}`
+                    : 'unknown';
+            logger(`[PomDenormalizer] Checking POM call: ${callLabel}`, 'log');
+        }
+        if (t.isIdentifier(callExpr.callee)) {
+            const binding = importBindings.get(callExpr.callee.name);
+            if (!binding) {
+                return null;
+            }
+            const modulePath = this.resolvePomModulePath(binding.source, testFileDir, logger);
+            if (!modulePath) {
+                return null;
+            }
+            const moduleExports = this.getPomModuleExports(modulePath, moduleCache, logger);
+            if (!moduleExports) {
+                return null;
+            }
+            const fnNode = binding.kind === 'default'
+                ? moduleExports.defaultFunction
+                : moduleExports.functionsByExportName.get(binding.importedName);
+            const fnDetails = this.extractFunctionDetails(fnNode, logger);
+            if (!fnDetails) {
+                return null;
+            }
+            if (!this.isSimpleBody(fnDetails.body)) {
+                return null;
+            }
+            if (!this.areParamsSupported(fnDetails.params, callExpr.arguments, logger)) {
+                return null;
+            }
+            return {
+                type: 'function',
+                callLabel: callExpr.callee.name,
+                params: fnDetails.params,
+                body: fnDetails.body
+            };
+        }
+        if (t.isMemberExpression(callExpr.callee) && t.isIdentifier(callExpr.callee.object) && t.isIdentifier(callExpr.callee.property) && !callExpr.callee.computed) {
+            const receiverName = callExpr.callee.object.name;
+            const methodName = callExpr.callee.property.name;
+            const className = varToClassName.get(receiverName);
+            if (!className) {
+                if (logger) {
+                    logger(`[PomDenormalizer] No class mapping found for receiver "${receiverName}" (available mappings: ${Array.from(varToClassName.keys()).join(', ') || 'none'})`, 'log');
+                }
+                return null;
+            }
+            const binding = importBindings.get(className);
+            if (!binding) {
+                return null;
+            }
+            const modulePath = this.resolvePomModulePath(binding.source, testFileDir, logger);
+            if (!modulePath) {
+                return null;
+            }
+            const moduleExports = this.getPomModuleExports(modulePath, moduleCache, logger);
+            if (!moduleExports) {
+                return null;
+            }
+            const classNode = binding.kind === 'default'
+                ? moduleExports.defaultClass
+                : moduleExports.classesByExportName.get(binding.importedName);
+            if (!classNode) {
+                return null;
+            }
+            const methodNode = this.getClassMethod(classNode, methodName);
+            if (!methodNode || !methodNode.body) {
+                return null;
+            }
+            if (!this.isSimpleBody(methodNode.body)) {
+                return null;
+            }
+            if (!this.areParamsSupported(methodNode.params, callExpr.arguments, logger)) {
+                return null;
+            }
+            return {
+                type: 'method',
+                receiverName,
+                callLabel: `${receiverName}.${methodName}`,
+                params: methodNode.params.filter(t.isIdentifier),
+                body: methodNode.body
+            };
+        }
+        return null;
+    }
+    static expandPomTarget(target, originalStatement, baseStepId, logger) {
+        const bodyStatements = target.body.body;
+        if (!bodyStatements || bodyStatements.length === 0) {
+            return null;
+        }
+        const clonedStatements = bodyStatements.map(stmt => t.cloneNode(stmt, true));
+        const substitutedStatements = this.applySubstitutions(clonedStatements, target.params, originalStatement.code, target.type === 'method' ? target.receiverName : undefined, logger);
+        if (!substitutedStatements) {
+            return null;
+        }
+        const generatedStatements = substitutedStatements.map(stmt => ({
+            code: (0, generator_1.default)(stmt, { comments: false }).code,
+            isVariableDeclaration: t.isVariableDeclaration(stmt)
+        }));
+        if (generatedStatements.length === 0) {
+            return null;
+        }
+        const baseDescription = originalStatement.description || `${target.callLabel}`;
+        const expanded = [];
+        let cumulativeCode = '';
+        for (let i = 0; i < generatedStatements.length; i++) {
+            const sub = generatedStatements[i];
+            if (!sub.code) {
+                continue;
+            }
+            cumulativeCode = cumulativeCode.length > 0 ? `${cumulativeCode}\n${sub.code}` : sub.code;
+            const subStepId = sub.isVariableDeclaration
+                ? undefined
+                : crypto.createHash('sha256').update(`${baseStepId}\n${cumulativeCode}`).digest('hex');
+            const description = sub.isVariableDeclaration
+                ? ''
+                : `${baseDescription} [${i + 1}/${generatedStatements.length}]`;
+            expanded.push({
+                code: sub.code,
+                description,
+                isVariableDeclaration: sub.isVariableDeclaration,
+                id: subStepId
+            });
+            // Log stepId generation for non-variable steps
+            if (logger && !sub.isVariableDeclaration && subStepId) {
+                const stepIdPreview = subStepId.substring(0, 16);
+                const codePreview = sub.code.length > 60 ? `${sub.code.substring(0, 60)}...` : sub.code;
+                logger(`[PomDenormalizer] Generated stepId for sub-step ${i + 1}/${generatedStatements.length}: ` +
+                    `${stepIdPreview}... (code: ${codePreview})`, 'log');
+            }
+        }
+        if (expanded.length === 0) {
+            return null;
+        }
+        const nonVariableCount = expanded.filter(s => !s.isVariableDeclaration).length;
+        const stepIdCount = expanded.filter(s => s.id).length;
+        if (logger) {
+            logger(`[PomDenormalizer] Expanded ${target.callLabel} into ${expanded.length} sub-step(s) ` +
+                `(${nonVariableCount} non-variable, ${stepIdCount} with stepIds)`, 'log');
+        }
+        return expanded;
+    }
+    static applySubstitutions(statements, params, originalCallCode, receiverName, logger) {
+        const callParsed = this.parseSingleStatement(originalCallCode, logger);
+        if (!callParsed || !t.isExpressionStatement(callParsed)) {
+            return null;
+        }
+        const awaitExpr = callParsed.expression;
+        if (!t.isAwaitExpression(awaitExpr) || !t.isCallExpression(awaitExpr.argument)) {
+            return null;
+        }
+        const args = awaitExpr.argument.arguments;
+        if (args.length < params.length) {
+            return null;
+        }
+        const paramMap = new Map();
+        params.forEach((param, index) => {
+            const arg = args[index];
+            if (t.isExpression(arg)) {
+                paramMap.set(param.name, arg);
+            }
+        });
+        const wrapper = t.functionExpression(null, params.map(param => t.cloneNode(param, true)), t.blockStatement(statements));
+        // Wrap in File (which contains Program) for proper scope handling (Babel requires File for traversal)
+        const program = t.program([t.variableDeclaration('const', [
+                t.variableDeclarator(t.identifier('_wrapper'), wrapper)
+            ])], [], 'module');
+        const file = t.file(program, [], null);
+        const paramBindings = new Map();
+        // First traversal: collect parameter bindings
+        (0, traverse_1.default)(file, {
+            Function(path) {
+                // Find our wrapper function within the Program
+                if (path.node === wrapper) {
+                    for (const param of params) {
+                        const binding = path.scope.getBinding(param.name);
+                        if (binding && binding.kind === 'param') {
+                            paramBindings.set(param.name, binding.identifier);
+                        }
+                    }
+                }
+            }
+        });
+        // Second traversal: perform substitutions
+        (0, traverse_1.default)(file, {
+            ThisExpression(path) {
+                if (receiverName) {
+                    path.replaceWith(t.identifier(receiverName));
+                    path.skip(); // Skip traversing into the replacement to avoid infinite recursion
+                }
+            },
+            Identifier(path) {
+                if (!path.isReferencedIdentifier()) {
+                    return;
+                }
+                const binding = path.scope.getBinding(path.node.name);
+                if (binding && binding.kind === 'param' && paramBindings.get(path.node.name) === binding.identifier) {
+                    const replacement = paramMap.get(path.node.name);
+                    if (replacement) {
+                        path.replaceWith(t.cloneNode(replacement, true));
+                        path.skip(); // Skip traversing into the replacement to avoid infinite recursion
+                    }
+                }
+            }
+        });
+        // Extract modified statements (wrapper.body is mutated in place during traversal)
+        return wrapper.body.body;
+    }
+    static collectVariableToClassMap(statements, logger) {
+        const map = new Map();
+        let parsedCount = 0;
+        let variableDeclarationCount = 0;
+        let assignmentCount = 0;
+        for (const stmt of statements) {
+            if (!stmt.code) {
+                continue;
+            }
+            // Debug: Log statements that might contain variable assignments/declarations
+            if (logger && (stmt.code.includes('=') || stmt.code.includes('const ') || stmt.code.includes('let ') || stmt.code.includes('var '))) {
+                const codePreview = stmt.code.length > 100 ? `${stmt.code.substring(0, 100)}...` : stmt.code;
+                logger(`[PomDenormalizer] Processing variable-related statement: ${codePreview}`, 'log');
+            }
+            const parsed = this.parseSingleStatement(stmt.code, logger);
+            if (!parsed) {
+                if (logger) {
+                    logger(`[PomDenormalizer] Failed to parse statement: ${stmt.code.substring(0, 50)}...`, 'log');
+                }
+                continue;
+            }
+            parsedCount++;
+            if (t.isVariableDeclaration(parsed)) {
+                variableDeclarationCount++;
+                for (const declarator of parsed.declarations) {
+                    if (t.isIdentifier(declarator.id)) {
+                        if (declarator.init && t.isNewExpression(declarator.init) && t.isIdentifier(declarator.init.callee)) {
+                            map.set(declarator.id.name, declarator.init.callee.name);
+                            if (logger) {
+                                logger(`[PomDenormalizer] Found variable-to-class mapping: ${declarator.id.name} -> ${declarator.init.callee.name}`, 'log');
+                            }
+                        }
+                        else if (declarator.init && logger) {
+                            // Log why this variable declaration didn't match
+                            const initType = declarator.init.type;
+                            if (!t.isNewExpression(declarator.init)) {
+                                logger(`[PomDenormalizer] Variable ${declarator.id.name} init is not NewExpression (type: ${initType})`, 'log');
+                            }
+                            else if (!t.isIdentifier(declarator.init.callee)) {
+                                logger(`[PomDenormalizer] Variable ${declarator.id.name} NewExpression callee is not Identifier`, 'log');
+                            }
+                        }
+                    }
+                }
+            }
+            else if (t.isExpressionStatement(parsed) && t.isAssignmentExpression(parsed.expression)) {
+                assignmentCount++;
+                const assignment = parsed.expression;
+                if (t.isIdentifier(assignment.left)) {
+                    if (t.isNewExpression(assignment.right) && t.isIdentifier(assignment.right.callee)) {
+                        map.set(assignment.left.name, assignment.right.callee.name);
+                        if (logger) {
+                            logger(`[PomDenormalizer] Found variable-to-class mapping: ${assignment.left.name} -> ${assignment.right.callee.name}`, 'log');
+                        }
+                    }
+                    else if (logger) {
+                        const rightType = assignment.right.type;
+                        if (!t.isNewExpression(assignment.right)) {
+                            logger(`[PomDenormalizer] Assignment ${assignment.left.name} right is not NewExpression (type: ${rightType})`, 'log');
+                        }
+                    }
+                }
+            }
+        }
+        // Add common POM object mappings based on naming conventions
+        // This handles cases where POM objects are passed as test parameters or fixtures
+        const commonPomMappings = [
+            ['signInPage', 'SignInPage'],
+            ['signinpage', 'SignInPage'],
+            ['SignInPage', 'SignInPage'],
+            ['smartTestsPage', 'SmartTestsPage'],
+            ['smarttestspage', 'SmartTestsPage'],
+            ['SmartTestsPage', 'SmartTestsPage'],
+            ['loginPage', 'LoginPage'],
+            ['loginpage', 'LoginPage'],
+            ['LoginPage', 'LoginPage']
+        ];
+        for (const [varName, className] of commonPomMappings) {
+            if (!map.has(varName)) {
+                map.set(varName, className);
+                if (logger) {
+                    logger(`[PomDenormalizer] Added common POM mapping: ${varName} -> ${className}`, 'log');
+                }
+            }
+        }
+        if (logger) {
+            logger(`[PomDenormalizer] Variable-to-class mapping: parsed ${parsedCount} statements ` +
+                `(${variableDeclarationCount} variable declarations, ${assignmentCount} assignments), ` +
+                `found ${map.size} mappings (including ${commonPomMappings.length} common POM mappings)`, 'log');
+        }
+        return map;
+    }
+    static collectImportBindings(script, logger) {
+        const bindings = new Map();
+        try {
+            const ast = (0, parser_1.parse)(script, {
+                sourceType: 'module',
+                plugins: ['typescript', 'classProperties', 'decorators-legacy'],
+                allowImportExportEverywhere: true
+            });
+            (0, traverse_1.default)(ast, {
+                ImportDeclaration(path) {
+                    const source = path.node.source.value;
+                    if (typeof source !== 'string' || !source.startsWith('.')) {
+                        return;
+                    }
+                    for (const specifier of path.node.specifiers) {
+                        if (t.isImportDefaultSpecifier(specifier)) {
+                            bindings.set(specifier.local.name, {
+                                source,
+                                importedName: 'default',
+                                kind: 'default'
+                            });
+                        }
+                        else if (t.isImportSpecifier(specifier)) {
+                            const importedName = t.isIdentifier(specifier.imported)
+                                ? specifier.imported.name
+                                : specifier.imported.value;
+                            bindings.set(specifier.local.name, {
+                                source,
+                                importedName,
+                                kind: 'named'
+                            });
+                        }
+                    }
+                }
+            });
+        }
+        catch (error) {
+            if (logger) {
+                logger(`[PomDenormalizer] Failed to parse imports: ${error.message}`, 'warn');
+            }
+        }
+        return bindings;
+    }
+    static resolvePomModulePath(source, testFileDir, logger) {
+        const resolvedPath = path.resolve(testFileDir, source);
+        const candidates = [
+            `${resolvedPath}.page.ts`,
+            `${resolvedPath}.page.js`,
+            path.join(resolvedPath, 'index.page.ts'),
+            path.join(resolvedPath, 'index.page.js')
+        ];
+        for (const candidate of candidates) {
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        if (logger) {
+            logger(`[PomDenormalizer] No POM module found for ${source} (resolved base: ${resolvedPath})`, 'warn');
+        }
+        return null;
+    }
+    static getPomModuleExports(modulePath, cache, logger) {
+        if (cache.has(modulePath)) {
+            return cache.get(modulePath);
+        }
+        try {
+            const source = fs.readFileSync(modulePath, 'utf8');
+            const ast = (0, parser_1.parse)(source, {
+                sourceType: 'module',
+                plugins: ['typescript', 'classProperties', 'decorators-legacy'],
+                allowImportExportEverywhere: true
+            });
+            const declaredClasses = new Map();
+            const declaredFunctions = new Map();
+            const exports = {
+                classesByExportName: new Map(),
+                functionsByExportName: new Map()
+            };
+            (0, traverse_1.default)(ast, {
+                ClassDeclaration(path) {
+                    if (path.node.id) {
+                        declaredClasses.set(path.node.id.name, path.node);
+                    }
+                },
+                FunctionDeclaration(path) {
+                    if (path.node.id) {
+                        declaredFunctions.set(path.node.id.name, path.node);
+                    }
+                },
+                VariableDeclarator(path) {
+                    if (!t.isIdentifier(path.node.id)) {
+                        return;
+                    }
+                    const init = path.node.init;
+                    if (t.isFunctionExpression(init) || (t.isArrowFunctionExpression(init) && t.isBlockStatement(init.body))) {
+                        declaredFunctions.set(path.node.id.name, init);
+                    }
+                },
+                ExportNamedDeclaration(path) {
+                    if (path.node.declaration) {
+                        const decl = path.node.declaration;
+                        if (t.isClassDeclaration(decl) && decl.id) {
+                            exports.classesByExportName.set(decl.id.name, decl);
+                        }
+                        else if (t.isFunctionDeclaration(decl) && decl.id) {
+                            exports.functionsByExportName.set(decl.id.name, decl);
+                        }
+                        else if (t.isVariableDeclaration(decl)) {
+                            for (const declarator of decl.declarations) {
+                                if (!t.isIdentifier(declarator.id)) {
+                                    continue;
+                                }
+                                const init = declarator.init;
+                                if (t.isFunctionExpression(init) || (t.isArrowFunctionExpression(init) && t.isBlockStatement(init.body))) {
+                                    exports.functionsByExportName.set(declarator.id.name, init);
+                                }
+                            }
+                        }
+                    }
+                    if (path.node.specifiers && path.node.specifiers.length > 0) {
+                        for (const specifier of path.node.specifiers) {
+                            if (!t.isExportSpecifier(specifier)) {
+                                continue;
+                            }
+                            if (!t.isIdentifier(specifier.local) || !t.isIdentifier(specifier.exported)) {
+                                continue;
+                            }
+                            const localName = specifier.local.name;
+                            const exportedName = specifier.exported.name;
+                            if (!localName || !exportedName) {
+                                continue;
+                            }
+                            const classNode = declaredClasses.get(localName);
+                            const fnNode = declaredFunctions.get(localName);
+                            if (classNode) {
+                                exports.classesByExportName.set(exportedName, classNode);
+                            }
+                            if (fnNode) {
+                                exports.functionsByExportName.set(exportedName, fnNode);
+                            }
+                        }
+                    }
+                },
+                ExportDefaultDeclaration(path) {
+                    const decl = path.node.declaration;
+                    if (t.isClassDeclaration(decl)) {
+                        exports.defaultClass = decl;
+                    }
+                    else if (t.isFunctionDeclaration(decl)) {
+                        exports.defaultFunction = decl;
+                    }
+                    else if (t.isFunctionExpression(decl) || (t.isArrowFunctionExpression(decl) && t.isBlockStatement(decl.body))) {
+                        exports.defaultFunction = decl;
+                    }
+                }
+            });
+            cache.set(modulePath, exports);
+            return exports;
+        }
+        catch (error) {
+            if (logger) {
+                logger(`[PomDenormalizer] Failed to parse module ${modulePath}: ${error.message}`, 'warn');
+            }
+            return null;
+        }
+    }
+    static extractFunctionDetails(node, logger) {
+        if (!node) {
+            return null;
+        }
+        if (t.isArrowFunctionExpression(node)) {
+            if (!t.isBlockStatement(node.body)) {
+                if (logger) {
+                    logger('[PomDenormalizer] Skipping arrow function with expression body', 'warn');
+                }
+                return null;
+            }
+            if (!node.params.every(t.isIdentifier)) {
+                if (logger) {
+                    logger('[PomDenormalizer] Skipping arrow function with non-identifier params', 'warn');
+                }
+                return null;
+            }
+            const params = node.params;
+            return { params, body: node.body };
+        }
+        if (t.isFunctionDeclaration(node) || t.isFunctionExpression(node)) {
+            if (!node.params.every(t.isIdentifier)) {
+                if (logger) {
+                    logger('[PomDenormalizer] Skipping function with non-identifier params', 'warn');
+                }
+                return null;
+            }
+            const params = node.params;
+            return { params, body: node.body };
+        }
+        return null;
+    }
+    static areParamsSupported(params, args, logger) {
+        if (params.length === 0) {
+            return true;
+        }
+        for (const param of params) {
+            if (!t.isIdentifier(param)) {
+                if (logger) {
+                    logger('[PomDenormalizer] Skipping - unsupported parameter pattern', 'warn');
+                }
+                return false;
+            }
+        }
+        if (args.length < params.length) {
+            if (logger) {
+                logger('[PomDenormalizer] Skipping - missing call arguments', 'warn');
+            }
+            return false;
+        }
+        for (let i = 0; i < params.length; i++) {
+            const arg = args[i];
+            if (!t.isExpression(arg)) {
+                if (logger) {
+                    logger('[PomDenormalizer] Skipping - unsupported call argument type', 'warn');
+                }
+                return false;
+            }
+        }
+        return true;
+    }
+    static getClassMethod(classNode, methodName) {
+        for (const member of classNode.body.body) {
+            if (t.isClassMethod(member) && t.isIdentifier(member.key) && member.key.name === methodName) {
+                return member;
+            }
+        }
+        return null;
+    }
+    static isSimpleBody(body) {
+        for (const stmt of body.body) {
+            if (UNSUPPORTED_STATEMENT_TYPES.has(stmt.type)) {
+                return false;
+            }
+            if (!SUPPORTED_STATEMENT_TYPES.has(stmt.type)) {
+                return false;
+            }
+            if (t.isVariableDeclaration(stmt)) {
+                for (const decl of stmt.declarations) {
+                    if (!t.isIdentifier(decl.id)) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    static parseSingleStatement(code, logger) {
+        try {
+            const ast = (0, parser_1.parse)(code, {
+                sourceType: 'module',
+                plugins: ['typescript', 'classProperties', 'decorators-legacy'],
+                allowAwaitOutsideFunction: true,
+                allowReturnOutsideFunction: true,
+                allowImportExportEverywhere: true
+            });
+            if (ast.program.body.length === 0) {
+                return null;
+            }
+            const first = ast.program.body[0];
+            return t.isStatement(first) ? first : null;
+        }
+        catch (error) {
+            if (logger) {
+                logger(`[PomDenormalizer] Failed to parse statement: ${error.message}`, 'warn');
+            }
+            return null;
+        }
+    }
+    /**
+     * Public function to denormalize POM steps.
+     * Exported for use by external consumers (e.g., scriptservice).
+     */
+    static denormalizePomSteps(steps, options) {
+        return this.denormalizeStatements(steps, {
+            enabled: true,
+            originalScript: options.originalScript,
+            tempDir: options.tempDir,
+            testFileDir: options.testFileDir,
+            logger: options.logger
+        });
+    }
+}
+exports.PomDenormalizer = PomDenormalizer;
+/**
+ * Export the public function for external use.
+ */
+function denormalizePomSteps(steps, options) {
+    return PomDenormalizer.denormalizePomSteps(steps, options);
+}
+//# sourceMappingURL=pom-denormalizer.js.map