@sun-asterisk/sungen 1.0.24 → 2.0.1

package/dist/generators/scaffold-generator/index.js

@@ -1,877 +0,0 @@
-"use strict";
-/**
- * Scaffold Generator
- * Parses Gherkin feature files and generates selector YAML scaffolds
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScaffoldGenerator = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const yaml_1 = __importDefault(require("yaml"));
-const glob_1 = require("glob");
-const selector_resolver_1 = require("../test-generator/utils/selector-resolver");
-class ScaffoldGenerator {
-    /**
-     * Generate scaffold YAML from a feature file
-     */
-    generateFromFile(featureFilePath) {
-        const content = fs_1.default.readFileSync(featureFilePath, 'utf-8');
-        return this.generateFromContent(content);
-    }
-    /**
-     * Generate scaffold YAML from feature content
-     */
-    generateFromContent(content) {
-        // Extract feature path from Gherkin metadata (e.g., "Path: login-guest?user=inactive")
-        const featurePath = this.extractFeaturePath(content);
-        const elements = this.extractElements(content, featurePath);
-        return this.buildScaffold(elements);
-    }
-    /**
-     * Extract elements from Gherkin content with their actions
-     */
-    extractElements(content, featurePath) {
-        const elements = [];
-        const lines = content.split('\n');
-        // Regex to match elements in brackets [...] with optional nth index
-        // Captures: [Element] field 1, [Element] button 2, [Element] text 3, etc.
-        const elementRegex = /\[([^\]]+)\]/g;
-        for (const line of lines) {
-            const trimmedLine = line.trim();
-            // Skip comments and empty lines
-            if (trimmedLine.startsWith('#') || !trimmedLine) {
-                continue;
-            }
-            // Determine action from the line
-            const action = this.detectAction(trimmedLine);
-            let match;
-            while ((match = elementRegex.exec(trimmedLine)) !== null) {
-                const rawText = match[1];
-                const baseKey = selector_resolver_1.SelectorResolver.generateKey(rawText);
-                // Extract nth index and target type from text after the element reference
-                // Matches patterns like: [Email] field 1, [Submit] button 2, [Name] 3
-                const afterElement = trimmedLine.slice(match.index + match[0].length);
-                const nth = selector_resolver_1.SelectorResolver.extractNthFromStep(afterElement);
-                const targetType = this.extractTargetType(afterElement, action);
-                // Append nth to key so elements at different positions get distinct keys
-                // e.g., [Hãy gửi lời cảm ơn] field 3 → "hay.gui.loi.cam.on--3"
-                const key = nth > 0 ? `${baseKey}--${nth}` : baseKey;
-                // Check if element starts with "target" (semantic indicator for dynamic content)
-                // e.g., [target order], [Target Item] → element should have empty value
-                const isTargetElement = /^target\s/i.test(rawText);
-                elements.push({
-                    rawText: isTargetElement ? '' : rawText, // Empty value when element is a target element
-                    key,
-                    action,
-                    targetType,
-                    lineText: trimmedLine,
-                    nth,
-                    featurePath: targetType === 'page' ? featurePath : undefined,
-                });
-            }
-        }
-        return elements;
-    }
-    /**
-     * Extract target type from text after element reference
-     * e.g., " button" -> "button", " link 1" -> "link", " field with" -> "field"
-     */
-    extractTargetType(text, action) {
-        const lowerText = text.toLowerCase().trim();
-        // NEW: Check for 'page' keyword FIRST (highest priority)
-        if (/^page\b/.test(lowerText) || /^\d*\s*page\b/.test(lowerText)) {
-            return 'page';
-        }
-        // Check for specific target types in order of specificity
-        if (/^link\b/.test(lowerText) || /^\d*\s*link\b/.test(lowerText)) {
-            return 'link';
-        }
-        if (/^button\b/.test(lowerText) || /^\d*\s*button\b/.test(lowerText)) {
-            return 'button';
-        }
-        if (/^radio\b/.test(lowerText) || /^\d*\s*radio\b/.test(lowerText)) {
-            return 'radio';
-        }
-        if (/^dropdown\b/.test(lowerText) || /^\d*\s*dropdown\b/.test(lowerText) || /^select\b/.test(lowerText)) {
-            return 'dropdown';
-        }
-        if (/^checkbox\b/.test(lowerText) || /^\d*\s*checkbox\b/.test(lowerText)) {
-            return 'checkbox';
-        }
-        if (/^field\b/.test(lowerText) || /^\d*\s*field\b/.test(lowerText) || /^input\b/.test(lowerText)) {
-            return 'field';
-        }
-        if (/^textbox\b/.test(lowerText) || /^\d*\s*textbox\b/.test(lowerText)) {
-            return 'textbox';
-        }
-        if (/^textarea\b/.test(lowerText) || /^\d*\s*textarea\b/.test(lowerText)) {
-            return 'textarea';
-        }
-        if (/^editor\b/.test(lowerText) || /^\d*\s*editor\b/.test(lowerText)) {
-            return 'editor';
-        }
-        if (/^text\b/.test(lowerText) || /^\d*\s*text\b/.test(lowerText)) {
-            return 'text';
-        }
-        if (/^label\b/.test(lowerText) || /^\d*\s*label\b/.test(lowerText)) {
-            return 'label';
-        }
-        if (/^uploader\b/.test(lowerText) || /^\d*\s*uploader\b/.test(lowerText)) {
-            return 'uploader';
-        }
-        if (/^element\b/.test(lowerText) || /^\d*\s*element\b/.test(lowerText)) {
-            return 'element';
-        }
-        if (/^(column|columnheader)\b/.test(lowerText) || /^\d*\s*(column|columnheader)\b/.test(lowerText)) {
-            return 'column';
-        }
-        if (/^(logo|image|img|icon)\b/.test(lowerText) || /^\d*\s*(logo|image|img|icon)\b/.test(lowerText)) {
-            return 'img';
-        }
-        if (/^(option|item|listitem)\b/.test(lowerText) || /^\d*\s*(option|item|listitem)\b/.test(lowerText)) {
-            return 'option';
-        }
-        if (/^(dialog|modal)\b/.test(lowerText) || /^\d*\s*(dialog|modal)\b/.test(lowerText)) {
-            return 'dialog';
-        }
-        if (/^(heading|header)\b/.test(lowerText) || /^\d*\s*(heading|header)\b/.test(lowerText)) {
-            return 'heading';
-        }
-        if (/^(title|caption|message)\b/.test(lowerText) || /^\d*\s*(title|caption|message)\b/.test(lowerText)) {
-            return 'text';
-        }
-        // Default based on action
-        switch (action) {
-            case 'click':
-                return 'text'; // Default click to text
-            case 'fill':
-                return 'field'; // Default fill to field
-            case 'see':
-                return 'text'; // Default see to text
-            case 'select':
-                return 'dropdown'; // Default select to dropdown
-            default:
-                return 'element';
-        }
-    }
-    /**
-     * Extract nth index from text after element reference
-     * e.g., " field 1 with" -> 1, " button 2" -> 2, " row 1" -> 1, " text" -> 0
-     */
-    /**
-     * Detect the action type from a Gherkin step line
-     */
-    detectAction(line) {
-        const lowerLine = line.toLowerCase();
-        // Check for specific action keywords
-        // Order matters: check "see" before "fill" because text like "fill in all fields" may appear in assertions
-        if (/\b(see|verify|check|expect|should see|visible|displayed)\b/.test(lowerLine)) {
-            return 'see';
-        }
-        if (/\b(fill|enter|type|input)\b/.test(lowerLine)) {
-            return 'fill';
-        }
-        if (/\b(click|press|tap|submit)\b/.test(lowerLine)) {
-            return 'click';
-        }
-        if (/\b(open|navigate|go to|visit)\b/.test(lowerLine)) {
-            return 'open';
-        }
-        if (/\b(select|choose|pick)\b/.test(lowerLine)) {
-            return 'select';
-        }
-        if (/\b(wait|wait for|waits for)\b/.test(lowerLine)) {
-            return 'wait';
-        }
-        // Default to placeholder for unknown actions
-        return 'default';
-    }
-    /**
-     * Extract feature path from Gherkin metadata
-     * Looks for "Path: <value>" line in the feature file
-     * e.g., "Path: login-guest?user=inactive" -> "login-guest?user=inactive"
-     */
-    extractFeaturePath(content) {
-        const lines = content.split('\n');
-        for (const line of lines) {
-            const trimmedLine = line.trim();
-            // Look for Path: pattern (case-insensitive)
-            const match = trimmedLine.match(/^Path:\s*(.+?)$/i);
-            if (match) {
-                return match[1].trim();
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Convert element text to YAML key format
-     * "Email Address" -> "email.address"
-     * "Your email or password is incorrect!" -> "your.email.or.password.is.incorrect"
-     */
-    /**
-     * Get action priority (higher number = higher priority)
-     */
-    getActionPriority(action) {
-        const priorities = {
-            'click': 4, // Highest priority - most specific interaction
-            'fill': 3, // Form input
-            'select': 3, // Form select
-            'see': 2, // Assertion
-            'open': 1, // Navigation - lowest priority
-            'default': 0,
-        };
-        return priorities[action] ?? 0;
-    }
-    /**
-     * Build scaffold result from extracted elements
-     */
-    buildScaffold(elements) {
-        const result = {};
-        // Group elements by key to detect duplicates with different target types
-        const elementsByKey = {};
-        for (const element of elements) {
-            if (!elementsByKey[element.key]) {
-                elementsByKey[element.key] = [];
-            }
-            elementsByKey[element.key].push(element);
-        }
-        for (const key of Object.keys(elementsByKey)) {
-            const group = elementsByKey[key];
-            // Deduplicate by targetType, keeping highest priority action per type
-            const byType = {};
-            for (const element of group) {
-                const existing = byType[element.targetType];
-                if (!existing ||
-                    this.getActionPriority(element.action) > this.getActionPriority(existing.action)) {
-                    byType[element.targetType] = element;
-                }
-            }
-            const uniqueTypes = Object.keys(byType);
-            if (uniqueTypes.length <= 1) {
-                // No type conflict — use base key as before
-                const element = byType[uniqueTypes[0]];
-                result[key] = this.createScaffoldElement(element);
-            }
-            else {
-                // Multiple types for same name — generate type-suffixed keys
-                for (const type of uniqueTypes) {
-                    const suffixedKey = `${key}--${type}`;
-                    result[suffixedKey] = this.createScaffoldElement(byType[type]);
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * Create a scaffold element based on the action type and target type
-     */
-    createScaffoldElement(element) {
-        const { nth, targetType } = element;
-        // NEW: Handle page type
-        if (targetType === 'page') {
-            return {
-                locator: '',
-                type: 'page',
-                value: element.featurePath || '/',
-                nth,
-            };
-        }
-        switch (element.action) {
-            case 'fill':
-                // For fill action with uploader type, use label type (file input triggered by label)
-                if (targetType === 'uploader') {
-                    return {
-                        locator: '',
-                        type: 'label',
-                        value: element.rawText,
-                        nth,
-                    };
-                }
-                // For fill action with label type, use label type
-                if (targetType === 'label') {
-                    return {
-                        locator: '',
-                        type: 'label',
-                        value: element.rawText,
-                        nth,
-                    };
-                }
-                // For fill action with field/textbox/textarea types, use role-based locator
-                return {
-                    locator: '',
-                    type: 'role',
-                    value: this.getFillRoleValue(targetType),
-                    name: element.rawText,
-                    nth,
-                };
-            case 'click':
-                // Special case: label and text clicks use text locator
-                if (targetType === 'label' || targetType === 'text') {
-                    return {
-                        locator: '',
-                        type: 'text',
-                        value: element.rawText,
-                        nth,
-                    };
-                }
-                // Regular click actions use role
-                const clickRoleValue = this.getClickRoleValue(targetType);
-                return {
-                    locator: '',
-                    type: 'role',
-                    value: clickRoleValue,
-                    name: element.rawText, // TODO: Update with actual accessible name from inspection
-                    nth,
-                };
-            case 'see':
-                // Column type: used for table column cell assertions, no DOM selector needed
-                if (targetType === 'column') {
-                    return {
-                        locator: '',
-                        type: 'column',
-                        value: element.rawText,
-                        nth,
-                    };
-                }
-                // For assertions - respect targetType for role-based elements
-                if (targetType === 'img' || targetType === 'button' || targetType === 'link' ||
-                    targetType === 'checkbox' || targetType === 'radio' || targetType === 'heading' || targetType === 'dialog' || targetType === 'dropdown') {
-                    const seeRoleValue = this.getRoleValue(targetType);
-                    return {
-                        locator: '',
-                        type: 'role',
-                        value: seeRoleValue,
-                        name: element.rawText,
-                        nth,
-                    };
-                }
-                return {
-                    locator: '',
-                    type: 'text',
-                    value: element.rawText,
-                    nth,
-                };
-            case 'select':
-                // Determine role based on target type (radio, dropdown/combobox, checkbox)
-                const selectRoleValue = this.getSelectRoleValue(targetType);
-                return {
-                    locator: '',
-                    type: 'role',
-                    value: selectRoleValue,
-                    name: element.rawText, // TODO: Update with actual accessible name from inspection
-                    nth,
-                };
-            case 'open':
-                // For page navigation, we typically don't need a selector
-                // But include it for reference
-                return {
-                    locator: '',
-                    type: 'text',
-                    value: element.rawText,
-                    nth,
-                };
-            default:
-                // Default to placeholder type
-                return {
-                    locator: '',
-                    type: 'placeholder',
-                    value: element.rawText,
-                    nth,
-                };
-        }
-    }
-    /**
-     * Get ARIA role value from target type (shared across actions)
-     */
-    getRoleValue(targetType) {
-        switch (targetType) {
-            case 'link':
-                return 'link';
-            case 'button':
-                return 'button';
-            case 'checkbox':
-                return 'checkbox';
-            case 'radio':
-                return 'radio';
-            case 'tab':
-                return 'tab';
-            case 'menuitem':
-                return 'menuitem';
-            case 'img':
-                return 'img';
-            case 'heading':
-                return 'heading';
-            case 'dialog':
-                return 'dialog';
-            case 'dropdown':
-                return 'button';
-            default:
-                return 'button'; // Default to button
-        }
-    }
-    /**
-     * Get role value for click actions based on target type
-     */
-    getClickRoleValue(targetType) {
-        return this.getRoleValue(targetType);
-    }
-    /**
-     * Get role value for select actions based on target type
-     */
-    getSelectRoleValue(targetType) {
-        switch (targetType) {
-            case 'radio':
-                return 'radio';
-            case 'checkbox':
-                return 'checkbox';
-            case 'dropdown':
-            case 'select':
-                return 'combobox';
-            case 'listbox':
-                return 'listbox';
-            default:
-                return 'combobox'; // Default to combobox
-        }
-    }
-    /**
-     * Get ARIA role value for fill actions — all fillable inputs use 'textbox'
-     */
-    getFillRoleValue(targetType) {
-        switch (targetType) {
-            case 'field':
-            case 'textbox':
-            case 'textarea':
-            default:
-                return 'textbox';
-        }
-    }
-    /**
-     * Generate YAML content from scaffold result
-     */
-    generateYamlContent(scaffold, screenName) {
-        // For header, use name (for role type) or value (for other types)
-        const getDisplayValue = (e) => e.name || e.value;
-        const header = screenName
-            ? `# ${this.capitalizeFirst(screenName)} Screen Selectors (Auto-generated)
-# Reference in features: ${Object.values(scaffold).map(e => `[${getDisplayValue(e)}]`).join(', ')}
-# Directory: qa/selectors/screens/
-
-`
-            : `# Screen Selectors (Auto-generated)
-
-`;
-        // Convert to YAML with proper formatting
-        const yamlContent = yaml_1.default.stringify(scaffold, {
-            indent: 2,
-            lineWidth: 100,
-            defaultKeyType: 'PLAIN',
-            defaultStringType: 'QUOTE_SINGLE',
-        });
-        return header + yamlContent;
-    }
-    /**
-     * Write scaffold to file
-     */
-    writeScaffold(scaffold, outputPath, screenName) {
-        const dir = path_1.default.dirname(outputPath);
-        if (!fs_1.default.existsSync(dir)) {
-            fs_1.default.mkdirSync(dir, { recursive: true });
-        }
-        const content = this.generateYamlContent(scaffold, screenName);
-        fs_1.default.writeFileSync(outputPath, content, 'utf-8');
-    }
-    /**
-     * Process a feature file and write scaffold to output
-     */
-    processFeatureFile(featureFilePath, outputDir, forceOverwrite = false) {
-        // Extract screen name from feature file name
-        const featureFileName = path_1.default.basename(featureFilePath, '.feature');
-        const screenName = featureFileName;
-        // Generate scaffold
-        const scaffold = this.generateFromFile(featureFilePath);
-        const elementCount = Object.keys(scaffold).length;
-        // Write to output
-        const outputPath = path_1.default.join(outputDir, `${screenName}.yaml`);
-        // Check if file exists and skip if not forcing overwrite
-        if (fs_1.default.existsSync(outputPath) && !forceOverwrite) {
-            return { outputPath, elementCount };
-        }
-        this.writeScaffold(scaffold, outputPath, screenName);
-        return { outputPath, elementCount };
-    }
-    /**
-     * Process all feature files in a directory
-     */
-    processAllFeatures(featuresDir, outputDir) {
-        const featureFiles = glob_1.glob.sync('**/*.feature', {
-            cwd: featuresDir,
-            absolute: true,
-        });
-        const results = [];
-        for (const featureFile of featureFiles) {
-            const result = this.processFeatureFile(featureFile, outputDir);
-            results.push({
-                file: featureFile,
-                ...result,
-            });
-        }
-        return results;
-    }
-    /**
-     * Enrich scaffold with live-scan data if a .live-scan.yaml file exists.
-     * Uses the Playwright locator strategy detected by live-scan:
-     *   testid      → type: testid, value: <testid>
-     *   role        → type: role, value: <aria-role>, name: <accessible-name>
-     *   label       → type: label, value: <label-text>
-     *   placeholder → type: placeholder, value: <placeholder-text>
-     *   text        → type: text, value: <visible-text>
-     */
-    enrichWithLiveScan(scaffold, liveScanPath) {
-        if (!fs_1.default.existsSync(liveScanPath)) {
-            return scaffold;
-        }
-        let matrixData;
-        try {
-            const { readMatrix, mergeMatrixElements } = require('../../core/live-scanner/matrix-reader');
-            matrixData = readMatrix(liveScanPath);
-            if (!matrixData)
-                return scaffold;
-            const elements = mergeMatrixElements(matrixData);
-            if (!elements || Object.keys(elements).length === 0)
-                return scaffold;
-            console.log(`   🔗 Using live-scan data from ${path_1.default.basename(liveScanPath)}`);
-            let enrichedCount = 0;
-            let warningCount = 0;
-            const enriched = { ...scaffold };
-            for (const [key, scaffoldElement] of Object.entries(enriched)) {
-                // Column-type elements use header text matching, skip live-scan enrichment
-                if (scaffoldElement.type === 'column')
-                    continue;
-                // Target elements (empty value) are matched by data value at runtime, skip enrichment
-                if (!scaffoldElement.value && !scaffoldElement.name)
-                    continue;
-                // Try exact key first, then base key without --N suffix or --type suffix
-                let liveElement = elements[key];
-                if (!liveElement && key.includes('--')) {
-                    const baseKey = key.replace(/--.*$/, '');
-                    liveElement = elements[baseKey];
-                }
-                if (!liveElement) {
-                    continue;
-                }
-                // If live-scan couldn't find the element, clear the identifying field so user must fill manually
-                if (liveElement.matchMethod === 'unresolved') {
-                    if (scaffoldElement.name !== undefined) {
-                        enriched[key] = { ...scaffoldElement, name: '' };
-                    }
-                    else {
-                        enriched[key] = { ...scaffoldElement, value: '' };
-                    }
-                    continue;
-                }
-                // Use the Playwright locator strategy that live-scan detected
-                const selectorType = liveElement.selectorType;
-                // Only set exact when true (omit from YAML when false for cleaner output)
-                const exactField = liveElement.exact ? { exact: true } : {};
-                // Strip 'name' from scaffold base — only 'role' type uses name
-                const { name: _scaffoldName, ...scaffoldBase } = scaffoldElement;
-                if (selectorType === 'testid' && liveElement.testid) {
-                    // page.getByTestId('value')
-                    enriched[key] = {
-                        ...scaffoldBase,
-                        type: 'testid',
-                        value: liveElement.testid,
-                    };
-                }
-                else if (selectorType === 'role' && liveElement.role) {
-                    // page.getByRole('button', { name: 'Submit' })
-                    // When name is empty (e.g. data-value fallback), keep it as '' —
-                    // the actual name comes from test-data at runtime
-                    enriched[key] = {
-                        ...scaffoldBase,
-                        type: 'role',
-                        value: liveElement.role,
-                        name: liveElement.name,
-                        ...exactField,
-                    };
-                }
-                else if (selectorType === 'label' && liveElement.label) {
-                    // page.getByLabel('Username')
-                    enriched[key] = {
-                        ...scaffoldBase,
-                        type: 'label',
-                        value: liveElement.label,
-                        ...exactField,
-                    };
-                }
-                else if (selectorType === 'placeholder' && (liveElement.placeholder || liveElement.selectorValue)) {
-                    // page.getByPlaceholder('Enter email')
-                    enriched[key] = {
-                        ...scaffoldBase,
-                        type: 'placeholder',
-                        value: liveElement.placeholder || liveElement.selectorValue,
-                        ...exactField,
-                    };
-                }
-                else if (selectorType === 'text') {
-                    // page.getByText('Welcome')
-                    // When name is empty (data-value fallback), keep value empty —
-                    // the actual text comes from test-data at runtime
-                    enriched[key] = {
-                        ...scaffoldBase,
-                        type: 'text',
-                        value: liveElement.name,
-                        ...exactField,
-                    };
-                }
-                else if (selectorType === 'locator' && liveElement.selectorValue) {
-                    // page.locator('[contenteditable="true"]') — CSS locator
-                    // Reset nth to 0: the original nth was for text matches, not this locator type
-                    enriched[key] = {
-                        ...scaffoldBase,
-                        type: 'locator',
-                        value: liveElement.selectorValue,
-                        nth: 0,
-                    };
-                }
-                else {
-                    continue;
-                }
-                // Detect contenteditable div-based editors (rich text editors like TipTap, Quill, ProseMirror)
-                // When the DOM element is contenteditable but NOT a native input/textarea,
-                // mark it so the generator uses click + pressSequentially instead of .fill()
-                if (liveElement.contenteditable && liveElement.tag !== 'textarea' && liveElement.tag !== 'input') {
-                    enriched[key] = { ...enriched[key], inputMethod: 'pressSequentially' };
-                }
-                enrichedCount++;
-                if (liveElement.warning) {
-                    warningCount++;
-                    console.log(`   ⚠️  ${key}: ${liveElement.warning}`);
-                }
-            }
-            const textOnlyCount = Object.keys(enriched).length - enrichedCount;
-            console.log(`   📊 Live-scan: ${enrichedCount} enriched, ${textOnlyCount} text-inferred${warningCount > 0 ? `, ${warningCount} warnings` : ''}`);
-            return enriched;
-        }
-        catch (error) {
-            console.warn(`   ⚠️  Failed to read live-scan data: ${error.message}`);
-            return scaffold;
-        }
-    }
-    /**
-     * Helper to capitalize first letter
-     */
-    capitalizeFirst(str) {
-        return str.charAt(0).toUpperCase() + str.slice(1);
-    }
-    /**
-     * Process a screen and generate both selectors and test-data YAML
-     * Folder structure: qa/screens/<screen>/features/, selectors/, test-data/
-     */
-    processScreen(screenName, screensDir = 'qa/screens', forceOverwrite = false) {
-        const screenDir = path_1.default.join(screensDir, screenName);
-        const featuresDir = path_1.default.join(screenDir, 'features');
-        const selectorsDir = path_1.default.join(screenDir, 'selectors');
-        const testDataDir = path_1.default.join(screenDir, 'test-data');
-        // Find all feature files in the screen's features directory
-        const featureFiles = glob_1.glob.sync('**/*.feature', {
-            cwd: featuresDir,
-            absolute: true,
-        });
-        if (featureFiles.length === 0) {
-            throw new Error(`No feature files found in ${featuresDir}`);
-        }
-        // Ensure directories exist
-        fs_1.default.mkdirSync(selectorsDir, { recursive: true });
-        fs_1.default.mkdirSync(testDataDir, { recursive: true });
-        const results = [];
-        // Process each feature file individually
-        for (const featureFile of featureFiles) {
-            const filename = path_1.default.basename(featureFile, '.feature');
-            const content = fs_1.default.readFileSync(featureFile, 'utf-8');
-            // Extract feature path from Gherkin metadata
-            const featurePath = this.extractFeaturePath(content);
-            // Extract elements and data refs from this file
-            const elements = this.extractElements(content, featurePath);
-            const dataRefs = this.extractDataRefs(content);
-            // Build scaffolds from this file
-            const selectorScaffold = this.buildScaffold(elements);
-            const testDataScaffold = this.buildTestData(dataRefs);
-            // Enrich scaffold with live-scan data if available
-            const liveScanPath = path_1.default.join(selectorsDir, `${filename}.live-scan.yaml`);
-            const liveScanEnriched = this.enrichWithLiveScan(selectorScaffold, liveScanPath);
-            // Check if files exist
-            const selectorsPath = path_1.default.join(selectorsDir, `${filename}.yaml`);
-            const selectorsOverridePath = path_1.default.join(selectorsDir, `${filename}.override.yaml`);
-            const selectorsExists = fs_1.default.existsSync(selectorsPath);
-            const testDataPath = path_1.default.join(testDataDir, `${filename}.yaml`);
-            const testDataOverridePath = path_1.default.join(testDataDir, `${filename}.override.yaml`);
-            const testDataExists = fs_1.default.existsSync(testDataPath);
-            // Write selectors YAML (BASE ONLY - never touch override files)
-            if (!selectorsExists || forceOverwrite) {
-                this.writeSelectorsYaml(liveScanEnriched, selectorsPath, filename);
-            }
-            // Override file is NEVER touched by map command
-            // Write test-data YAML — always smart-merge regardless of --force:
-            // • existing keys keep their current value
-            // • new keys from features are added (empty string)
-            // • keys no longer referenced in features are removed
-            if (testDataExists) {
-                const existingRaw = yaml_1.default.parse(fs_1.default.readFileSync(testDataPath, 'utf-8')) || {};
-                const merged = this.mergeTestData(existingRaw, testDataScaffold);
-                this.writeTestDataYaml(merged, testDataPath, filename);
-            }
-            else {
-                this.writeTestDataYaml(testDataScaffold, testDataPath, filename);
-            }
-            // Override file is NEVER touched by map command
-            results.push({
-                featureFile: filename,
-                selectorsPath,
-                testDataPath,
-                elementCount: Object.keys(liveScanEnriched).length,
-                dataRefCount: dataRefs.length,
-                selectorsSkipped: selectorsExists && !forceOverwrite,
-                testDataMerged: testDataExists,
-            });
-        }
-        return results;
-    }
-    /**
-     * Extract data references {{...}} from Gherkin content
-     */
-    extractDataRefs(content) {
-        const dataRefs = [];
-        const lines = content.split('\n');
-        const seen = new Set();
-        // Regex to match data refs {{...}}
-        const dataRefRegex = /\{\{([^}]+)\}\}/g;
-        for (const line of lines) {
-            const trimmedLine = line.trim();
-            // Skip comments and empty lines
-            if (trimmedLine.startsWith('#') || !trimmedLine) {
-                continue;
-            }
-            let match;
-            while ((match = dataRefRegex.exec(trimmedLine)) !== null) {
-                const rawRef = match[1].trim();
-                // Skip duplicates
-                if (seen.has(rawRef)) {
-                    continue;
-                }
-                seen.add(rawRef);
-                dataRefs.push({
-                    rawRef,
-                    lineText: trimmedLine,
-                });
-            }
-        }
-        return dataRefs;
-    }
-    /**
-     * Build test data structure from data refs
-     * Supports nested structure: "valid.login_password" -> { valid: { login_password: '' } }
-     */
-    buildTestData(dataRefs) {
-        const result = {};
-        for (const dataRef of dataRefs) {
-            const parts = dataRef.rawRef.split('.');
-            if (parts.length === 1) {
-                // Simple variable: "valid_login_email" -> { valid_login_email: '' }
-                result[parts[0]] = '';
-            }
-            else {
-                // Nested variable: "valid.login_password" -> { valid: { login_password: '' } }
-                let current = result;
-                for (let i = 0; i < parts.length - 1; i++) {
-                    const part = parts[i];
-                    if (!current[part] || typeof current[part] === 'string') {
-                        current[part] = {};
-                    }
-                    current = current[part];
-                }
-                current[parts[parts.length - 1]] = '';
-            }
-        }
-        return result;
-    }
-    /**
-     * Write selectors YAML file
-     */
-    writeSelectorsYaml(scaffold, outputPath, screenName) {
-        const getDisplayValue = (e) => e.name || e.value;
-        // Deduplicate display values for header comment
-        const displayValues = [...new Set(Object.values(scaffold).map(e => `[${getDisplayValue(e)}]`))];
-        const header = `# ${this.capitalizeFirst(screenName)} Screen Selectors (Auto-generated)
-# ⚠️  AUTO-GENERATED - Do not edit directly
-# To override values, edit ${screenName}.override.yaml
-# Manual edits to this file will be lost on regeneration
-#
-# Reference in features: ${displayValues.join(', ')}
-
-`;
-        const yamlContent = yaml_1.default.stringify(scaffold, {
-            indent: 2,
-            lineWidth: 100,
-            defaultKeyType: 'PLAIN',
-            defaultStringType: 'QUOTE_SINGLE',
-        });
-        fs_1.default.writeFileSync(outputPath, header + yamlContent, 'utf-8');
-    }
-    /**
-     * Smart-merge test-data objects:
-     * - Keys present in both: keep the existing value (user may have filled it in)
-     * - Keys only in fresh (new refs in features): add with empty value
-     * - Keys only in existing (removed from features): drop them
-     */
-    mergeTestData(existing, fresh) {
-        const merged = {};
-        for (const key of Object.keys(fresh)) {
-            if (key in existing) {
-                const existingVal = existing[key];
-                const freshVal = fresh[key];
-                if (typeof freshVal === 'object' && typeof existingVal === 'object') {
-                    // Both are nested — recurse
-                    merged[key] = this.mergeTestData(existingVal, freshVal);
-                }
-                else {
-                    // Keep the existing (user-supplied) value
-                    merged[key] = existingVal;
-                }
-            }
-            else {
-                // New key — add with the scaffold default (empty string or nested object)
-                merged[key] = fresh[key];
-            }
-            // Keys present in existing but absent from fresh are intentionally dropped (no longer referenced)
-        }
-        return merged;
-    }
-    /**
-     * Write test-data YAML file
-     */
-    writeTestDataYaml(testData, outputPath, screenName) {
-        const header = `# ${this.capitalizeFirst(screenName)} Screen Test Data
-# Managed by: sungen map (smart-merge)
-# • New {{variable}} refs are added automatically (empty value)
-# • Removed refs are dropped on the next sungen map run
-# • Your existing values are never overwritten
-# To fix a value permanently, copy the key to ${screenName}.override.yaml
-#
-# Reference in features using {{variable}} syntax
-
-`;
-        const yamlContent = yaml_1.default.stringify(testData, {
-            indent: 2,
-            lineWidth: 100,
-            defaultKeyType: 'PLAIN',
-            defaultStringType: 'QUOTE_SINGLE',
-        });
-        fs_1.default.writeFileSync(outputPath, header + yamlContent, 'utf-8');
-    }
-}
-exports.ScaffoldGenerator = ScaffoldGenerator;
-//# sourceMappingURL=index.js.map