@sun-asterisk/sungen 1.0.0

package/dist/generators/test-generator/step-mapper-old.js

@@ -0,0 +1,752 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepMapper = void 0;
+const ai_step_mapper_1 = require("./ai-step-mapper");
+const template_engine_1 = require("./template-engine");
+class StepMapper {
+    constructor(options = {}) {
+        this.stepCounter = 0;
+        this.aiMapper = null;
+        this.useAI = false;
+        this.verbose = false;
+        this.useAI = options.useAI ?? false;
+        this.verbose = options.verbose ?? false;
+        this.templateEngine = new template_engine_1.TemplateEngine();
+        // Initialize AI mapper if enabled
+        if (this.useAI) {
+            try {
+                this.aiMapper = new ai_step_mapper_1.AIStepMapper(this.verbose);
+                if (this.verbose) {
+                    console.log('  [StepMapper] AI fallback enabled');
+                }
+            }
+            catch (error) {
+                console.warn('[StepMapper] AI mapper initialization failed:', error);
+                this.useAI = false;
+            }
+        }
+    }
+    /**
+     * Map a Gherkin step to Playwright code
+     * Uses dictionary patterns first, falls back to AI if enabled
+     */
+    mapStep(step) {
+        this.stepCounter++;
+        const { keyword, text, selectorRef, dataRef, value } = step;
+        // Normalize keyword (And, But → use previous context, default to When)
+        const normalizedKeyword = ['Given', 'When', 'Then'].includes(keyword)
+            ? keyword
+            : 'When';
+        // Match step patterns
+        // Pattern: user navigates to [screen] or user navigates to route <route>
+        if ((text.includes('navigates to') || text.includes('is on')) && (selectorRef || dataRef)) {
+            const route = selectorRef || dataRef;
+            return this.mapNavigationStep(route);
+        }
+        if (text.includes('user is logged in as')) {
+            return this.mapLoginStep(dataRef);
+        }
+        // Pattern: [element] should be visible/displayed
+        if ((text.includes('should be visible') || text.includes('should be displayed')) && selectorRef) {
+            return this.mapVisibilityAssertionStep(selectorRef);
+        }
+        // Pattern: [element] should be enabled
+        if (text.includes('should be enabled') && selectorRef) {
+            return this.mapEnabledAssertion(selectorRef);
+        }
+        // Pattern: user fills [element] with value (with or without "the")
+        if (text.includes('fills') && selectorRef && (dataRef || value)) {
+            return this.mapFillStep(selectorRef, dataRef, value);
+        }
+        // Pattern: user clicks [element] (with or without "the")
+        if (text.includes('clicks') && selectorRef) {
+            return this.mapClickStep(selectorRef);
+        }
+        if (text.includes('user waits for')) {
+            return this.mapWaitStep(text);
+        }
+        // Pattern: user should see route OR user should remain on [screen]
+        if ((text.includes('should see route') || text.includes('should remain on')) && (selectorRef || dataRef)) {
+            const route = selectorRef || dataRef;
+            return this.mapRouteAssertionStep(route);
+        }
+        if (text.includes('user should see') && selectorRef) {
+            return this.mapVisibilityAssertionStep(selectorRef);
+        }
+        if (text.includes('error message') && text.includes('should')) {
+            return this.mapErrorMessageAssertion();
+        }
+        // Pattern: welcome/success/any message should be displayed
+        if (text.includes('message') && text.includes('should be displayed')) {
+            return this.mapGenericMessageAssertion(text);
+        }
+        if (text.includes('should see message') && value) {
+            return this.mapMessageAssertion(value, selectorRef);
+        }
+        if (text.includes('user should see') && text.includes('AI response')) {
+            return this.mapAIResponseAssertion(selectorRef);
+        }
+        if (text.includes('messages in') && selectorRef) {
+            return this.mapMessageCountAssertion(text, selectorRef);
+        }
+        // Pattern: user presses Enter in [element]
+        if (text.includes('user presses') && text.includes('Enter') && selectorRef) {
+            return this.mapPressEnterStep(selectorRef);
+        }
+        // Pattern: [element] should be empty
+        if (text.includes('should be empty') && selectorRef) {
+            return this.mapEmptyAssertion(selectorRef);
+        }
+        // Pattern: [element] should contain N messages
+        if (text.includes('should contain') && text.includes('messages') && selectorRef) {
+            return this.mapMessageCountAssertion(text, selectorRef);
+        }
+        // Pattern: [element] should be scrolled to bottom
+        if (text.includes('should be scrolled to bottom') && selectorRef) {
+            return this.mapScrollBottomAssertion(selectorRef);
+        }
+        // Pattern: [element] should be displayed with "text"
+        if (text.includes('should be displayed with') && selectorRef && value) {
+            return this.mapDisplayedWithTextAssertion(selectorRef, value);
+        }
+        // Pattern: [element] should contain "text" (alternative to above)
+        if (text.includes('should contain') && selectorRef && value && !text.includes('messages')) {
+            return this.mapDisplayedContainingTextAssertion(selectorRef, value);
+        }
+        // Pattern: [element] should have attribute "attr" with value "val"
+        if (text.includes('should have attribute') && selectorRef) {
+            const attrMatch = text.match(/attribute\s+['"]([\w-]+)['"]\s+with\s+(?:value\s+)?['"](.*?)['"]/);
+            if (attrMatch) {
+                return this.mapHasAttributeAssertion(selectorRef, attrMatch[1], attrMatch[2]);
+            }
+        }
+        // Pattern: [element] should have class "className"
+        if (text.includes('should have class') && selectorRef && value) {
+            return this.mapHasClassAssertion(selectorRef, value);
+        }
+        // Pattern: [element] should have value "value"
+        if (text.includes('should have value') && selectorRef && value) {
+            return this.mapHasValueAssertion(selectorRef, value);
+        }
+        // Pattern: [element] should be checked
+        if (text.includes('should be checked') && selectorRef) {
+            return this.mapIsCheckedAssertion(selectorRef);
+        }
+        // Pattern: [element] should not be checked / should be unchecked
+        if ((text.includes('should not be checked') || text.includes('should be unchecked')) && selectorRef) {
+            return this.mapIsUncheckedAssertion(selectorRef);
+        }
+        // Pattern: [element] should not be visible / should be hidden
+        if ((text.includes('should not be visible') || text.includes('should be hidden')) && selectorRef) {
+            return this.mapNotVisibleAssertion(selectorRef);
+        }
+        // Pattern: [element] should be focused
+        if (text.includes('should be focused') && selectorRef) {
+            return this.mapIsFocusedAssertion(selectorRef);
+        }
+        // Pattern: [element] should be editable
+        if (text.includes('should be editable') && selectorRef) {
+            return this.mapIsEditableAssertion(selectorRef);
+        }
+        // Pattern: [element] should have count N
+        if (text.includes('should have count') && selectorRef) {
+            const countMatch = text.match(/(\d+)/);
+            if (countMatch) {
+                return this.mapHasCountAssertion(selectorRef, parseInt(countMatch[1]));
+            }
+        }
+        // Pattern: user should see notification "text"
+        if (text.includes('user should see notification') && value) {
+            return this.mapNotificationAssertion(value);
+        }
+        // Pattern: [element] should be disabled
+        if (text.includes('should be disabled') && selectorRef) {
+            return this.mapDisabledAssertion(selectorRef);
+        }
+        // Pattern: user is not logged in
+        if (text.includes('user is not logged in')) {
+            return this.mapNotLoggedInStep();
+        }
+        // Pattern: user navigates to route <route>
+        if (text.includes('user navigates to route')) {
+            const route = selectorRef || dataRef;
+            return this.mapNavigationStep(route);
+        }
+        // Pattern: user should be redirected to [screen] or screen name
+        if (text.includes('should be redirected to')) {
+            // Can use selectorRef [screen] or extract from text
+            if (selectorRef) {
+                return this.mapRedirectAssertion(selectorRef);
+            }
+            else {
+                // Extract screen name from text like "redirected to the dashboard"
+                const screenMatch = text.match(/redirected to (?:the )?(\w+)/);
+                if (screenMatch) {
+                    return this.mapRedirectAssertion(screenMatch[1]);
+                }
+            }
+        }
+        // Pattern: [element] should contain text "..."
+        if (text.includes('should contain text') && selectorRef && value) {
+            return this.mapContainsTextAssertion(selectorRef, value);
+        }
+        // Pattern: HTML5 validation is disabled
+        if (text.includes('HTML5 validation is disabled')) {
+            return this.mapHTML5ValidationCheck();
+        }
+        // ========================================
+        // NEW PATTERNS - Admin Dashboard Support
+        // ========================================
+        // Pattern: user selects [element] with "value"
+        if (text.includes('user selects') && selectorRef && (dataRef || value)) {
+            return this.mapSelectStep(selectorRef, dataRef, value);
+        }
+        // Pattern: user checks [element] checkbox
+        if (text.includes('user checks') && text.includes('checkbox') && selectorRef) {
+            return this.mapCheckboxStep(selectorRef, true);
+        }
+        // Pattern: user unchecks [element] checkbox
+        if (text.includes('user unchecks') && text.includes('checkbox') && selectorRef) {
+            return this.mapCheckboxStep(selectorRef, false);
+        }
+        // Pattern: user clears [element]
+        if (text.includes('user clears') && selectorRef) {
+            return this.mapClearStep(selectorRef);
+        }
+        // Pattern: [element] should be active
+        if (text.includes('should be active') && selectorRef) {
+            return this.mapActiveStateAssertion(selectorRef);
+        }
+        // Pattern: I am on the "screen-name" screen
+        if (text.includes('I am on the') && text.includes('screen')) {
+            // Extract screen name from quotes
+            const screenMatch = text.match(/"([^"]+)"/);
+            if (screenMatch) {
+                return this.mapScreenNavigationStep(screenMatch[1]);
+            }
+        }
+        // Fallback: Use AI if enabled, otherwise TODO
+        if (this.useAI && this.aiMapper) {
+            if (this.verbose) {
+                console.log(`    [Dictionary] No match for: "${text}" - falling back to AI`);
+            }
+            return this.aiMapper.mapStep(step); // Returns Promise<MappedStep>
+        }
+        // Final fallback: TODO comment
+        return {
+            code: `// TODO: Implement step: ${text}`,
+            comment: `Unrecognized step pattern (AI fallback disabled)`,
+        };
+    }
+    mapNavigationStep(route) {
+        // Extract route name from data ref <auth-login> or legacy selector ref [auth-login]
+        const routeName = route ? route.replace(/[<>\[\]]/g, '') : '';
+        // Use route loader to get actual path
+        // For now, use simple conversion (will be improved in Phase 2)
+        const routePath = this.selectorToRoutePath(routeName);
+        return {
+            code: this.templateEngine.renderStep('navigation', { routePath }),
+            comment: `Navigate to ${routeName}`,
+        };
+    }
+    mapLoginStep(userDataRef) {
+        // Parse data ref like "valid_user" from <valid_user>
+        const userKey = userDataRef.split('.')[0];
+        return {
+            code: this.templateEngine.renderStep('login', { userKey }),
+            imports: ['getUser'],
+        };
+    }
+    mapFillStep(selectorRef, dataRef, value) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        const fillValue = dataRef
+            ? this.resolveDataRef(dataRef)
+            : `'${value}'`;
+        return {
+            code: this.templateEngine.renderStep('fill', { varName, selectorRef, screenId, fillValue }),
+            comment: `Fill ${selectorRef}`,
+        };
+    }
+    mapClickStep(selectorRef) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('click', { varName, selectorRef, screenId }),
+            comment: `Click ${selectorRef}`,
+        };
+    }
+    mapWaitStep(text) {
+        const duration = text.includes('AI response') ? 2000 : 1000;
+        return {
+            code: this.templateEngine.renderStep('wait', { duration }),
+        };
+    }
+    mapRouteAssertionStep(route) {
+        const routePath = this.selectorToRoutePath(route);
+        return {
+            code: this.templateEngine.renderStep('route-assertion', { routePath }),
+            comment: `Assert route is ${route}`,
+        };
+    }
+    mapVisibilityAssertionStep(selectorRef) {
+        const screenId = this.extractScreenId(selectorRef);
+        // Generate unique variable name from selector ref + counter
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('visibility-assertion', { varName, selectorRef, screenId }),
+            comment: `Assert ${selectorRef} is visible`,
+        };
+    }
+    mapErrorMessageAssertion() {
+        return {
+            code: this.templateEngine.renderStep('error-message-assertion', {}),
+            comment: 'Assert error message is shown',
+        };
+    }
+    mapMessageAssertion(message, selectorRef) {
+        if (selectorRef) {
+            const screenId = this.extractScreenId(selectorRef);
+            const varName = 'msgContainer_' + selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+            return {
+                code: this.templateEngine.renderStep('message-assertion-selector', { varName, selectorRef, screenId, message }),
+            };
+        }
+        return {
+            code: this.templateEngine.renderStep('message-assertion-body', { message }),
+        };
+    }
+    mapGenericMessageAssertion(text) {
+        // Extract message type (welcome, error, success, etc.)
+        const typeMatch = text.match(/(\w+)\s+message/);
+        const messageType = typeMatch ? typeMatch[1] : 'message';
+        return {
+            code: this.templateEngine.renderStep('generic-message-assertion', { messageType }),
+            comment: `Assert ${messageType} message is displayed`,
+        };
+    }
+    mapAIResponseAssertion(selectorRef) {
+        if (selectorRef) {
+            const screenId = this.extractScreenId(selectorRef);
+            const containerVar = 'aiRespContainer_' + selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+            const messagesVar = 'aiMessages_' + selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+            return {
+                code: this.templateEngine.renderStep('ai-response-assertion-selector', { containerVar, messagesVar, selectorRef, screenId }),
+            };
+        }
+        return {
+            code: this.templateEngine.renderStep('ai-response-assertion-simple', {}),
+        };
+    }
+    mapMessageCountAssertion(text, selectorRef) {
+        const countMatch = text.match(/(\d+)/);
+        const expectedCount = countMatch ? parseInt(countMatch[1]) : 1;
+        const messageType = text.includes('user messages') ? 'user' : 'AI';
+        const screenId = this.extractScreenId(selectorRef);
+        const containerVar = 'msgCountContainer_' + selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        const messagesVar = `${messageType}Messages_${selectorRef.replace(/[^a-zA-Z0-9]/g, '_')}_${this.stepCounter}`;
+        return {
+            code: this.templateEngine.renderStep('message-count-assertion', { containerVar, messagesVar, selectorRef, screenId, messageType, expectedCount }),
+            comment: `Assert ${expectedCount} ${messageType} messages`,
+        };
+    }
+    /**
+     * Extract screen ID from selector ref
+     * Example: auth-login.email → auth-login
+     */
+    extractScreenId(selectorRef) {
+        const parts = selectorRef.split('.');
+        return parts[0];
+    }
+    /**
+     * Resolve data reference to code
+     * Example: valid_user.email → user.email
+     */
+    resolveDataRef(dataRef) {
+        const parts = dataRef.split('.');
+        const userKey = parts[0];
+        const field = parts.slice(1).join('.');
+        return `user.${field}`;
+    }
+    /**
+     * Convert route name to route path
+     * Example: chat → /chat, auth-login → /auth/login, home → /
+     * Note: Route name should already be cleaned (no brackets/angle brackets)
+     */
+    selectorToRoutePath(routeName) {
+        // Handle null/undefined
+        if (!routeName) {
+            return '/';
+        }
+        // Special case: home → / (root)
+        if (routeName === 'home') {
+            return '/';
+        }
+        // Convert auth-login → /auth/login (replace ALL hyphens with slashes)
+        return '/' + routeName.replace(/-/g, '/');
+    }
+    /**
+     * Map "user presses Enter in [element]" step
+     */
+    mapPressEnterStep(selectorRef) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('press-enter', { varName, selectorRef, screenId }),
+            comment: `Press Enter in ${selectorRef}`,
+        };
+    }
+    /**
+     * Map "[element] should be empty" step
+     */
+    mapEmptyAssertion(selectorRef) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('empty-assertion-advanced', { varName, selectorRef, screenId }),
+            comment: `Assert ${selectorRef} is empty`,
+        };
+    }
+    /**
+     * Map "[element] should be scrolled to bottom" step
+     */
+    mapScrollBottomAssertion(selectorRef) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('scroll-bottom-assertion', { varName, selectorRef, screenId }),
+            comment: `Assert ${selectorRef} scrolled to bottom`,
+        };
+    }
+    /**
+     * Map "user should see notification 'text'" step
+     */
+    mapNotificationAssertion(message) {
+        return {
+            code: this.templateEngine.renderStep('notification-assertion', { message }),
+            comment: `Assert notification: "${message}"`,
+        };
+    }
+    /**
+     * Map "[element] should be disabled" step
+     */
+    mapDisabledAssertion(selectorRef) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('disabled-assertion', { varName, selectorRef, screenId }),
+            comment: `Assert ${selectorRef} is disabled`,
+        };
+    }
+    /**
+     * Map "[element] should be enabled" step
+     */
+    mapEnabledAssertion(selectorRef) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('enabled-assertion', { varName, selectorRef, screenId }),
+            comment: `Assert ${selectorRef} is enabled`,
+        };
+    }
+    /**
+     * Map "user is not logged in" step
+     */
+    mapNotLoggedInStep() {
+        return {
+            code: this.templateEngine.renderStep('clear-auth', {}),
+            comment: 'Clear authentication',
+        };
+    }
+    /**
+     * Map "user should be redirected to [screen]" step
+     */
+    mapRedirectAssertion(selectorRef) {
+        // Extract screen from selector ref like [auth-login]
+        const screenName = selectorRef.split('.')[0];
+        const routePath = this.selectorToRoutePath(screenName);
+        return {
+            code: this.templateEngine.renderStep('redirect-assertion', { routePath }),
+            comment: `Assert redirected to ${screenName}`,
+        };
+    }
+    /**
+     * Map "[element] should contain text '...'" step
+     */
+    mapContainsTextAssertion(selectorRef, expectedText) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('contains-text-assertion', { varName, selectorRef, screenId, expectedText }),
+            comment: `Assert ${selectorRef} contains "${expectedText}"`,
+        };
+    }
+    /**
+     * Map "HTML5 validation is disabled" step
+     */
+    mapHTML5ValidationCheck() {
+        return {
+            code: this.templateEngine.renderStep('html5-validation-check', {}),
+            comment: 'Assert HTML5 validation disabled',
+        };
+    }
+    // ========================================
+    // NEW METHODS - Admin Dashboard Support
+    // ========================================
+    /**
+     * Map "user selects [element] with 'value'" step
+     * Handles dropdown/select elements
+     */
+    mapSelectStep(selectorRef, dataRef, value) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        const selectValue = dataRef
+            ? this.resolveDataRef(dataRef)
+            : `'${value}'`;
+        return {
+            code: this.templateEngine.renderStep('select', { varName, selectorRef, screenId, selectValue }),
+            comment: `Select ${value || dataRef} from ${selectorRef}`,
+        };
+    }
+    /**
+     * Map "user checks/unchecks [element] checkbox" step
+     */
+    mapCheckboxStep(selectorRef, checked) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        const action = checked ? 'check' : 'uncheck';
+        return {
+            code: this.templateEngine.renderStep('checkbox', { varName, selectorRef, screenId, action }),
+            comment: `${checked ? 'Check' : 'Uncheck'} ${selectorRef}`,
+        };
+    }
+    /**
+     * Map "user clears [element]" step
+     */
+    mapClearStep(selectorRef) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('clear', { varName, selectorRef, screenId }),
+            comment: `Clear ${selectorRef}`,
+        };
+    }
+    /**
+     * Map "[element] should be active" step
+     * Checks for aria-selected="true" or active class
+     */
+    mapActiveStateAssertion(selectorRef) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('active-state-assertion', { varName, selectorRef, screenId }),
+            comment: `Assert ${selectorRef} is active`,
+        };
+    }
+    /**
+     * Map "I am on the 'screen-name' screen" step
+     * Navigation to a specific screen
+     */
+    mapScreenNavigationStep(screenName) {
+        const routePath = this.selectorToRoutePath(screenName);
+        return {
+            code: this.templateEngine.renderStep('screen-navigation', { screenName, routePath }),
+            comment: `Navigate to ${screenName}`,
+        };
+    }
+    // ========================================
+    // ASSERTION METHODS - Display & Content
+    // ========================================
+    /**
+     * Map "[element] should be displayed with 'text'" step
+     * Checks both visibility and exact text match
+     */
+    mapDisplayedWithTextAssertion(selectorRef, expectedText) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('displayed-with-text', { varName, selectorRef, screenId, expectedText }),
+            comment: `Assert ${selectorRef} is displayed with "${expectedText}"`,
+        };
+    }
+    /**
+     * Map "[element] should contain 'text'" step
+     * Checks visibility and partial text match
+     */
+    mapDisplayedContainingTextAssertion(selectorRef, expectedText) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('displayed-containing-text', { varName, selectorRef, screenId, expectedText }),
+            comment: `Assert ${selectorRef} contains "${expectedText}"`,
+        };
+    }
+    // ========================================
+    // ASSERTION METHODS - Attributes & Properties
+    // ========================================
+    /**
+     * Map "[element] should have attribute 'attr' with value 'val'" step
+     */
+    mapHasAttributeAssertion(selectorRef, attributeName, expectedValue) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('has-attribute', { varName, selectorRef, screenId, attributeName, expectedValue }),
+            comment: `Assert ${selectorRef} has attribute ${attributeName}="${expectedValue}"`,
+        };
+    }
+    /**
+     * Map "[element] should have class 'className'" step
+     */
+    mapHasClassAssertion(selectorRef, className) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('has-class', { varName, selectorRef, screenId, className }),
+            comment: `Assert ${selectorRef} has class "${className}"`,
+        };
+    }
+    /**
+     * Map "[element] should have value 'value'" step
+     */
+    mapHasValueAssertion(selectorRef, expectedValue) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('has-value', { varName, selectorRef, screenId, expectedValue }),
+            comment: `Assert ${selectorRef} has value "${expectedValue}"`,
+        };
+    }
+    /**
+     * Map "[element] should have placeholder 'text'" step
+     */
+    mapHasPlaceholderAssertion(selectorRef, expectedPlaceholder) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('has-placeholder', { varName, selectorRef, screenId, expectedPlaceholder }),
+            comment: `Assert ${selectorRef} has placeholder "${expectedPlaceholder}"`,
+        };
+    }
+    // ========================================
+    // ASSERTION METHODS - State Checks
+    // ========================================
+    /**
+     * Map "[element] should be checked" step
+     */
+    mapIsCheckedAssertion(selectorRef) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('is-checked', { varName, selectorRef, screenId }),
+            comment: `Assert ${selectorRef} is checked`,
+        };
+    }
+    /**
+     * Map "[element] should be unchecked" step
+     */
+    mapIsUncheckedAssertion(selectorRef) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('is-unchecked', { varName, selectorRef, screenId }),
+            comment: `Assert ${selectorRef} is unchecked`,
+        };
+    }
+    /**
+     * Map "[element] should not be visible" or "should be hidden" step
+     */
+    mapNotVisibleAssertion(selectorRef) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('not-visible', { varName, selectorRef, screenId }),
+            comment: `Assert ${selectorRef} is not visible`,
+        };
+    }
+    /**
+     * Map "[element] should be focused" step
+     */
+    mapIsFocusedAssertion(selectorRef) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('is-focused', { varName, selectorRef, screenId }),
+            comment: `Assert ${selectorRef} is focused`,
+        };
+    }
+    /**
+     * Map "[element] should be editable" step
+     */
+    mapIsEditableAssertion(selectorRef) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('is-editable', { varName, selectorRef, screenId }),
+            comment: `Assert ${selectorRef} is editable`,
+        };
+    }
+    // ========================================
+    // ASSERTION METHODS - Count & Collections
+    // ========================================
+    /**
+     * Map "[element] should have count N" step
+     */
+    mapHasCountAssertion(selectorRef, expectedCount) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('has-count', { varName, selectorRef, screenId, expectedCount }),
+            comment: `Assert ${selectorRef} has count ${expectedCount}`,
+        };
+    }
+    /**
+     * Map "[element] count should be greater than N" step
+     */
+    mapCountGreaterThanAssertion(selectorRef, minCount) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('count-greater-than', { varName, selectorRef, screenId, minCount }),
+            comment: `Assert ${selectorRef} count > ${minCount}`,
+        };
+    }
+    /**
+     * Map "[element] count should be less than N" step
+     */
+    mapCountLessThanAssertion(selectorRef, maxCount) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('count-less-than', { varName, selectorRef, screenId, maxCount }),
+            comment: `Assert ${selectorRef} count < ${maxCount}`,
+        };
+    }
+    // ========================================
+    // ASSERTION METHODS - Link & Image
+    // ========================================
+    /**
+     * Map "[element] should have link 'url'" step
+     */
+    mapHasLinkAssertion(selectorRef, expectedUrl) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('has-link', { varName, selectorRef, screenId, expectedUrl }),
+            comment: `Assert ${selectorRef} links to "${expectedUrl}"`,
+        };
+    }
+    /**
+     * Map "[element] should have image source 'src'" step
+     */
+    mapHasImageSrcAssertion(selectorRef, expectedSrc) {
+        const screenId = this.extractScreenId(selectorRef);
+        const varName = selectorRef.replace(/[^a-zA-Z0-9]/g, '_') + '_' + this.stepCounter;
+        return {
+            code: this.templateEngine.renderStep('has-image-src', { varName, selectorRef, screenId, expectedSrc }),
+            comment: `Assert ${selectorRef} has image src "${expectedSrc}"`,
+        };
+    }
+}
+exports.StepMapper = StepMapper;
+//# sourceMappingURL=step-mapper-old.js.map