@cqa-lib/cqa-ui 1.1.235 → 1.1.237

package/esm2020/lib/step-builder/template-variables-form/template-variables-form.component.mjs

@@ -1,12 +1,11 @@
 import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy } from '@angular/core';
 import { FormControl, FormArray } from '@angular/forms';
 import * as i0 from "@angular/core";
-import * as i1 from "@angular/material/slide-toggle";
-import * as i2 from "../../dynamic-select/dynamic-select-field.component";
-import * as i3 from "../../custom-input/custom-input.component";
+import * as i1 from "../../custom-input/custom-input.component";
+import * as i2 from "@angular/material/slide-toggle";
+import * as i3 from "../../dynamic-select/dynamic-select-field.component";
 import * as i4 from "../../test-case-details/element-popup/element-form/element-form.component";
-import * as i5 from "../../button/button.component";
-import * as i6 from "@angular/common";
+import * as i5 from "@angular/common";
 export class TemplateVariablesFormComponent {
     constructor(cdr) {
         this.cdr = cdr;
@@ -23,6 +22,18 @@ export class TemplateVariablesFormComponent {
         this.hasMoreScreenNames = false;
         /** True while parent is loading screen names (search or load more) */
         this.isLoadingScreenNames = false;
+        /** Test data profiles for parameter dropdown (from API) - raw TestData objects */
+        this.parameterOptions = []; // TestData[] - using any to avoid circular dependency
+        /** Whether more parameters are available for infinite scroll */
+        this.hasMoreParameters = false;
+        /** True while parent is loading parameters (search or load more) */
+        this.isLoadingParameters = false;
+        /** Environment options for environment parameter dropdown (from API) */
+        this.environmentOptions = [];
+        /** Whether more environments are available for infinite scroll */
+        this.hasMoreEnvironments = false;
+        /** True while parent is loading environments (search or load more) */
+        this.isLoadingEnvironments = false;
         this.variableValueChange = new EventEmitter();
         this.variableBooleanChange = new EventEmitter();
         this.metadataChange = new EventEmitter();
@@ -33,16 +44,28 @@ export class TemplateVariablesFormComponent {
         this.searchScreenName = new EventEmitter(); // Emit when user searches screen names
         this.loadMoreScreenNames = new EventEmitter(); // Emit when user scrolls to load more screen names
         this.createScreenNameRequest = new EventEmitter(); // Emit when user requests to create a new screen name
+        this.searchParameters = new EventEmitter(); // Emit when user searches for parameters
+        this.loadMoreParameters = new EventEmitter(); // Emit when user scrolls to load more parameters
+        this.searchEnvironments = new EventEmitter(); // Emit when user searches for environments
+        this.loadMoreEnvironments = new EventEmitter(); // Emit when user scrolls to load more environments
         this.cancelElementForm = new EventEmitter(); // Emit when element form is cancelled
         this.elementFormVisibilityChange = new EventEmitter(); // Emit when element form visibility changes
         // Cache for select configs to avoid recalculating on every change detection
         this.selectConfigCache = new Map();
         // Cache for data type select configs
         this.dataTypeSelectConfigCache = new Map();
-        // Store data types for test-data variables
-        this.variableDataTypes = new Map();
-        // Store raw values (without formatting) for test-data variables
-        this.variableRawValues = new Map();
+        // Cache for parameter select configs
+        this.parameterSelectConfigCache = new Map();
+        // Cache for environment select configs
+        this.environmentSelectConfigCache = new Map();
+        // Cache for environment parameter select configs
+        this.environmentParameterSelectConfigCache = new Map();
+        // Cache for test data profile select configs (first dropdown for parameters)
+        this.testDataProfileSelectConfigCache = new Map();
+        // Cache for data set select configs (second dropdown for parameters - shows data sets from selected profile)
+        this.dataSetSelectConfigCache = new Map();
+        // Cache for parameter select configs for a specific data set (third dropdown for parameters)
+        this.parameterForDataSetSelectConfigCache = new Map();
         // Cache for computed properties
         this.needsDataTypeDropdownCache = new Map();
         this.shouldShowDropdownCache = new Map();
@@ -58,35 +81,79 @@ export class TemplateVariablesFormComponent {
     onCreateElement(payload) {
         console.log('onCreateElement', payload);
         this.createElement.emit(payload);
-        this.createElementVisible = false;
         this.elementFormVisibilityChange.emit(false);
         this.cdr.markForCheck();
     }
     onCancelElementForm() {
-        this.createElementVisible = false;
         this.elementFormVisibilityChange.emit(false);
         this.cancelElementForm.emit();
         this.cdr.markForCheck();
     }
-    onShowElementForm() {
-        this.createElementVisible = true;
-        this.elementFormVisibilityChange.emit(true);
-        this.cdr.markForCheck();
-    }
     ngOnChanges(changes) {
         if (changes['templateVariables'] || changes['variablesForm'] || changes['elementOptions'] ||
-            changes['hasMoreElements'] || changes['isLoadingElements']) {
+            changes['hasMoreElements'] || changes['isLoadingElements'] ||
+            changes['parameterOptions'] || changes['hasMoreParameters'] || changes['isLoadingParameters'] ||
+            changes['environmentOptions'] || changes['hasMoreEnvironments'] || changes['isLoadingEnvironments'] ||
+            changes['defaultTestDataProfileId'] || changes['defaultTestDataStartIndex']) {
             // Clear all caches when inputs change
             this.selectConfigCache.clear();
             this.dataTypeSelectConfigCache.clear();
+            this.parameterSelectConfigCache.clear();
+            this.environmentSelectConfigCache.clear();
+            this.environmentParameterSelectConfigCache.clear();
+            this.testDataProfileSelectConfigCache.clear();
+            this.dataSetSelectConfigCache.clear();
+            this.parameterForDataSetSelectConfigCache.clear();
             this.needsDataTypeDropdownCache.clear();
             this.shouldShowDropdownCache.clear();
             // Initialize data types and raw values for test-data variables
-            if (changes['templateVariables'] && this.templateVariables) {
+            // Also re-initialize if default values or parameterOptions change (to set default selections)
+            if ((changes['templateVariables'] || changes['defaultTestDataProfileId'] || changes['defaultTestDataStartIndex'] || changes['parameterOptions']) && this.templateVariables) {
                 this.initializeTestDataVariables();
             }
             // Pre-compute all configs to avoid calling methods in template
             this.precomputeConfigs();
+            // If environment options changed and we have selected environments, refresh parameter configs
+            if (changes['environmentOptions']) {
+                this.templateVariables.forEach((variable, index) => {
+                    if (this.isEnvironmentType(variable) && variable.selectedEnvironment) {
+                        // Clear and recompute environment parameter config
+                        this.environmentParameterSelectConfigCache.delete(`${variable.name}_envParam`);
+                        this.getEnvironmentParameterSelectConfig(variable, index);
+                    }
+                });
+            }
+            // If parameter options changed and we have default values, try to initialize them
+            if (changes['parameterOptions'] && this.defaultTestDataProfileId && this.defaultTestDataStartIndex != null && this.parameterOptions.length > 0) {
+                // Re-initialize to set default values now that parameterOptions are available
+                console.log('Re-initializing with default values after parameterOptions loaded');
+                this.initializeTestDataVariables();
+                // Force change detection after initialization
+                this.cdr.markForCheck();
+            }
+            // If parameter options changed and we have selected test data profiles, refresh configs
+            if (changes['parameterOptions'] || changes['defaultTestDataProfileId'] || changes['defaultTestDataStartIndex']) {
+                // Clear test data profile select config cache since profiles list may have changed
+                this.testDataProfileSelectConfigCache.clear();
+                this.templateVariables.forEach((variable, index) => {
+                    if (this.isParameterType(variable)) {
+                        // Recompute test data profile config
+                        this.getTestDataProfileSelectConfig(variable, index);
+                        // If a profile is already selected, recompute data set config
+                        if (variable.selectedTestDataProfile) {
+                            this.getDataSetSelectConfig(variable, index);
+                            // If a data set is already selected, recompute parameter config
+                            if (variable.selectedDataSet) {
+                                // Clear and recompute parameter config for the selected data set
+                                // Use profile ID if available for cache key
+                                const profileIdentifier = variable.selectedTestDataProfileId ? String(variable.selectedTestDataProfileId) : variable.selectedTestDataProfile;
+                                this.parameterForDataSetSelectConfigCache.delete(`${variable.name}_paramForDataSet_${profileIdentifier}_${variable.selectedDataSet}`);
+                                this.getParameterSelectConfig(variable, index);
+                            }
+                        }
+                    }
+                });
+            }
             // Mark for check since we're using OnPush
             this.cdr.markForCheck();
         }
@@ -95,8 +162,9 @@ export class TemplateVariablesFormComponent {
         this.templateVariables.forEach((variable, index) => {
             if (this.needsDataTypeDropdown(variable)) {
                 const { dataType, rawValue } = this.parseTestDataValue(variable.value || '');
-                this.variableDataTypes.set(variable.name, dataType);
-                this.variableRawValues.set(variable.name, rawValue);
+                // Set properties directly on the variable object
+                variable.dataType = dataType;
+                variable.rawValue = rawValue;
                 // Ensure form control exists for data type in the FormArray
                 const variableGroup = this.getVariableFormGroup(variable.name);
                 if (variableGroup) {
@@ -106,6 +174,162 @@ export class TemplateVariablesFormComponent {
                     else {
                         variableGroup.get('dataType')?.setValue(dataType, { emitEvent: false });
                     }
+                    // For parameter type, parse the value to extract test data profile and parameter
+                    if (dataType === 'parameter') {
+                        // Check if default test data profile and data set are provided from test case
+                        // Only proceed if parameterOptions are loaded
+                        if (this.defaultTestDataProfileId && this.defaultTestDataStartIndex != null && this.parameterOptions.length > 0) {
+                            // Find the test data profile by ID
+                            const defaultProfile = this.parameterOptions.find((testData) => testData.id === this.defaultTestDataProfileId);
+                            if (defaultProfile && defaultProfile.data && defaultProfile.data.length > this.defaultTestDataStartIndex) {
+                                const defaultDataSet = defaultProfile.data[this.defaultTestDataStartIndex];
+                                const profileName = defaultProfile.name || defaultProfile.testDataName;
+                                const dataSetName = defaultDataSet.name;
+                                // Set variable properties - this ensures hasSelectedTestDataProfile() and hasSelectedDataSet() return true
+                                variable.selectedTestDataProfile = profileName;
+                                variable.selectedTestDataProfileId = defaultProfile.id;
+                                variable.selectedDataSet = dataSetName;
+                                // Set form controls with the actual values so dropdowns display selected options
+                                if (!variableGroup.get('selectedTestDataProfile')) {
+                                    variableGroup.addControl('selectedTestDataProfile', new FormControl(profileName));
+                                }
+                                else {
+                                    variableGroup.get('selectedTestDataProfile')?.setValue(profileName, { emitEvent: false });
+                                }
+                                if (!variableGroup.get('selectedDataSet')) {
+                                    variableGroup.addControl('selectedDataSet', new FormControl(dataSetName));
+                                }
+                                else {
+                                    variableGroup.get('selectedDataSet')?.setValue(dataSetName, { emitEvent: false });
+                                }
+                                // Don't set parameter value yet - user will select it
+                                if (variableGroup.get('value')) {
+                                    variableGroup.get('value')?.setValue('', { emitEvent: false });
+                                }
+                                // Clear caches to force recomputation of configs with new values
+                                // Clear all cache entries for this variable to ensure fresh configs
+                                this.testDataProfileSelectConfigCache.delete(`${variable.name}_testDataProfile`);
+                                // Clear data set cache - need to clear all possible keys since we don't know the exact format
+                                const dataSetKeysToDelete = [];
+                                this.dataSetSelectConfigCache.forEach((value, key) => {
+                                    if (key.startsWith(`${variable.name}_dataSet`)) {
+                                        dataSetKeysToDelete.push(key);
+                                    }
+                                });
+                                dataSetKeysToDelete.forEach(key => this.dataSetSelectConfigCache.delete(key));
+                                // Clear parameter cache - need to clear all possible keys
+                                const paramKeysToDelete = [];
+                                this.parameterForDataSetSelectConfigCache.forEach((value, key) => {
+                                    if (key.startsWith(`${variable.name}_paramForDataSet`)) {
+                                        paramKeysToDelete.push(key);
+                                    }
+                                });
+                                paramKeysToDelete.forEach(key => this.parameterForDataSetSelectConfigCache.delete(key));
+                                console.log('Default test data initialized:', {
+                                    variableName: variable.name,
+                                    profileName,
+                                    profileId: defaultProfile.id,
+                                    dataSetName,
+                                    hasSelectedProfile: !!variable.selectedTestDataProfile,
+                                    hasSelectedDataSet: !!variable.selectedDataSet
+                                });
+                            }
+                            else {
+                                console.warn('Default test data profile not found or invalid:', {
+                                    defaultTestDataProfileId: this.defaultTestDataProfileId,
+                                    defaultTestDataStartIndex: this.defaultTestDataStartIndex,
+                                    parameterOptionsLength: this.parameterOptions.length,
+                                    foundProfile: !!defaultProfile
+                                });
+                            }
+                        }
+                        else {
+                            // No default values - use existing logic to find from parameter value
+                            const paramName = rawValue;
+                            if (paramName) {
+                                // Find the test data profile and data set that contains this parameter
+                                // Search through all test data profiles and their data sets
+                                let foundProfile = null;
+                                let foundDataSet = null;
+                                for (const testDataProfile of this.parameterOptions) {
+                                    if (testDataProfile.data && testDataProfile.data.length > 0) {
+                                        // Search through all data sets in this profile
+                                        for (const dataSet of testDataProfile.data) {
+                                            if (dataSet && dataSet.data && dataSet.data.hasOwnProperty(paramName)) {
+                                                foundProfile = testDataProfile;
+                                                foundDataSet = dataSet;
+                                                break;
+                                            }
+                                        }
+                                        if (foundProfile)
+                                            break;
+                                    }
+                                }
+                                if (foundProfile && foundDataSet) {
+                                    const profileName = foundProfile.name || foundProfile.testDataName;
+                                    const dataSetName = foundDataSet.name;
+                                    variable.selectedTestDataProfile = profileName;
+                                    variable.selectedTestDataProfileId = foundProfile.id;
+                                    variable.selectedDataSet = dataSetName;
+                                    // Set form controls
+                                    if (!variableGroup.get('selectedTestDataProfile')) {
+                                        variableGroup.addControl('selectedTestDataProfile', new FormControl(profileName));
+                                    }
+                                    else {
+                                        variableGroup.get('selectedTestDataProfile')?.setValue(profileName, { emitEvent: false });
+                                    }
+                                    if (!variableGroup.get('selectedDataSet')) {
+                                        variableGroup.addControl('selectedDataSet', new FormControl(dataSetName));
+                                    }
+                                    else {
+                                        variableGroup.get('selectedDataSet')?.setValue(dataSetName, { emitEvent: false });
+                                    }
+                                    // Set form control to param name (for dropdown display)
+                                    if (variableGroup.get('value')) {
+                                        variableGroup.get('value')?.setValue(paramName, { emitEvent: false });
+                                    }
+                                    // Ensure variable.value is formatted correctly as @|paramName|
+                                    variable.value = this.formatTestDataValue(paramName, 'parameter');
+                                }
+                                else {
+                                    // If parameter not found, format the raw value if it's a parameter type
+                                    if (variableGroup.get('value')) {
+                                        variableGroup.get('value')?.setValue(rawValue, { emitEvent: false });
+                                    }
+                                    // Ensure variable.value is formatted correctly
+                                    variable.value = this.formatTestDataValue(rawValue, dataType);
+                                }
+                            }
+                        }
+                    }
+                    // For environment type, parse the value to extract environment and parameter
+                    if (dataType === 'environment') {
+                        // Environment values are in format *|parameterName|
+                        // We need to find which environment this parameter belongs to
+                        const paramName = rawValue;
+                        if (paramName) {
+                            // Find the environment that contains this parameter
+                            const envOption = this.environmentOptions.find(env => env.name === paramName);
+                            if (envOption) {
+                                variable.selectedEnvironment = envOption.environment;
+                                // Extract and store environment ID
+                                const idMatch = envOption.id.match(/env-(\d+)-/);
+                                if (idMatch && idMatch[1]) {
+                                    variable.selectedEnvironmentId = parseInt(idMatch[1], 10);
+                                }
+                                // Set form controls
+                                if (!variableGroup.get('selectedEnvironment')) {
+                                    variableGroup.addControl('selectedEnvironment', new FormControl(envOption.environment));
+                                }
+                                else {
+                                    variableGroup.get('selectedEnvironment')?.setValue(envOption.environment, { emitEvent: false });
+                                }
+                                if (variableGroup.get('value')) {
+                                    variableGroup.get('value')?.setValue(`*|${paramName}|`, { emitEvent: false });
+                                }
+                            }
+                        }
+                    }
                 }
             }
         });
@@ -137,6 +361,26 @@ export class TemplateVariablesFormComponent {
             // Pre-compute data type select configs
             if (this.needsDataTypeDropdown(variable)) {
                 this.getDataTypeSelectConfig(variable, index);
+                // Pre-compute parameter and environment select configs if needed
+                const dataType = variable.dataType || 'plain-text';
+                if (dataType === 'parameter') {
+                    this.getTestDataProfileSelectConfig(variable, index);
+                    // Pre-compute data set config if test data profile is already selected
+                    if (variable.selectedTestDataProfile) {
+                        this.getDataSetSelectConfig(variable, index);
+                        // Pre-compute parameter config if data set is already selected
+                        if (variable.selectedDataSet) {
+                            this.getParameterSelectConfig(variable, index);
+                        }
+                    }
+                }
+                else if (dataType === 'environment') {
+                    this.getEnvironmentSelectConfig(variable, index);
+                    // Pre-compute environment parameter config if environment is already selected
+                    if (variable.selectedEnvironment) {
+                        this.getEnvironmentParameterSelectConfig(variable, index);
+                    }
+                }
             }
         });
     }
@@ -250,8 +494,8 @@ export class TemplateVariablesFormComponent {
         // If this is a test-data variable, parse and update raw value and data type
         if (this.needsDataTypeDropdown(variable)) {
             const { dataType, rawValue } = this.parseTestDataValue(value || '');
-            this.variableDataTypes.set(variableName, dataType);
-            this.variableRawValues.set(variableName, rawValue);
+            variable.dataType = dataType;
+            variable.rawValue = rawValue;
             // Update data type form control in FormArray
             const variableGroup = this.getVariableFormGroup(variableName);
             if (variableGroup && variableGroup.get('dataType')) {
@@ -302,7 +546,7 @@ export class TemplateVariablesFormComponent {
             return this.needsDataTypeDropdownCache.get(variable.name);
         }
         const dataKey = variable.dataKey?.toLowerCase() || '';
-        const result = dataKey === 'test-data' || dataKey === 'source_value' || dataKey === 'target_value';
+        const result = dataKey === 'test_data' || dataKey === 'source_value' || dataKey === 'target_value';
         this.needsDataTypeDropdownCache.set(variable.name, result);
         return result;
     }
@@ -319,7 +563,7 @@ export class TemplateVariablesFormComponent {
         // Ensure form control exists in FormArray
         const variableGroup = this.getVariableFormGroup(variable.name);
         if (variableGroup && !variableGroup.get('dataType')) {
-            const currentDataType = this.variableDataTypes.get(variable.name) || 'plain-text';
+            const currentDataType = variable.dataType || 'plain-text';
             variableGroup.addControl('dataType', new FormControl(currentDataType));
         }
         const config = {
@@ -336,12 +580,10 @@ export class TemplateVariablesFormComponent {
         return config;
     }
     getCurrentDataType(variable) {
-        // Simple getter - already cached in Map, no computation needed
-        return this.variableDataTypes.get(variable.name) || 'plain-text';
+        return variable.dataType || 'plain-text';
     }
     getRawValue(variable) {
-        // Simple getter - already cached in Map, no computation needed
-        return this.variableRawValues.get(variable.name) || '';
+        return variable.rawValue || '';
     }
     /**
      * Check if selector variable is available in templateVariables
@@ -355,8 +597,8 @@ export class TemplateVariablesFormComponent {
     get parameterVariableAvailable() {
         return this.templateVariables.some(v => {
             const dataKey = v.dataKey?.toLowerCase() || '';
-            if (dataKey === 'test-data' || dataKey === 'source_value' || dataKey === 'target_value') {
-                const dataType = this.variableDataTypes.get(v.name) || 'plain-text';
+            if (dataKey === 'test_data' || dataKey === 'source_value' || dataKey === 'target_value') {
+                const dataType = v.dataType || 'plain-text';
                 return dataType === 'parameter';
             }
             return false;
@@ -367,35 +609,140 @@ export class TemplateVariablesFormComponent {
      */
     get environmentVariableAvailable() {
         return this.templateVariables.some(v => {
-            const dataKey = v.name?.toLowerCase() || '';
-            if (dataKey === 'test-data' || dataKey === 'source_value' || dataKey === 'target_value') {
-                const dataType = this.variableDataTypes.get(v.name) || 'plain-text';
+            const dataKey = v.dataKey?.toLowerCase() || '';
+            if (dataKey === 'test_data' || dataKey === 'source_value' || dataKey === 'target_value') {
+                const dataType = v.dataType || 'plain-text';
                 return dataType === 'environment';
             }
             return false;
         });
     }
     onDataTypeChange(variableName, dataType) {
-        // Update stored data type
-        this.variableDataTypes.set(variableName, dataType);
+        // Find the variable
+        const variable = this.templateVariables.find(v => v.name === variableName);
+        if (!variable)
+            return;
+        // Update stored data type on the variable object
+        variable.dataType = dataType;
+        // Clear parameter and environment select config caches since data type changed
+        this.testDataProfileSelectConfigCache.delete(`${variableName}_testDataProfile`);
+        this.dataSetSelectConfigCache.delete(`${variableName}_dataSet`);
+        this.parameterForDataSetSelectConfigCache.delete(`${variableName}_paramForDataSet`);
+        this.environmentSelectConfigCache.delete(`${variableName}_environment`);
+        this.environmentParameterSelectConfigCache.delete(`${variableName}_envParam`);
+        // Clear selected test data profile and data set if switching away from parameter type
+        if (dataType !== 'parameter') {
+            variable.selectedTestDataProfile = undefined;
+            variable.selectedTestDataProfileId = undefined;
+            variable.selectedDataSet = undefined;
+        }
+        // Clear selected environment if switching away from environment type
+        if (dataType !== 'environment') {
+            variable.selectedEnvironment = undefined;
+            variable.selectedEnvironmentId = undefined;
+        }
         // Get current raw value
-        const rawValue = this.variableRawValues.get(variableName) || '';
+        const rawValue = variable.rawValue || '';
         // Format the value based on new data type
         const formattedValue = this.formatTestDataValue(rawValue, dataType);
-        // Update variable value
-        const variable = this.templateVariables.find(v => v.name === variableName);
-        if (variable) {
-            variable.value = formattedValue;
-        }
+        // Update variable value (always store formatted value in variable)
+        variable.value = formattedValue;
         // Update form control in FormArray
         const variableGroup = this.getVariableFormGroup(variableName);
-        if (variableGroup && variableGroup.get('value')) {
-            variableGroup.get('value')?.setValue(formattedValue, { emitEvent: false });
+        if (variableGroup) {
+            if (variableGroup.get('value')) {
+                // For parameter type, set form control to raw value so select can display it
+                if (dataType === 'parameter') {
+                    variableGroup.get('value')?.setValue(rawValue, { emitEvent: false });
+                }
+                else if (dataType === 'environment') {
+                    // For environment type, clear value and selectedEnvironment
+                    variableGroup.get('value')?.setValue('', { emitEvent: false });
+                    if (variableGroup.get('selectedEnvironment')) {
+                        variableGroup.get('selectedEnvironment')?.setValue('', { emitEvent: false });
+                    }
+                }
+                else {
+                    variableGroup.get('value')?.setValue(formattedValue, { emitEvent: false });
+                }
+            }
+            // Remove selectedEnvironment control if not environment type
+            if (dataType !== 'environment' && variableGroup.get('selectedEnvironment')) {
+                variableGroup.removeControl('selectedEnvironment');
+            }
+        }
+        // If switching to parameter type, check for default values and initialize them
+        if (dataType === 'parameter') {
+            const index = this.templateVariables.indexOf(variable);
+            // Check if default test data profile and data set are provided from test case
+            if (this.defaultTestDataProfileId && this.defaultTestDataStartIndex != null && this.parameterOptions.length > 0) {
+                // Find the test data profile by ID
+                const defaultProfile = this.parameterOptions.find((testData) => testData.id === this.defaultTestDataProfileId);
+                if (defaultProfile && defaultProfile.data && defaultProfile.data.length > this.defaultTestDataStartIndex) {
+                    const defaultDataSet = defaultProfile.data[this.defaultTestDataStartIndex];
+                    const profileName = defaultProfile.name || defaultProfile.testDataName;
+                    const dataSetName = defaultDataSet.name;
+                    // Set variable properties - this ensures hasSelectedTestDataProfile() and hasSelectedDataSet() return true
+                    variable.selectedTestDataProfile = profileName;
+                    variable.selectedTestDataProfileId = defaultProfile.id;
+                    variable.selectedDataSet = dataSetName;
+                    // Set form controls with the actual values so dropdowns display selected options
+                    if (variableGroup) {
+                        if (!variableGroup.get('selectedTestDataProfile')) {
+                            variableGroup.addControl('selectedTestDataProfile', new FormControl(profileName));
+                        }
+                        else {
+                            variableGroup.get('selectedTestDataProfile')?.setValue(profileName, { emitEvent: false });
+                        }
+                        if (!variableGroup.get('selectedDataSet')) {
+                            variableGroup.addControl('selectedDataSet', new FormControl(dataSetName));
+                        }
+                        else {
+                            variableGroup.get('selectedDataSet')?.setValue(dataSetName, { emitEvent: false });
+                        }
+                    }
+                    // Clear caches to force recomputation of configs with new values
+                    this.testDataProfileSelectConfigCache.delete(`${variableName}_testDataProfile`);
+                    const dataSetKeysToDelete = [];
+                    this.dataSetSelectConfigCache.forEach((value, key) => {
+                        if (key.startsWith(`${variableName}_dataSet`)) {
+                            dataSetKeysToDelete.push(key);
+                        }
+                    });
+                    dataSetKeysToDelete.forEach(key => this.dataSetSelectConfigCache.delete(key));
+                    const paramKeysToDelete = [];
+                    this.parameterForDataSetSelectConfigCache.forEach((value, key) => {
+                        if (key.startsWith(`${variableName}_paramForDataSet`)) {
+                            paramKeysToDelete.push(key);
+                        }
+                    });
+                    paramKeysToDelete.forEach(key => this.parameterForDataSetSelectConfigCache.delete(key));
+                }
+            }
+        }
+        // Pre-compute the new select config if needed
+        if (variable) {
+            const index = this.templateVariables.indexOf(variable);
+            if (dataType === 'parameter') {
+                // Pre-compute test data profile config
+                this.getTestDataProfileSelectConfig(variable, index);
+                // If a profile is already selected, pre-compute data set config
+                if (variable.selectedTestDataProfile) {
+                    this.getDataSetSelectConfig(variable, index);
+                    // If a data set is already selected, pre-compute parameter config
+                    if (variable.selectedDataSet) {
+                        this.getParameterSelectConfig(variable, index);
+                    }
+                }
+            }
+            else if (dataType === 'environment') {
+                this.getEnvironmentSelectConfig(variable, index);
+            }
         }
         // Mark for check since we're using OnPush
         this.cdr.markForCheck();
         console.log('onDataTypeChange', variableName, dataType, formattedValue);
-        // Emit the change event
+        // Emit the change event with formatted value
         this.variableValueChange.emit({ name: variableName, value: formattedValue });
     }
     onElementSearch(event) {
@@ -405,17 +752,18 @@ export class TemplateVariablesFormComponent {
         this.searchElements.emit(event.query);
     }
     onTestDataValueChange(variableName, rawValue) {
-        // Update stored raw value
-        this.variableRawValues.set(variableName, rawValue);
+        // Find the variable
+        const variable = this.templateVariables.find(v => v.name === variableName);
+        if (!variable)
+            return;
+        // Update stored raw value on the variable object
+        variable.rawValue = rawValue;
         // Get current data type
-        const dataType = this.variableDataTypes.get(variableName) || 'plain-text';
+        const dataType = variable.dataType || 'plain-text';
         // Format the value based on data type
         const formattedValue = this.formatTestDataValue(rawValue, dataType);
         // Update variable value
-        const variable = this.templateVariables.find(v => v.name === variableName);
-        if (variable) {
-            variable.value = formattedValue;
-        }
+        variable.value = formattedValue;
         // Update form control in FormArray
         const variableGroup = this.getVariableFormGroup(variableName);
         if (variableGroup && variableGroup.get('value')) {
@@ -426,12 +774,639 @@ export class TemplateVariablesFormComponent {
         // Emit the change event
         this.variableValueChange.emit({ name: variableName, value: formattedValue });
     }
+    /**
+     * Get unique test data profiles from parameter options (raw TestData objects)
+     */
+    getUniqueTestDataProfiles() {
+        const profileMap = new Map();
+        this.parameterOptions.forEach((testData) => {
+            // testData.name is the testDataName (profile name)
+            const profileName = testData.name || testData.testDataName;
+            if (profileName && !profileMap.has(profileName)) {
+                profileMap.set(profileName, {
+                    id: String(testData.id),
+                    name: profileName
+                });
+            }
+        });
+        const profiles = Array.from(profileMap.values());
+        return profiles;
+    }
+    /**
+     * Get data sets for a specific test data profile
+     * Returns all data sets from the profile's data array
+     */
+    getDataSetsForTestDataProfile(profileId) {
+        // Find the test data profile by id
+        const testDataProfile = this.parameterOptions.find((testData) => {
+            return testData.id === Number(profileId);
+        });
+        if (!testDataProfile || !testDataProfile.data || testDataProfile.data.length === 0) {
+            return [];
+        }
+        // Return all data sets from the profile
+        return testDataProfile.data.map((dataSet) => ({
+            id: dataSet.name,
+            name: dataSet.name
+        }));
+    }
+    /**
+     * Get parameters for a specific data set in a test data profile
+     * Extracts parameter names from the selected data set's data object
+     */
+    getParametersForDataSet(profileIdOrName, dataSetName) {
+        // Find the test data profile by id or name
+        const testDataProfile = this.parameterOptions.find((testData) => {
+            // Try to match by ID first (if profileIdOrName is a number)
+            const idMatch = !isNaN(Number(profileIdOrName)) && testData.id === Number(profileIdOrName);
+            // Otherwise try to match by name
+            const nameMatch = (testData.name || testData.testDataName) === profileIdOrName;
+            return idMatch || nameMatch;
+        });
+        if (!testDataProfile || !testDataProfile.data || testDataProfile.data.length === 0) {
+            return [];
+        }
+        // Find the specific data set by name
+        const dataSet = testDataProfile.data.find((ds) => ds.name === dataSetName);
+        if (!dataSet || !dataSet.data) {
+            return [];
+        }
+        // Get all parameter keys from the data set's data object
+        const parameterNames = Object.keys(dataSet.data);
+        return parameterNames.map(paramName => ({
+            id: paramName,
+            name: paramName,
+        }));
+    }
+    /**
+     * Get select config for test data profile dropdown (first dropdown for parameters)
+     */
+    getTestDataProfileSelectConfig(variable, index) {
+        const cacheKey = `${variable.name}_testDataProfile`;
+        // Get unique test data profiles
+        const profiles = this.getUniqueTestDataProfiles();
+        // Create options with profile name and ID (display name with ID)
+        const optionsArray = profiles.map(profile => {
+            // Find the test data profile to get the ID
+            const testDataProfile = this.parameterOptions.find((testData) => {
+                const name = testData.name || testData.testDataName;
+                return name === profile.name;
+            });
+            const profileId = testDataProfile?.id || profile.id;
+            return {
+                id: String(profileId),
+                value: profile.name,
+                name: `${profile.name}`,
+                label: `${profile.name}`
+            };
+        });
+        // Ensure form control exists for test data profile selection and update it
+        const variableGroup = this.getVariableFormGroup(variable.name);
+        if (variableGroup) {
+            if (!variableGroup.get('selectedTestDataProfile')) {
+                // Use profile ID if available, otherwise use profile name
+                const currentValue = variable.selectedTestDataProfileId
+                    ? String(variable.selectedTestDataProfileId)
+                    : (variable.selectedTestDataProfile || '');
+                variableGroup.addControl('selectedTestDataProfile', new FormControl(currentValue));
+            }
+            // Always update form control value if variable has a selected profile
+            // This ensures the value is set even if config was cached
+            // Use profile ID (which matches opt.id) instead of profile name (which matches opt.value)
+            if (variable.selectedTestDataProfileId != null) {
+                const profileIdString = String(variable.selectedTestDataProfileId);
+                // Verify the profile ID exists in options before setting
+                const profileExists = optionsArray.some(opt => opt.id === profileIdString);
+                if (profileExists) {
+                    const currentControlValue = variableGroup.get('selectedTestDataProfile')?.value;
+                    if (currentControlValue !== profileIdString) {
+                        variableGroup.get('selectedTestDataProfile')?.setValue(profileIdString, { emitEvent: false });
+                        console.log('Updated test data profile form control with ID:', {
+                            variableName: variable.name,
+                            profileId: profileIdString,
+                            profileName: variable.selectedTestDataProfile,
+                            optionsCount: optionsArray.length
+                        });
+                    }
+                }
+                else {
+                    console.warn('Selected test data profile ID not found in options:', {
+                        variableName: variable.name,
+                        profileId: profileIdString,
+                        profileName: variable.selectedTestDataProfile,
+                        availableOptionIds: optionsArray.map(opt => opt.id)
+                    });
+                }
+            }
+            else if (variable.selectedTestDataProfile) {
+                // Fallback: if we only have the profile name, find the matching option and use its ID
+                const matchingOption = optionsArray.find(opt => opt.value === variable.selectedTestDataProfile);
+                if (matchingOption) {
+                    const currentControlValue = variableGroup.get('selectedTestDataProfile')?.value;
+                    if (currentControlValue !== matchingOption.id) {
+                        variableGroup.get('selectedTestDataProfile')?.setValue(matchingOption.id, { emitEvent: false });
+                        // Also update the variable's profile ID for consistency
+                        variable.selectedTestDataProfileId = Number(matchingOption.id);
+                        console.log('Updated test data profile form control with ID from name:', {
+                            variableName: variable.name,
+                            profileId: matchingOption.id,
+                            profileName: variable.selectedTestDataProfile
+                        });
+                    }
+                }
+            }
+        }
+        // Check cache after ensuring form control is set
+        if (this.testDataProfileSelectConfigCache.has(cacheKey)) {
+            return this.testDataProfileSelectConfigCache.get(cacheKey);
+        }
+        // Check if default values are set - if so, disable the dropdown
+        const isDisabled = this.hasDefaultTestDataSelection();
+        const config = {
+            key: 'selectedTestDataProfile',
+            placeholder: 'Select Test Data Profile',
+            multiple: false,
+            searchable: false,
+            options: optionsArray,
+            hasMore: false,
+            isLoading: false,
+            disabled: isDisabled,
+            onChange: (value) => {
+                // Value is the profile ID (string) from the mat-option
+                // Find the test data profile by ID to get the name
+                const testDataProfile = this.parameterOptions.find((testData) => {
+                    return testData.id === Number(value);
+                });
+                // Store both ID and name
+                variable.selectedTestDataProfileId = testDataProfile?.id;
+                variable.selectedTestDataProfile = testDataProfile?.name || testDataProfile?.testDataName || '';
+                // Clear data set and parameter selection when profile changes
+                variable.selectedDataSet = undefined;
+                variable.rawValue = '';
+                variable.value = '';
+                // Update form controls
+                const varGroup = this.getVariableFormGroup(variable.name);
+                if (varGroup) {
+                    if (varGroup.get('selectedTestDataProfile')) {
+                        varGroup.get('selectedTestDataProfile')?.setValue(value, { emitEvent: false });
+                    }
+                    if (varGroup.get('selectedDataSet')) {
+                        varGroup.get('selectedDataSet')?.setValue('', { emitEvent: false });
+                    }
+                    if (varGroup.get('value')) {
+                        varGroup.get('value')?.setValue('', { emitEvent: false });
+                    }
+                }
+                // Clear caches for data set and parameter select configs since profile changed
+                // Clear all data set and parameter configs for this variable
+                const dataSetKeysToDelete = [];
+                this.dataSetSelectConfigCache.forEach((value, key) => {
+                    if (key.startsWith(`${variable.name}_dataSet`)) {
+                        dataSetKeysToDelete.push(key);
+                    }
+                });
+                dataSetKeysToDelete.forEach(key => this.dataSetSelectConfigCache.delete(key));
+                const paramKeysToDelete = [];
+                this.parameterForDataSetSelectConfigCache.forEach((value, key) => {
+                    if (key.startsWith(`${variable.name}_paramForDataSet`)) {
+                        paramKeysToDelete.push(key);
+                    }
+                });
+                paramKeysToDelete.forEach(key => this.parameterForDataSetSelectConfigCache.delete(key));
+                // Clear selected data set when profile changes
+                variable.selectedDataSet = undefined;
+                // Mark for check
+                this.cdr.markForCheck();
+            }
+        };
+        this.testDataProfileSelectConfigCache.set(cacheKey, config);
+        return config;
+    }
+    /**
+     * Get select config for data set dropdown (second dropdown for parameters - shows data sets from selected profile)
+     */
+    getDataSetSelectConfig(variable, index) {
+        // Get selected test data profile ID (preferred) or name (fallback)
+        const selectedProfileId = variable.selectedTestDataProfileId;
+        const selectedProfile = variable.selectedTestDataProfile;
+        if (!selectedProfileId && !selectedProfile) {
+            // Return empty config if no profile is selected
+            return {
+                key: 'selectedDataSet',
+                placeholder: 'Select Test Data Profile first',
+                multiple: false,
+                searchable: false,
+                options: []
+            };
+        }
+        // Use profile ID if available, otherwise find ID from profile name
+        let profileIdToUse;
+        if (selectedProfileId) {
+            profileIdToUse = String(selectedProfileId);
+        }
+        else {
+            // Find the profile ID from the profile name
+            const testDataProfile = this.parameterOptions.find((testData) => {
+                const name = testData.name || testData.testDataName;
+                return name === selectedProfile;
+            });
+            profileIdToUse = testDataProfile?.id ? String(testDataProfile.id) : '';
+        }
+        // Use profile ID for cache key if available, otherwise use profile name
+        const cacheKey = `${variable.name}_dataSet_${profileIdToUse || selectedProfile || ''}`;
+        if (this.dataSetSelectConfigCache.has(cacheKey)) {
+            return this.dataSetSelectConfigCache.get(cacheKey);
+        }
+        // Get data sets for the selected test data profile using ID
+        const dataSets = this.getDataSetsForTestDataProfile(profileIdToUse);
+        const optionsArray = dataSets.map(dataSet => ({
+            id: dataSet.name,
+            value: dataSet.name,
+            name: dataSet.name,
+            label: dataSet.name
+        }));
+        // Ensure form control exists for data set selection
+        const variableGroup = this.getVariableFormGroup(variable.name);
+        if (variableGroup) {
+            if (!variableGroup.get('selectedDataSet')) {
+                const currentDataSet = variable.selectedDataSet || '';
+                variableGroup.addControl('selectedDataSet', new FormControl(currentDataSet));
+            }
+            else {
+                // Update form control value if variable has a selected data set
+                if (variable.selectedDataSet) {
+                    variableGroup.get('selectedDataSet')?.setValue(variable.selectedDataSet, { emitEvent: false });
+                }
+            }
+        }
+        // Check if default values are set - if so, disable the dropdown
+        const isDisabled = this.hasDefaultTestDataSelection();
+        const config = {
+            key: 'selectedDataSet',
+            placeholder: 'Select Data Set',
+            multiple: false,
+            searchable: false,
+            options: optionsArray,
+            hasMore: false,
+            isLoading: false,
+            disabled: isDisabled,
+            onChange: (value) => {
+                // Store selected data set
+                variable.selectedDataSet = value;
+                // Clear parameter selection when data set changes
+                variable.rawValue = '';
+                variable.value = '';
+                // Update form controls
+                const varGroup = this.getVariableFormGroup(variable.name);
+                if (varGroup) {
+                    if (varGroup.get('selectedDataSet')) {
+                        varGroup.get('selectedDataSet')?.setValue(value, { emitEvent: false });
+                    }
+                    if (varGroup.get('value')) {
+                        varGroup.get('value')?.setValue('', { emitEvent: false });
+                    }
+                }
+                // Clear caches for parameter select config since data set changed
+                const paramKeysToDelete = [];
+                this.parameterForDataSetSelectConfigCache.forEach((configValue, key) => {
+                    if (key.startsWith(`${variable.name}_paramForDataSet_`)) {
+                        paramKeysToDelete.push(key);
+                    }
+                });
+                paramKeysToDelete.forEach(key => this.parameterForDataSetSelectConfigCache.delete(key));
+                // Mark for check
+                this.cdr.markForCheck();
+            }
+        };
+        this.dataSetSelectConfigCache.set(cacheKey, config);
+        return config;
+    }
+    /**
+     * Get select config for parameter dropdown (third dropdown for parameters - shows parameters from selected data set)
+     */
+    getParameterSelectConfig(variable, index) {
+        // Get selected test data profile ID (preferred) or name (fallback) and data set
+        const selectedProfileId = variable.selectedTestDataProfileId;
+        const selectedProfile = variable.selectedTestDataProfile;
+        const selectedDataSet = variable.selectedDataSet;
+        if ((!selectedProfileId && !selectedProfile) || !selectedDataSet) {
+            // Return empty config if profile or data set is not selected
+            return {
+                key: 'value',
+                placeholder: (selectedProfileId || selectedProfile) ? 'Select Data Set first' : 'Select Test Data Profile first',
+                multiple: false,
+                searchable: false,
+                options: []
+            };
+        }
+        // Use profile ID if available, otherwise use profile name
+        const profileIdentifier = selectedProfileId ? String(selectedProfileId) : (selectedProfile || '');
+        const cacheKey = `${variable.name}_paramForDataSet_${profileIdentifier}_${selectedDataSet}`;
+        if (this.parameterForDataSetSelectConfigCache.has(cacheKey)) {
+            return this.parameterForDataSetSelectConfigCache.get(cacheKey);
+        }
+        // Get parameters for the selected data set using profile ID or name
+        const parameters = this.getParametersForDataSet(profileIdentifier, selectedDataSet);
+        const optionsArray = parameters.map(param => ({
+            id: `@|${param.name}|`,
+            value: `@|${param.name}|`,
+            name: param.name,
+            label: param.name
+        }));
+        // Ensure form control exists and is initialized with the current value
+        const variableGroup = this.getVariableFormGroup(variable.name);
+        if (variableGroup && variableGroup.get('value')) {
+            // If we have a value, ensure form control matches the option id (formatted value)
+            const currentValue = variable.value || '';
+            // Check if value is already formatted (e.g., "@|email|")
+            const formattedValue = currentValue.startsWith('@|') && currentValue.endsWith('|')
+                ? currentValue
+                : (currentValue ? `@|${currentValue}|` : '');
+            // Set form control to formatted value (matches opt.id) so select displays correctly
+            if (formattedValue && parameters.some(p => `@|${p.name}|` === formattedValue)) {
+                variableGroup.get('value')?.setValue(formattedValue, { emitEvent: false });
+            }
+        }
+        const config = {
+            key: 'value',
+            placeholder: `Select ${variable.label}`,
+            multiple: false,
+            searchable: true,
+            serverSearch: false,
+            options: optionsArray,
+            hasMore: false,
+            isLoading: false,
+            onChange: (value) => {
+                // Value received is the formatted value (e.g., "@|email|") because mat-option uses opt.id
+                // Extract parameter name from formatted value
+                const formattedValue = value; // This is already formatted as @|paramName|
+                const paramName = formattedValue.startsWith('@|') && formattedValue.endsWith('|')
+                    ? formattedValue.slice(2, -1)
+                    : formattedValue;
+                // Update raw value (store parameter name without formatting)
+                variable.rawValue = paramName;
+                // Update variable value (store formatted value for template)
+                variable.value = formattedValue;
+                // Update form control in FormArray - use formatted value (matches opt.id) so select displays correctly
+                const varGroup = this.getVariableFormGroup(variable.name);
+                if (varGroup && varGroup.get('value')) {
+                    // Set to formatted value so the select can match and display the selected option
+                    varGroup.get('value')?.setValue(formattedValue, { emitEvent: false });
+                }
+                // Mark for check and emit
+                this.cdr.markForCheck();
+                // Emit formatted value for parent component (this is what gets used in the template)
+                this.variableValueChange.emit({ name: variable.name, value: formattedValue });
+            }
+        };
+        this.parameterForDataSetSelectConfigCache.set(cacheKey, config);
+        return config;
+    }
+    /**
+     * Get unique environments from environment options
+     */
+    getUniqueEnvironments() {
+        const envMap = new Map();
+        this.environmentOptions.forEach(env => {
+            if (!envMap.has(env.environment)) {
+                envMap.set(env.environment, {
+                    id: env.environment,
+                    name: env.environment
+                });
+            }
+        });
+        return Array.from(envMap.values());
+    }
+    /**
+     * Get parameters for a specific environment
+     */
+    getParametersForEnvironment(environmentName) {
+        return this.environmentOptions
+            .filter(env => env.environment === environmentName)
+            .map(env => ({
+            id: env.name,
+            name: env.name
+        }));
+    }
+    /**
+     * Get select config for environment dropdown (first dropdown - select environment)
+     */
+    getEnvironmentSelectConfig(variable, index) {
+        const cacheKey = `${variable.name}_environment`;
+        if (this.environmentSelectConfigCache.has(cacheKey)) {
+            return this.environmentSelectConfigCache.get(cacheKey);
+        }
+        // Get unique environments
+        const uniqueEnvironments = this.getUniqueEnvironments();
+        const optionsArray = uniqueEnvironments.map(env => ({
+            id: env.id,
+            value: env.name,
+            name: env.name,
+            label: env.name
+        }));
+        // Ensure form control exists for environment selection
+        const variableGroup = this.getVariableFormGroup(variable.name);
+        if (variableGroup && !variableGroup.get('selectedEnvironment')) {
+            const currentEnv = variable.selectedEnvironment || '';
+            variableGroup.addControl('selectedEnvironment', new FormControl(currentEnv));
+        }
+        const config = {
+            key: 'selectedEnvironment',
+            placeholder: `Select Environment`,
+            multiple: false,
+            searchable: true,
+            serverSearch: true,
+            options: optionsArray,
+            hasMore: this.hasMoreEnvironments,
+            isLoading: this.isLoadingEnvironments,
+            onChange: (value) => {
+                // Store selected environment name on the variable object
+                variable.selectedEnvironment = value;
+                // Extract and store environment ID from environmentOptions
+                // Find the first environment option with matching environment name to get the ID
+                const envOption = this.environmentOptions.find(env => env.environment === value);
+                if (envOption) {
+                    // Extract numeric ID from envOption.id (format: "env-74-test" -> 74)
+                    const idMatch = envOption.id.match(/env-(\d+)-/);
+                    if (idMatch && idMatch[1]) {
+                        variable.selectedEnvironmentId = parseInt(idMatch[1], 10);
+                    }
+                }
+                // Clear the parameter selection when environment changes
+                variable.rawValue = undefined;
+                variable.value = '';
+                // Clear environment parameter config cache to force refresh
+                this.environmentParameterSelectConfigCache.delete(`${variable.name}_envParam`);
+                // Update form control
+                const variableGroup = this.getVariableFormGroup(variable.name);
+                if (variableGroup) {
+                    if (variableGroup.get('value')) {
+                        variableGroup.get('value')?.setValue('', { emitEvent: false });
+                    }
+                    // Update selectedEnvironment control
+                    if (variableGroup.get('selectedEnvironment')) {
+                        variableGroup.get('selectedEnvironment')?.setValue(value, { emitEvent: false });
+                    }
+                }
+                // Pre-compute environment parameter config for the new environment
+                const index = this.templateVariables.findIndex(v => v.name === variable.name);
+                if (index !== -1) {
+                    this.getEnvironmentParameterSelectConfig(variable, index);
+                }
+                // Mark for check to update UI
+                this.cdr.markForCheck();
+            },
+            onLoadMore: () => {
+                this.loadMoreEnvironments.emit();
+            },
+            onSearch: (query) => {
+                this.searchEnvironments.emit(query);
+            }
+        };
+        this.environmentSelectConfigCache.set(cacheKey, config);
+        return config;
+    }
+    /**
+     * Get select config for environment parameter dropdown (second dropdown - select parameter from environment)
+     */
+    getEnvironmentParameterSelectConfig(variable, index) {
+        const cacheKey = `${variable.name}_envParam`;
+        if (this.environmentParameterSelectConfigCache.has(cacheKey)) {
+            return this.environmentParameterSelectConfigCache.get(cacheKey);
+        }
+        // Get selected environment
+        const selectedEnvironment = variable.selectedEnvironment;
+        if (!selectedEnvironment) {
+            // Return empty config if no environment is selected
+            return {
+                key: 'value',
+                placeholder: 'Select Environment first',
+                multiple: false,
+                searchable: false,
+                options: []
+            };
+        }
+        // Get parameters for the selected environment
+        const parameters = this.getParametersForEnvironment(selectedEnvironment);
+        const optionsArray = parameters.map(param => ({
+            id: `*|${param.name}|`,
+            value: `*|${param.name}|`,
+            name: param.name,
+            label: param.name
+        }));
+        const config = {
+            key: 'value',
+            placeholder: `Select Parameter`,
+            multiple: false,
+            searchable: false,
+            options: optionsArray,
+            onChange: (value) => {
+                // When parameter is selected, update raw value and format it
+                variable.rawValue = value;
+                const formattedValue = `${value}`;
+                // Update variable value (store formatted value)
+                variable.value = formattedValue;
+                // Environment ID is already stored on variable.selectedEnvironmentId
+                // (it was set when environment was selected)
+                // Update form control in FormArray - keep raw value so select displays correctly
+                const variableGroup = this.getVariableFormGroup(variable.name);
+                if (variableGroup && variableGroup.get('value')) {
+                    // Set to raw value so the select can match and display the selected option
+                    variableGroup.get('value')?.setValue(value, { emitEvent: false });
+                }
+                // Mark for check and emit
+                this.cdr.markForCheck();
+                // Emit formatted value for parent component
+                this.variableValueChange.emit({ name: variable.name, value: formattedValue });
+            }
+        };
+        this.environmentParameterSelectConfigCache.set(cacheKey, config);
+        return config;
+    }
+    /**
+     * Get selected environment for a variable
+     */
+    getSelectedEnvironment(variable) {
+        return variable.selectedEnvironment || '';
+    }
+    /**
+     * Check if environment is selected for a variable
+     */
+    hasSelectedEnvironment(variable) {
+        return !!variable.selectedEnvironment;
+    }
+    /**
+     * Get selected environment ID for a variable
+     */
+    getSelectedEnvironmentId(variable) {
+        return variable.selectedEnvironmentId || null;
+    }
+    /**
+     * Get all environment IDs for variables that use environment type
+     * Returns a map of variable name to environment ID
+     */
+    getEnvironmentIdsForVariables() {
+        const envIds = new Map();
+        this.templateVariables.forEach(variable => {
+            if (this.isEnvironmentType(variable) && variable.selectedEnvironmentId) {
+                envIds.set(variable.name, variable.selectedEnvironmentId);
+            }
+        });
+        return envIds;
+    }
+    /**
+     * Check if current data type is plain-text
+     */
+    isPlainTextType(variable) {
+        const dataType = variable.dataType || 'plain-text';
+        return dataType === 'plain-text';
+    }
+    /**
+     * Check if current data type is parameter
+     */
+    isParameterType(variable) {
+        const dataType = variable.dataType || 'plain-text';
+        return dataType === 'parameter';
+    }
+    /**
+     * Check if test data profile is selected for a variable
+     */
+    hasSelectedTestDataProfile(variable) {
+        return !!variable.selectedTestDataProfile;
+    }
+    /**
+     * Check if data set is selected for a variable
+     */
+    hasSelectedDataSet(variable) {
+        return !!variable.selectedDataSet;
+    }
+    /**
+     * Check if default test data profile and data set are set (from test case)
+     * If true, profile and data set dropdowns should be disabled
+     */
+    hasDefaultTestDataSelection() {
+        return !!(this.defaultTestDataProfileId != null && this.defaultTestDataStartIndex != null);
+    }
+    /**
+     * Check if current data type is environment
+     */
+    isEnvironmentType(variable) {
+        const dataType = variable.dataType || 'plain-text';
+        return dataType === 'environment';
+    }
+    /**
+     * Check if current data type is runtime
+     */
+    isRuntimeType(variable) {
+        const dataType = variable.dataType || 'plain-text';
+        return dataType === 'runtime';
+    }
 }
 TemplateVariablesFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TemplateVariablesFormComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
-TemplateVariablesFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: TemplateVariablesFormComponent, selector: "cqa-template-variables-form", inputs: { templateVariables: "templateVariables", variablesForm: "variablesForm", metadata: "metadata", description: "description", elementOptions: "elementOptions", hasMoreElements: "hasMoreElements", isLoadingElements: "isLoadingElements", screenNameOptions: "screenNameOptions", hasMoreScreenNames: "hasMoreScreenNames", isLoadingScreenNames: "isLoadingScreenNames" }, outputs: { variableValueChange: "variableValueChange", variableBooleanChange: "variableBooleanChange", metadataChange: "metadataChange", descriptionChange: "descriptionChange", loadMoreElements: "loadMoreElements", searchElements: "searchElements", createElement: "createElement", searchScreenName: "searchScreenName", loadMoreScreenNames: "loadMoreScreenNames", createScreenNameRequest: "createScreenNameRequest", cancelElementForm: "cancelElementForm", elementFormVisibilityChange: "elementFormVisibilityChange" }, host: { classAttribute: "cqa-ui-root" }, usesOnChanges: true, ngImport: i0, template: "<div class=\"cqa-flex cqa-gap-x-6 cqa-gap-y-4 cqa-flex-wrap\" *ngIf=\"!createElementVisible\">\n  <ng-container *ngFor=\"let variable of templateVariables; let i = index; trackBy: trackByVariable\">\n    <!-- Boolean variables with mat-slide-toggle -->\n    <ng-container *ngIf=\"variable.type === 'boolean'\">\n      <div class=\"cqa-flex cqa-items-center cqa-gap-2\" style=\"width: calc(50% - 12px);\">\n        <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700\">\n          {{ variable.label }}\n        </label>\n        <mat-slide-toggle [checked]=\"variablesForm.at(i)?.get('value')?.value || variable.value || false\"\n          (change)=\"onVariableBooleanChange(variable.name, $event.checked)\" color=\"primary\">\n        </mat-slide-toggle>\n      </div>\n    </ng-container>\n\n    <!-- Non-boolean, non-custom_code variables -->\n    <ng-container *ngIf=\"variable.name !== 'custom_code' && variable.type !== 'boolean'\">\n      <ng-container *ngIf=\"shouldShowDropdown(variable); else defaultInput\">\n        <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n          <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n            {{ variable.label }}\n          </label>\n          <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getSelectConfig(variable, i)\">\n          </cqa-dynamic-select>\n        </div>\n      </ng-container>\n      <ng-template #defaultInput>\n        <!-- Test-data, source-value, or target-value with data type dropdown -->\n        <ng-container *ngIf=\"needsDataTypeDropdown(variable); else regularInput\">\n          <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n              {{ variable.label }} Type\n            </label>\n            <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getDataTypeSelectConfig(variable, i)\">\n            </cqa-dynamic-select>\n          </div>\n          <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n              {{ variable.label }}\n            </label>\n            <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"getRawValue(variable)\" [fullWidth]=\"true\"\n              (valueChange)=\"onTestDataValueChange(variable.name, $event)\">\n            </cqa-custom-input>\n          </div>\n        </ng-container>\n        <ng-template #regularInput>\n          <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n              {{ variable.label }}\n            </label>\n            <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"variable.value\" [fullWidth]=\"true\"\n              (valueChange)=\"onVariableValueChange(variable.name, $event)\">\n            </cqa-custom-input>\n          </div>\n        </ng-template>\n      </ng-template>\n    </ng-container>\n  </ng-container>\n\n  <!-- Metadata -->\n  <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n    <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n      Metadata\n    </label>\n    <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"metadata\" [fullWidth]=\"true\"\n      (valueChange)=\"metadataChange.emit($event)\">\n    </cqa-custom-input>\n  </div>\n\n  <!-- Description -->\n  <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n    <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n      Description\n    </label>\n    <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"description\" [fullWidth]=\"true\"\n      (valueChange)=\"descriptionChange.emit($event)\">\n    </cqa-custom-input>\n  </div>\n</div>\n\n<div *ngIf=\"createElementVisible\">\n  <cqa-element-form\n    [isCreateMode]=\"true\"\n    [screenNameOptions]=\"screenNameOptions\"\n    [hasMoreScreenNames]=\"hasMoreScreenNames\"\n    [isLoadingScreenNames]=\"isLoadingScreenNames\"\n    [isEditInDepthAvailable]=\"false\"\n    (createElement)=\"onCreateElement($event)\"\n    (cancel)=\"onCancelElementForm()\"\n    (searchScreenName)=\"searchScreenName.emit($event)\"\n    (loadMoreScreenNames)=\"loadMoreScreenNames.emit($event)\"\n    (createScreenNameRequest)=\"createScreenNameRequest.emit($event)\">\n  </cqa-element-form>\n</div>\n<div class=\"cqa-flex cqa-justify-end cqa-pt-2\" *ngIf=\"!createElementVisible\">\n  <cqa-button \n    *ngIf=\"selectorVariableAvailable\"\n    variant=\"text\" \n    size=\"sm\"\n    text=\"Create Element\"\n    (clicked)=\"onShowElementForm()\">\n  </cqa-button>\n  <!-- <cqa-button \n    *ngIf=\"parameterVariableAvailable\"\n    variant=\"filled\" \n    text=\"Create Parameter\"\n    (clicked)=\"onCreateParameter()\">\n  </cqa-button>\n  <cqa-button \n    *ngIf=\"environmentVariableAvailable\"\n    variant=\"filled\" \n    text=\"Create Environment\"\n    (clicked)=\"onCreateEnvironment()\">\n  </cqa-button> -->\n</div>", components: [{ type: i1.MatSlideToggle, selector: "mat-slide-toggle", inputs: ["disabled", "disableRipple", "color", "tabIndex", "name", "id", "labelPosition", "aria-label", "aria-labelledby", "aria-describedby", "required", "checked"], outputs: ["change", "toggleChange"], exportAs: ["matSlideToggle"] }, { type: i2.DynamicSelectFieldComponent, selector: "cqa-dynamic-select", inputs: ["form", "config"], outputs: ["selectionChange", "selectClick", "searchChange", "loadMore", "addCustomValue"] }, { type: i3.CustomInputComponent, selector: "cqa-custom-input", inputs: ["label", "type", "placeholder", "value", "disabled", "errors", "required", "ariaLabel", "size", "fullWidth", "maxLength", "showCharCount", "inputInlineStyle", "labelInlineStyle"], outputs: ["valueChange", "blurred", "focused", "enterPressed"] }, { type: i4.ElementFormComponent, selector: "cqa-element-form", inputs: ["elementId", "element", "screenNameOptions", "hasMoreScreenNames", "isLoadingScreenNames", "isElementLoading", "isEditMode", "isCreateMode", "isEditInDepthAvailable"], outputs: ["createElement", "updateElement", "createScreenNameRequest", "searchScreenName", "loadMoreScreenNames", "cancel", "editInDepth"] }, { type: i5.ButtonComponent, selector: "cqa-button", inputs: ["variant", "btnSize", "disabled", "icon", "iconPosition", "fullWidth", "iconColor", "type", "text", "customClass", "inlineStyles", "tooltip", "tooltipPosition"], outputs: ["clicked"] }], directives: [{ type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+TemplateVariablesFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: TemplateVariablesFormComponent, selector: "cqa-template-variables-form", inputs: { templateVariables: "templateVariables", variablesForm: "variablesForm", metadata: "metadata", description: "description", elementOptions: "elementOptions", hasMoreElements: "hasMoreElements", isLoadingElements: "isLoadingElements", screenNameOptions: "screenNameOptions", hasMoreScreenNames: "hasMoreScreenNames", isLoadingScreenNames: "isLoadingScreenNames", parameterOptions: "parameterOptions", hasMoreParameters: "hasMoreParameters", isLoadingParameters: "isLoadingParameters", environmentOptions: "environmentOptions", hasMoreEnvironments: "hasMoreEnvironments", isLoadingEnvironments: "isLoadingEnvironments", defaultTestDataProfileId: "defaultTestDataProfileId", defaultTestDataStartIndex: "defaultTestDataStartIndex", createElementVisible: "createElementVisible" }, outputs: { variableValueChange: "variableValueChange", variableBooleanChange: "variableBooleanChange", metadataChange: "metadataChange", descriptionChange: "descriptionChange", loadMoreElements: "loadMoreElements", searchElements: "searchElements", createElement: "createElement", searchScreenName: "searchScreenName", loadMoreScreenNames: "loadMoreScreenNames", createScreenNameRequest: "createScreenNameRequest", searchParameters: "searchParameters", loadMoreParameters: "loadMoreParameters", searchEnvironments: "searchEnvironments", loadMoreEnvironments: "loadMoreEnvironments", cancelElementForm: "cancelElementForm", elementFormVisibilityChange: "elementFormVisibilityChange" }, host: { classAttribute: "cqa-ui-root" }, usesOnChanges: true, ngImport: i0, template: "<style>\n  .capitalize-first::first-letter {\n    text-transform: uppercase;\n  }\n</style>\n\n<div class=\"cqa-flex cqa-gap-x-6 cqa-gap-y-4 cqa-flex-wrap template-variables-form\" *ngIf=\"!createElementVisible\">\n  \n  <!-- Metadata -->\n  <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n    <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n      Metadata\n    </label>\n    <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"metadata\" [fullWidth]=\"true\"\n      (valueChange)=\"metadataChange.emit($event)\">\n    </cqa-custom-input>\n  </div>\n\n  <!-- Description -->\n  <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n    <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n      Description\n    </label>\n    <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"description\" [fullWidth]=\"true\"\n      (valueChange)=\"descriptionChange.emit($event)\">\n    </cqa-custom-input>\n  </div>\n  \n  <ng-container *ngFor=\"let variable of templateVariables; let i = index; trackBy: trackByVariable\">\n    <!-- Boolean variables with mat-slide-toggle -->\n    <ng-container *ngIf=\"variable.type === 'boolean'\">\n      <div class=\"cqa-flex cqa-items-center cqa-gap-2\" style=\"width: calc(50% - 12px);\">\n        <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 capitalize-first\">\n          {{ variable.label }}\n        </label>\n        <mat-slide-toggle [checked]=\"variablesForm.at(i)?.get('value')?.value || variable.value || false\"\n          (change)=\"onVariableBooleanChange(variable.name, $event.checked)\" color=\"primary\">\n        </mat-slide-toggle>\n      </div>\n    </ng-container>\n\n    <!-- Non-boolean, non-custom_code variables -->\n    <ng-container *ngIf=\"variable.name !== 'custom_code' && variable.type !== 'boolean'\">\n      <ng-container *ngIf=\"shouldShowDropdown(variable); else defaultInput\">\n        <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n          <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1 capitalize-first\">\n            {{ variable.label }}\n          </label>\n          <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getSelectConfig(variable, i)\">\n          </cqa-dynamic-select>\n        </div>\n      </ng-container>\n      <ng-template #defaultInput>\n        <!-- Test-data, source-value, or target-value with data type dropdown -->\n        <ng-container *ngIf=\"needsDataTypeDropdown(variable); else regularInput\">\n          <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1 capitalize-first\">\n              {{ variable.label }} Type\n            </label>\n            <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getDataTypeSelectConfig(variable, i)\">\n            </cqa-dynamic-select>\n          </div>\n          <ng-container *ngIf=\"isEnvironmentType(variable)\">\n          <div *ngIf=\"isEnvironmentType(variable)\" class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n              Environment Name\n            </label>\n            <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getEnvironmentSelectConfig(variable, i)\">\n            </cqa-dynamic-select>\n          </div>\n          <div *ngIf=\"hasSelectedEnvironment(variable)\" class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n              Environment Value\n            </label>\n            <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getEnvironmentParameterSelectConfig(variable, i)\">\n            </cqa-dynamic-select>\n          </div>\n          </ng-container>\n          <ng-container *ngIf=\"isParameterType(variable)\">\n            <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n              <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n                Test Data Profile\n              </label>\n              <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getTestDataProfileSelectConfig(variable, i)\">\n              </cqa-dynamic-select>\n            </div>\n            <div *ngIf=\"hasSelectedTestDataProfile(variable)\" class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n              <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n                Data Set\n              </label>\n              <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getDataSetSelectConfig(variable, i)\">\n              </cqa-dynamic-select>\n            </div>\n            <div *ngIf=\"hasSelectedDataSet(variable)\" class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n              <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1 capitalize-first\">\n                {{ variable.label }}\n              </label>\n              <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getParameterSelectConfig(variable, i)\">\n              </cqa-dynamic-select>\n            </div>\n          </ng-container>\n          <div *ngIf=\"isPlainTextType(variable) || isRuntimeType(variable)\" class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1  capitalize-first\">\n              {{ variable.label }} \n            </label>\n            <!-- Show custom input for plain-text type -->\n            <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"getRawValue(variable)\" [fullWidth]=\"true\"\n              (valueChange)=\"onTestDataValueChange(variable.name, $event)\">\n            </cqa-custom-input>\n          </div>\n        </ng-container>\n        <ng-template #regularInput>\n          <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1 capitalize-first\">\n              {{ variable.label }}\n            </label>\n            <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"variable.value\" [fullWidth]=\"true\"\n              (valueChange)=\"onVariableValueChange(variable.name, $event)\">\n            </cqa-custom-input>\n          </div>\n        </ng-template>\n      </ng-template>\n    </ng-container>\n  </ng-container>\n</div>\n\n<div *ngIf=\"createElementVisible\">\n  <cqa-element-form\n    [isCreateMode]=\"true\"\n    [screenNameOptions]=\"screenNameOptions\"\n    [hasMoreScreenNames]=\"hasMoreScreenNames\"\n    [isLoadingScreenNames]=\"isLoadingScreenNames\"\n    [isEditInDepthAvailable]=\"false\"\n    (createElement)=\"onCreateElement($event)\"\n    (cancel)=\"onCancelElementForm()\"\n    (searchScreenName)=\"searchScreenName.emit($event)\"\n    (loadMoreScreenNames)=\"loadMoreScreenNames.emit($event)\"\n    (createScreenNameRequest)=\"createScreenNameRequest.emit($event)\">\n  </cqa-element-form>\n</div>", styles: ["\n  .capitalize-first::first-letter {\n    text-transform: uppercase;\n  }\n"], components: [{ type: i1.CustomInputComponent, selector: "cqa-custom-input", inputs: ["label", "type", "placeholder", "value", "disabled", "errors", "required", "ariaLabel", "size", "fullWidth", "maxLength", "showCharCount", "inputInlineStyle", "labelInlineStyle"], outputs: ["valueChange", "blurred", "focused", "enterPressed"] }, { type: i2.MatSlideToggle, selector: "mat-slide-toggle", inputs: ["disabled", "disableRipple", "color", "tabIndex", "name", "id", "labelPosition", "aria-label", "aria-labelledby", "aria-describedby", "required", "checked"], outputs: ["change", "toggleChange"], exportAs: ["matSlideToggle"] }, { type: i3.DynamicSelectFieldComponent, selector: "cqa-dynamic-select", inputs: ["form", "config"], outputs: ["selectionChange", "selectClick", "searchChange", "loadMore", "addCustomValue"] }, { type: i4.ElementFormComponent, selector: "cqa-element-form", inputs: ["elementId", "element", "screenNameOptions", "hasMoreScreenNames", "isLoadingScreenNames", "isElementLoading", "isEditMode", "isCreateMode", "isEditInDepthAvailable"], outputs: ["createElement", "updateElement", "createScreenNameRequest", "searchScreenName", "loadMoreScreenNames", "cancel", "editInDepth"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TemplateVariablesFormComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'cqa-template-variables-form', host: { class: 'cqa-ui-root' }, changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"cqa-flex cqa-gap-x-6 cqa-gap-y-4 cqa-flex-wrap\" *ngIf=\"!createElementVisible\">\n  <ng-container *ngFor=\"let variable of templateVariables; let i = index; trackBy: trackByVariable\">\n    <!-- Boolean variables with mat-slide-toggle -->\n    <ng-container *ngIf=\"variable.type === 'boolean'\">\n      <div class=\"cqa-flex cqa-items-center cqa-gap-2\" style=\"width: calc(50% - 12px);\">\n        <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700\">\n          {{ variable.label }}\n        </label>\n        <mat-slide-toggle [checked]=\"variablesForm.at(i)?.get('value')?.value || variable.value || false\"\n          (change)=\"onVariableBooleanChange(variable.name, $event.checked)\" color=\"primary\">\n        </mat-slide-toggle>\n      </div>\n    </ng-container>\n\n    <!-- Non-boolean, non-custom_code variables -->\n    <ng-container *ngIf=\"variable.name !== 'custom_code' && variable.type !== 'boolean'\">\n      <ng-container *ngIf=\"shouldShowDropdown(variable); else defaultInput\">\n        <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n          <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n            {{ variable.label }}\n          </label>\n          <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getSelectConfig(variable, i)\">\n          </cqa-dynamic-select>\n        </div>\n      </ng-container>\n      <ng-template #defaultInput>\n        <!-- Test-data, source-value, or target-value with data type dropdown -->\n        <ng-container *ngIf=\"needsDataTypeDropdown(variable); else regularInput\">\n          <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n              {{ variable.label }} Type\n            </label>\n            <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getDataTypeSelectConfig(variable, i)\">\n            </cqa-dynamic-select>\n          </div>\n          <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n              {{ variable.label }}\n            </label>\n            <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"getRawValue(variable)\" [fullWidth]=\"true\"\n              (valueChange)=\"onTestDataValueChange(variable.name, $event)\">\n            </cqa-custom-input>\n          </div>\n        </ng-container>\n        <ng-template #regularInput>\n          <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n              {{ variable.label }}\n            </label>\n            <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"variable.value\" [fullWidth]=\"true\"\n              (valueChange)=\"onVariableValueChange(variable.name, $event)\">\n            </cqa-custom-input>\n          </div>\n        </ng-template>\n      </ng-template>\n    </ng-container>\n  </ng-container>\n\n  <!-- Metadata -->\n  <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n    <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n      Metadata\n    </label>\n    <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"metadata\" [fullWidth]=\"true\"\n      (valueChange)=\"metadataChange.emit($event)\">\n    </cqa-custom-input>\n  </div>\n\n  <!-- Description -->\n  <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n    <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n      Description\n    </label>\n    <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"description\" [fullWidth]=\"true\"\n      (valueChange)=\"descriptionChange.emit($event)\">\n    </cqa-custom-input>\n  </div>\n</div>\n\n<div *ngIf=\"createElementVisible\">\n  <cqa-element-form\n    [isCreateMode]=\"true\"\n    [screenNameOptions]=\"screenNameOptions\"\n    [hasMoreScreenNames]=\"hasMoreScreenNames\"\n    [isLoadingScreenNames]=\"isLoadingScreenNames\"\n    [isEditInDepthAvailable]=\"false\"\n    (createElement)=\"onCreateElement($event)\"\n    (cancel)=\"onCancelElementForm()\"\n    (searchScreenName)=\"searchScreenName.emit($event)\"\n    (loadMoreScreenNames)=\"loadMoreScreenNames.emit($event)\"\n    (createScreenNameRequest)=\"createScreenNameRequest.emit($event)\">\n  </cqa-element-form>\n</div>\n<div class=\"cqa-flex cqa-justify-end cqa-pt-2\" *ngIf=\"!createElementVisible\">\n  <cqa-button \n    *ngIf=\"selectorVariableAvailable\"\n    variant=\"text\" \n    size=\"sm\"\n    text=\"Create Element\"\n    (clicked)=\"onShowElementForm()\">\n  </cqa-button>\n  <!-- <cqa-button \n    *ngIf=\"parameterVariableAvailable\"\n    variant=\"filled\" \n    text=\"Create Parameter\"\n    (clicked)=\"onCreateParameter()\">\n  </cqa-button>\n  <cqa-button \n    *ngIf=\"environmentVariableAvailable\"\n    variant=\"filled\" \n    text=\"Create Environment\"\n    (clicked)=\"onCreateEnvironment()\">\n  </cqa-button> -->\n</div>", styles: [] }]
+            args: [{ selector: 'cqa-template-variables-form', host: { class: 'cqa-ui-root' }, changeDetection: ChangeDetectionStrategy.OnPush, template: "<style>\n  .capitalize-first::first-letter {\n    text-transform: uppercase;\n  }\n</style>\n\n<div class=\"cqa-flex cqa-gap-x-6 cqa-gap-y-4 cqa-flex-wrap template-variables-form\" *ngIf=\"!createElementVisible\">\n  \n  <!-- Metadata -->\n  <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n    <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n      Metadata\n    </label>\n    <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"metadata\" [fullWidth]=\"true\"\n      (valueChange)=\"metadataChange.emit($event)\">\n    </cqa-custom-input>\n  </div>\n\n  <!-- Description -->\n  <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n    <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n      Description\n    </label>\n    <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"description\" [fullWidth]=\"true\"\n      (valueChange)=\"descriptionChange.emit($event)\">\n    </cqa-custom-input>\n  </div>\n  \n  <ng-container *ngFor=\"let variable of templateVariables; let i = index; trackBy: trackByVariable\">\n    <!-- Boolean variables with mat-slide-toggle -->\n    <ng-container *ngIf=\"variable.type === 'boolean'\">\n      <div class=\"cqa-flex cqa-items-center cqa-gap-2\" style=\"width: calc(50% - 12px);\">\n        <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 capitalize-first\">\n          {{ variable.label }}\n        </label>\n        <mat-slide-toggle [checked]=\"variablesForm.at(i)?.get('value')?.value || variable.value || false\"\n          (change)=\"onVariableBooleanChange(variable.name, $event.checked)\" color=\"primary\">\n        </mat-slide-toggle>\n      </div>\n    </ng-container>\n\n    <!-- Non-boolean, non-custom_code variables -->\n    <ng-container *ngIf=\"variable.name !== 'custom_code' && variable.type !== 'boolean'\">\n      <ng-container *ngIf=\"shouldShowDropdown(variable); else defaultInput\">\n        <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n          <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1 capitalize-first\">\n            {{ variable.label }}\n          </label>\n          <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getSelectConfig(variable, i)\">\n          </cqa-dynamic-select>\n        </div>\n      </ng-container>\n      <ng-template #defaultInput>\n        <!-- Test-data, source-value, or target-value with data type dropdown -->\n        <ng-container *ngIf=\"needsDataTypeDropdown(variable); else regularInput\">\n          <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1 capitalize-first\">\n              {{ variable.label }} Type\n            </label>\n            <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getDataTypeSelectConfig(variable, i)\">\n            </cqa-dynamic-select>\n          </div>\n          <ng-container *ngIf=\"isEnvironmentType(variable)\">\n          <div *ngIf=\"isEnvironmentType(variable)\" class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n              Environment Name\n            </label>\n            <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getEnvironmentSelectConfig(variable, i)\">\n            </cqa-dynamic-select>\n          </div>\n          <div *ngIf=\"hasSelectedEnvironment(variable)\" class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n              Environment Value\n            </label>\n            <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getEnvironmentParameterSelectConfig(variable, i)\">\n            </cqa-dynamic-select>\n          </div>\n          </ng-container>\n          <ng-container *ngIf=\"isParameterType(variable)\">\n            <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n              <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n                Test Data Profile\n              </label>\n              <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getTestDataProfileSelectConfig(variable, i)\">\n              </cqa-dynamic-select>\n            </div>\n            <div *ngIf=\"hasSelectedTestDataProfile(variable)\" class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n              <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n                Data Set\n              </label>\n              <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getDataSetSelectConfig(variable, i)\">\n              </cqa-dynamic-select>\n            </div>\n            <div *ngIf=\"hasSelectedDataSet(variable)\" class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n              <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1 capitalize-first\">\n                {{ variable.label }}\n              </label>\n              <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getParameterSelectConfig(variable, i)\">\n              </cqa-dynamic-select>\n            </div>\n          </ng-container>\n          <div *ngIf=\"isPlainTextType(variable) || isRuntimeType(variable)\" class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1  capitalize-first\">\n              {{ variable.label }} \n            </label>\n            <!-- Show custom input for plain-text type -->\n            <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"getRawValue(variable)\" [fullWidth]=\"true\"\n              (valueChange)=\"onTestDataValueChange(variable.name, $event)\">\n            </cqa-custom-input>\n          </div>\n        </ng-container>\n        <ng-template #regularInput>\n          <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1 capitalize-first\">\n              {{ variable.label }}\n            </label>\n            <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"variable.value\" [fullWidth]=\"true\"\n              (valueChange)=\"onVariableValueChange(variable.name, $event)\">\n            </cqa-custom-input>\n          </div>\n        </ng-template>\n      </ng-template>\n    </ng-container>\n  </ng-container>\n</div>\n\n<div *ngIf=\"createElementVisible\">\n  <cqa-element-form\n    [isCreateMode]=\"true\"\n    [screenNameOptions]=\"screenNameOptions\"\n    [hasMoreScreenNames]=\"hasMoreScreenNames\"\n    [isLoadingScreenNames]=\"isLoadingScreenNames\"\n    [isEditInDepthAvailable]=\"false\"\n    (createElement)=\"onCreateElement($event)\"\n    (cancel)=\"onCancelElementForm()\"\n    (searchScreenName)=\"searchScreenName.emit($event)\"\n    (loadMoreScreenNames)=\"loadMoreScreenNames.emit($event)\"\n    (createScreenNameRequest)=\"createScreenNameRequest.emit($event)\">\n  </cqa-element-form>\n</div>", styles: ["\n  .capitalize-first::first-letter {\n    text-transform: uppercase;\n  }\n"] }]
         }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { templateVariables: [{
                 type: Input
             }], variablesForm: [{
@@ -452,6 +1427,22 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImpor
                 type: Input
             }], isLoadingScreenNames: [{
                 type: Input
+            }], parameterOptions: [{
+                type: Input
+            }], hasMoreParameters: [{
+                type: Input
+            }], isLoadingParameters: [{
+                type: Input
+            }], environmentOptions: [{
+                type: Input
+            }], hasMoreEnvironments: [{
+                type: Input
+            }], isLoadingEnvironments: [{
+                type: Input
+            }], defaultTestDataProfileId: [{
+                type: Input
+            }], defaultTestDataStartIndex: [{
+                type: Input
             }], variableValueChange: [{
                 type: Output
             }], variableBooleanChange: [{
@@ -472,9 +1463,19 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImpor
                 type: Output
             }], createScreenNameRequest: [{
                 type: Output
+            }], searchParameters: [{
+                type: Output
+            }], loadMoreParameters: [{
+                type: Output
+            }], searchEnvironments: [{
+                type: Output
+            }], loadMoreEnvironments: [{
+                type: Output
             }], cancelElementForm: [{
                 type: Output
             }], elementFormVisibilityChange: [{
                 type: Output
+            }], createElementVisible: [{
+                type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template-variables-form.component.js","sourceRoot":"","sources":["../../../../../../src/lib/step-builder/template-variables-form/template-variables-form.component.ts","../../../../../../src/lib/step-builder/template-variables-form/template-variables-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, OnChanges, SimpleChanges, ChangeDetectionStrategy, ChangeDetectorRef } from '@angular/core';\nimport { FormGroup, FormControl, FormArray } from '@angular/forms';\nimport { DynamicSelectFieldConfig, SelectOption } from '../../dynamic-select/dynamic-select-field.component';\nimport { ElementCreatePayload, ScreenNameOption } from '../../test-case-details/element-popup/element-popup-form-data';\n\n// Import Element type - using any for now since Element is from ts-portal-ui\n// In a real scenario, you might want to create a shared interface or import from a shared package\ninterface Element {\n  id?: number;\n  name: string;\n  locatorValue?: string;\n  otherLocator?: string[];\n  [key: string]: any;\n}\n\nexport interface TemplateVariable {\n  name: string;\n  dataKey: string;\n  label: string;\n  value: any;\n  type?: string;\n  options?: string[];\n}\n\n@Component({\n  selector: 'cqa-template-variables-form',\n  templateUrl: './template-variables-form.component.html',\n  styleUrls: [],\n  host: { class: 'cqa-ui-root' },\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class TemplateVariablesFormComponent implements OnChanges {\n  @Input() templateVariables: TemplateVariable[] = [];\n  @Input() variablesForm: FormArray = new FormArray([]);\n  @Input() metadata: string = '';\n  @Input() description: string = '';\n  @Input() elementOptions: Element[] = []; // Element objects for element dropdown\n  @Input() hasMoreElements: boolean = false; // Whether more elements are available\n  @Input() isLoadingElements: boolean = false; // Loading state for elements\n  /** Screen name options for element form autocomplete (from API) */\n  @Input() screenNameOptions: ScreenNameOption[] = [];\n  /** Whether more screen names are available for infinite scroll */\n  @Input() hasMoreScreenNames: boolean = false;\n  /** True while parent is loading screen names (search or load more) */\n  @Input() isLoadingScreenNames: boolean = false;\n  \n  @Output() variableValueChange = new EventEmitter<{ name: string; value: any }>();\n  @Output() variableBooleanChange = new EventEmitter<{ name: string; value: boolean }>();\n  @Output() metadataChange = new EventEmitter<string>();\n  @Output() descriptionChange = new EventEmitter<string>();\n  @Output() loadMoreElements = new EventEmitter<void>(); // Emit when load more is requested\n  @Output() searchElements = new EventEmitter<string>(); // Emit when user searches for elements\n  @Output() createElement = new EventEmitter<ElementCreatePayload>(); // Emit when element is created with payload\n  @Output() searchScreenName = new EventEmitter<string>(); // Emit when user searches screen names\n  @Output() loadMoreScreenNames = new EventEmitter<string>(); // Emit when user scrolls to load more screen names\n  @Output() createScreenNameRequest = new EventEmitter<string>(); // Emit when user requests to create a new screen name\n  @Output() cancelElementForm = new EventEmitter<void>(); // Emit when element form is cancelled\n  @Output() elementFormVisibilityChange = new EventEmitter<boolean>(); // Emit when element form visibility changes\n  \n  // Cache for select configs to avoid recalculating on every change detection\n  private selectConfigCache: Map<string, DynamicSelectFieldConfig> = new Map();\n  \n  // Cache for data type select configs\n  private dataTypeSelectConfigCache: Map<string, DynamicSelectFieldConfig> = new Map();\n  \n  // Store data types for test-data variables\n  private variableDataTypes: Map<string, 'plain-text' | 'parameter' | 'runtime' | 'environment'> = new Map();\n  \n  // Store raw values (without formatting) for test-data variables\n  private variableRawValues: Map<string, string> = new Map();\n  \n  // Cache for computed properties\n  private needsDataTypeDropdownCache: Map<string, boolean> = new Map();\n  private shouldShowDropdownCache: Map<string, boolean> = new Map();\n  \n  // Pre-computed data type options (static, no need to recreate)\n  private readonly dataTypeOptions: SelectOption[] = [\n    { id: 'plain-text', value: 'plain-text', name: 'Plain Text', label: 'Plain Text' },\n    { id: 'parameter', value: 'parameter', name: '@|Parameter|', label: '@|Parameter|' },\n    { id: 'runtime', value: 'runtime', name: '$|Runtime|', label: '$|Runtime|' },\n    { id: 'environment', value: 'environment', name: '*|Environment|', label: '*|Environment|' }\n  ];\n\n  createElementVisible: boolean = false;\n  \n  constructor(private cdr: ChangeDetectorRef) {}\n\n  onCreateElement(payload: ElementCreatePayload): void {\n    console.log('onCreateElement', payload);\n    this.createElement.emit(payload);\n    this.createElementVisible = false;\n    this.elementFormVisibilityChange.emit(false);\n    this.cdr.markForCheck();\n  }\n\n  onCancelElementForm(): void {\n    this.createElementVisible = false;\n    this.elementFormVisibilityChange.emit(false);\n    this.cancelElementForm.emit();\n    this.cdr.markForCheck();\n  }\n\n  onShowElementForm(): void {\n    this.createElementVisible = true;\n    this.elementFormVisibilityChange.emit(true);\n    this.cdr.markForCheck();\n  }\n  \n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['templateVariables'] || changes['variablesForm'] || changes['elementOptions'] || \n        changes['hasMoreElements'] || changes['isLoadingElements']) {\n      // Clear all caches when inputs change\n      this.selectConfigCache.clear();\n      this.dataTypeSelectConfigCache.clear();\n      this.needsDataTypeDropdownCache.clear();\n      this.shouldShowDropdownCache.clear();\n      \n      // Initialize data types and raw values for test-data variables\n      if (changes['templateVariables'] && this.templateVariables) {\n        this.initializeTestDataVariables();\n      }\n      \n      // Pre-compute all configs to avoid calling methods in template\n      this.precomputeConfigs();\n      \n      // Mark for check since we're using OnPush\n      this.cdr.markForCheck();\n    }\n  }\n  \n  private initializeTestDataVariables(): void {\n    this.templateVariables.forEach((variable, index) => {\n      if (this.needsDataTypeDropdown(variable)) {\n        const { dataType, rawValue } = this.parseTestDataValue(variable.value || '');\n        this.variableDataTypes.set(variable.name, dataType);\n        this.variableRawValues.set(variable.name, rawValue);\n        \n        // Ensure form control exists for data type in the FormArray\n        const variableGroup = this.getVariableFormGroup(variable.name);\n        if (variableGroup) {\n          if (!variableGroup.get('dataType')) {\n            variableGroup.addControl('dataType', new FormControl(dataType));\n          } else {\n            variableGroup.get('dataType')?.setValue(dataType, { emitEvent: false });\n          }\n        }\n      }\n    });\n  }\n  \n  /** Get form group for a variable by name from FormArray */\n  getVariableFormGroup(variableName: string): FormGroup | null {\n    const variableIndex = this.variablesForm.controls.findIndex(\n      control => (control as FormGroup).get('name')?.value === variableName\n    );\n    if (variableIndex !== -1) {\n      return this.variablesForm.at(variableIndex) as FormGroup;\n    }\n    return null;\n  }\n  \n  /** Get form group at a specific index from FormArray (for template use) */\n  getFormGroupAt(index: number): FormGroup | null {\n    if (index >= 0 && index < this.variablesForm.length) {\n      return this.variablesForm.at(index) as FormGroup;\n    }\n    return null;\n  }\n  \n  private precomputeConfigs(): void {\n    if (!this.templateVariables) return;\n    \n    // Pre-compute all select configs\n    this.templateVariables.forEach((variable, index) => {\n      // Pre-compute regular select configs\n      if (this.shouldShowDropdown(variable)) {\n        this.getSelectConfig(variable, index);\n      }\n      \n      // Pre-compute data type select configs\n      if (this.needsDataTypeDropdown(variable)) {\n        this.getDataTypeSelectConfig(variable, index);\n      }\n    });\n  }\n  \n  private parseTestDataValue(value: string): { dataType: 'plain-text' | 'parameter' | 'runtime' | 'environment', rawValue: string } {\n    if (!value || typeof value !== 'string') {\n      return { dataType: 'plain-text', rawValue: '' };\n    }\n    \n    // Check for parameter format: @|value|\n    if (value.startsWith('@|') && value.endsWith('|')) {\n      return { dataType: 'parameter', rawValue: value.slice(2, -1) };\n    }\n    // Check for runtime format: $|value|\n    else if (value.startsWith('$|') && value.endsWith('|')) {\n      return { dataType: 'runtime', rawValue: value.slice(2, -1) };\n    }\n    // Check for environment format: *|value|\n    else if (value.startsWith('*|') && value.endsWith('|')) {\n      return { dataType: 'environment', rawValue: value.slice(2, -1) };\n    }\n    // Plain text (no formatting)\n    else {\n      return { dataType: 'plain-text', rawValue: value };\n    }\n  }\n  \n  private formatTestDataValue(rawValue: string, dataType: 'plain-text' | 'parameter' | 'runtime' | 'environment'): string {\n    if (!rawValue) {\n      return '';\n    }\n    \n    switch (dataType) {\n      case 'parameter':\n        return `@|${rawValue}|`;\n      case 'runtime':\n        return `$|${rawValue}|`;\n      case 'environment':\n        return `*|${rawValue}|`;\n      case 'plain-text':\n      default:\n        return rawValue;\n    }\n  }\n  \n  trackByVariable(index: number, variable: TemplateVariable): any {\n    return variable.name || index;\n  }\n  \n  getSelectConfig(variable: TemplateVariable, index: number): DynamicSelectFieldConfig {\n    // Use cache to avoid recalculating on every change detection\n    // For element variables, include elementOptions, hasMoreElements, and isLoadingElements in cache key\n    const optionsKey = variable.dataKey === 'element' || variable.dataKey === 'label'\n      ? this.elementOptions.map(el => String(el.name || '')).join(',') \n      : (variable.options?.join(',') || '');\n    // Include hasMoreElements and isLoadingElements in cache key for selector variables\n    const cacheKey = variable.dataKey === 'element' || variable.dataKey === 'label'\n      ? `${variable.name}_${optionsKey}_${this.hasMoreElements}_${this.isLoadingElements}`\n      : `${variable.name}_${optionsKey}`;\n    if (this.selectConfigCache.has(cacheKey)) {\n      return this.selectConfigCache.get(cacheKey)!;\n    }\n\n    // Use elementOptions if variable name is 'selector', otherwise use variable.options\n    // Extract element names from Element objects\n    let optionsArray: SelectOption[] = [];\n    if (variable.dataKey === 'element' || variable.dataKey === 'label') {\n      // For element options, use locatorValue as both id and value so the component returns locatorValue\n      // This ensures the selected value is the locatorValue (not the element id)\n      optionsArray = this.elementOptions\n        .map(el => {\n          const locatorValue = el.locatorValue || '';\n          return {\n            id: locatorValue, // Use locatorValue as id so it gets returned as the value\n            elementId: el.id?.toString() || '',\n            value: locatorValue, // Also set value for consistency\n            name: el.name,\n            label: el.name\n          };\n        });\n    } else {\n      optionsArray = variable.options?.map(opt => {return {id: opt, value: opt, name: opt, label: opt}}) as SelectOption[] || [];\n    }\n\n    console.log('optionsArray', optionsArray);\n    const config: DynamicSelectFieldConfig = {\n      key: 'value', // Use 'value' as key since we're accessing from FormArray\n      placeholder: `Select ${variable.label}`,\n      multiple: false,\n      searchable: false,\n      options: optionsArray,\n      onChange: (value: any) => {\n        this.onVariableValueChange(variable.name, value);\n      }\n    };\n    \n    // Add load more and search support for selector variables\n    if (variable.dataKey === 'element' || variable.dataKey === 'label') {\n      config.searchable = true; // Enable search for selector dropdown\n      config.serverSearch = true; // Enable server-side search\n      config.hasMore = this.hasMoreElements;\n      config.isLoading = this.isLoadingElements;\n      config.onLoadMore = () => {\n        this.loadMoreElements.emit();\n      };\n      config.onSearch = (query: string) => {\n        // Emit search event when user types in the search box\n        this.searchElements.emit(query);\n      };\n    }\n    \n    this.selectConfigCache.set(cacheKey, config);\n    return config;\n  }\n  \n  onVariableValueChange(variableName: string, value: any): void {\n    console.log(\"onVariableValueChange\", variableName, value);\n    const variable = this.templateVariables.find(v => v.name === variableName);\n    if (!variable) return;\n    \n    // If this is a test-data variable, parse and update raw value and data type\n    if (this.needsDataTypeDropdown(variable)) {\n      const { dataType, rawValue } = this.parseTestDataValue(value || '');\n      this.variableDataTypes.set(variableName, dataType);\n      this.variableRawValues.set(variableName, rawValue);\n      \n      // Update data type form control in FormArray\n      const variableGroup = this.getVariableFormGroup(variableName);\n      if (variableGroup && variableGroup.get('dataType')) {\n        variableGroup.get('dataType')?.setValue(dataType, { emitEvent: false });\n      }\n    }\n    \n    // Update the variable in templateVariables array\n    variable.value = value;\n    \n    // Also update form control in FormArray (use emitEvent: false to prevent triggering valueChanges)\n    const variableGroup = this.getVariableFormGroup(variableName);\n    if (variableGroup && variableGroup.get('value')) {\n      variableGroup.get('value')?.setValue(value, { emitEvent: false });\n    }\n    \n    // Mark for check since we're using OnPush\n    this.cdr.markForCheck();\n    \n    // Emit the change event\n    this.variableValueChange.emit({ name: variableName, value: value });\n  }\n  \n  onVariableBooleanChange(variableName: string, value: boolean): void {\n    // Update the variable in templateVariables array\n    const variable = this.templateVariables.find(v => v.name === variableName);\n    if (variable) {\n      variable.value = value;\n    }\n    // Also update form control in FormArray (use emitEvent: false to prevent triggering valueChanges)\n    const variableGroup = this.getVariableFormGroup(variableName);\n    if (variableGroup && variableGroup.get('value')) {\n      variableGroup.get('value')?.setValue(value, { emitEvent: false });\n    }\n    // Note: If variable doesn't exist in FormArray, it should be added by parent component\n    \n    // Mark for check since we're using OnPush\n    this.cdr.markForCheck();\n    \n    // Emit the change event\n    this.variableBooleanChange.emit({ name: variableName, value: value });\n  }\n  \n  shouldShowDropdown(variable: TemplateVariable): boolean {\n    // Use cache to avoid repeated calculations\n    if (this.shouldShowDropdownCache.has(variable.name)) {\n      return this.shouldShowDropdownCache.get(variable.name)!;\n    }\n    const result = variable.name === 'type' || variable.name === 'scrollTo' || variable.dataKey === 'element' || variable.dataKey === 'label';\n    this.shouldShowDropdownCache.set(variable.name, result);\n    return result;\n  }\n  \n  needsDataTypeDropdown(variable: TemplateVariable): boolean {\n    // Use cache to avoid repeated calculations\n    if (this.needsDataTypeDropdownCache.has(variable.name)) {\n      return this.needsDataTypeDropdownCache.get(variable.name)!;\n    }\n    const dataKey = variable.dataKey?.toLowerCase() || '';\n    const result = dataKey === 'test-data' || dataKey === 'source_value' || dataKey === 'target_value';\n    this.needsDataTypeDropdownCache.set(variable.name, result);\n    return result;\n  }\n  \n  getDataTypeOptions(): SelectOption[] {\n    // Return cached static array\n    return this.dataTypeOptions;\n  }\n  \n  getDataTypeSelectConfig(variable: TemplateVariable, index: number): DynamicSelectFieldConfig {\n    // Use cache to avoid recalculating on every change detection\n    const cacheKey = `${variable.name}_dataType`;\n    if (this.dataTypeSelectConfigCache.has(cacheKey)) {\n      return this.dataTypeSelectConfigCache.get(cacheKey)!;\n    }\n    \n    // Ensure form control exists in FormArray\n    const variableGroup = this.getVariableFormGroup(variable.name);\n    if (variableGroup && !variableGroup.get('dataType')) {\n      const currentDataType = this.variableDataTypes.get(variable.name) || 'plain-text';\n      variableGroup.addControl('dataType', new FormControl(currentDataType));\n    }\n    \n    const config: DynamicSelectFieldConfig = {\n      key: 'dataType', // Use 'dataType' as key since we're accessing from FormArray\n      placeholder: 'Select Type',\n      multiple: false,\n      searchable: false,\n      options: this.dataTypeOptions,\n      onChange: (value: any) => {\n        this.onDataTypeChange(variable.name, value);\n      }\n    };\n    \n    this.dataTypeSelectConfigCache.set(cacheKey, config);\n    return config;\n  }\n  \n  getCurrentDataType(variable: TemplateVariable): 'plain-text' | 'parameter' | 'runtime' | 'environment' {\n    // Simple getter - already cached in Map, no computation needed\n    return this.variableDataTypes.get(variable.name) || 'plain-text';\n  }\n  \n  getRawValue(variable: TemplateVariable): string {\n    // Simple getter - already cached in Map, no computation needed\n    return this.variableRawValues.get(variable.name) || '';\n  }\n\n  /**\n   * Check if selector variable is available in templateVariables\n   */\n  get selectorVariableAvailable(): boolean {\n    return this.templateVariables.some(v => v.dataKey === 'element' || v.dataKey === 'label');\n  }\n\n  /**\n   * Check if parameter variable is available (testData with parameter type)\n   */\n  get parameterVariableAvailable(): boolean {\n    return this.templateVariables.some(v => {\n      const dataKey = v.dataKey?.toLowerCase() || '';\n      if (dataKey === 'test-data' || dataKey === 'source_value' || dataKey === 'target_value') {\n        const dataType = this.variableDataTypes.get(v.name) || 'plain-text';\n        return dataType === 'parameter';\n      }\n      return false;\n    });\n  }\n\n  /**\n   * Check if environment variable is available (testData with environment type)\n   */\n  get environmentVariableAvailable(): boolean {\n    return this.templateVariables.some(v => {\n      const dataKey = v.name?.toLowerCase() || '';\n      if (dataKey === 'test-data' || dataKey === 'source_value' || dataKey === 'target_value') {\n        const dataType = this.variableDataTypes.get(v.name) || 'plain-text';\n        return dataType === 'environment';\n      }\n      return false;\n    });\n  }\n  \n  onDataTypeChange(variableName: string, dataType: 'plain-text' | 'parameter' | 'runtime' | 'environment'): void {\n    // Update stored data type\n    this.variableDataTypes.set(variableName, dataType);\n    \n    // Get current raw value\n    const rawValue = this.variableRawValues.get(variableName) || '';\n    \n    // Format the value based on new data type\n    const formattedValue = this.formatTestDataValue(rawValue, dataType);\n    \n    // Update variable value\n    const variable = this.templateVariables.find(v => v.name === variableName);\n    if (variable) {\n      variable.value = formattedValue;\n    }\n    \n    // Update form control in FormArray\n    const variableGroup = this.getVariableFormGroup(variableName);\n    if (variableGroup && variableGroup.get('value')) {\n      variableGroup.get('value')?.setValue(formattedValue, { emitEvent: false });\n    }\n    \n    // Mark for check since we're using OnPush\n    this.cdr.markForCheck();\n    console.log('onDataTypeChange', variableName, dataType, formattedValue);\n    // Emit the change event\n    this.variableValueChange.emit({ name: variableName, value: formattedValue });\n  }\n  \n  onElementSearch(event: { key: string; query: string }): void {\n    // Only handle search for selector variables\n    // The key will be 'value' since that's what we set in the config\n    // Emit the search query to parent component\n    this.searchElements.emit(event.query);\n  }\n\n  onTestDataValueChange(variableName: string, rawValue: string): void {\n    // Update stored raw value\n    this.variableRawValues.set(variableName, rawValue);\n    \n    // Get current data type\n    const dataType = this.variableDataTypes.get(variableName) || 'plain-text';\n    \n    // Format the value based on data type\n    const formattedValue = this.formatTestDataValue(rawValue, dataType);\n    \n    // Update variable value\n    const variable = this.templateVariables.find(v => v.name === variableName);\n    if (variable) {\n      variable.value = formattedValue;\n    }\n    \n    // Update form control in FormArray\n    const variableGroup = this.getVariableFormGroup(variableName);\n    if (variableGroup && variableGroup.get('value')) {\n      variableGroup.get('value')?.setValue(formattedValue, { emitEvent: false });\n    }\n    \n    // Mark for check since we're using OnPush\n    this.cdr.markForCheck();\n    \n    // Emit the change event\n    this.variableValueChange.emit({ name: variableName, value: formattedValue });\n  }\n}\n\n","<div class=\"cqa-flex cqa-gap-x-6 cqa-gap-y-4 cqa-flex-wrap\" *ngIf=\"!createElementVisible\">\n  <ng-container *ngFor=\"let variable of templateVariables; let i = index; trackBy: trackByVariable\">\n    <!-- Boolean variables with mat-slide-toggle -->\n    <ng-container *ngIf=\"variable.type === 'boolean'\">\n      <div class=\"cqa-flex cqa-items-center cqa-gap-2\" style=\"width: calc(50% - 12px);\">\n        <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700\">\n          {{ variable.label }}\n        </label>\n        <mat-slide-toggle [checked]=\"variablesForm.at(i)?.get('value')?.value || variable.value || false\"\n          (change)=\"onVariableBooleanChange(variable.name, $event.checked)\" color=\"primary\">\n        </mat-slide-toggle>\n      </div>\n    </ng-container>\n\n    <!-- Non-boolean, non-custom_code variables -->\n    <ng-container *ngIf=\"variable.name !== 'custom_code' && variable.type !== 'boolean'\">\n      <ng-container *ngIf=\"shouldShowDropdown(variable); else defaultInput\">\n        <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n          <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n            {{ variable.label }}\n          </label>\n          <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getSelectConfig(variable, i)\">\n          </cqa-dynamic-select>\n        </div>\n      </ng-container>\n      <ng-template #defaultInput>\n        <!-- Test-data, source-value, or target-value with data type dropdown -->\n        <ng-container *ngIf=\"needsDataTypeDropdown(variable); else regularInput\">\n          <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n              {{ variable.label }} Type\n            </label>\n            <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getDataTypeSelectConfig(variable, i)\">\n            </cqa-dynamic-select>\n          </div>\n          <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n              {{ variable.label }}\n            </label>\n            <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"getRawValue(variable)\" [fullWidth]=\"true\"\n              (valueChange)=\"onTestDataValueChange(variable.name, $event)\">\n            </cqa-custom-input>\n          </div>\n        </ng-container>\n        <ng-template #regularInput>\n          <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n              {{ variable.label }}\n            </label>\n            <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"variable.value\" [fullWidth]=\"true\"\n              (valueChange)=\"onVariableValueChange(variable.name, $event)\">\n            </cqa-custom-input>\n          </div>\n        </ng-template>\n      </ng-template>\n    </ng-container>\n  </ng-container>\n\n  <!-- Metadata -->\n  <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n    <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n      Metadata\n    </label>\n    <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"metadata\" [fullWidth]=\"true\"\n      (valueChange)=\"metadataChange.emit($event)\">\n    </cqa-custom-input>\n  </div>\n\n  <!-- Description -->\n  <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n    <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n      Description\n    </label>\n    <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"description\" [fullWidth]=\"true\"\n      (valueChange)=\"descriptionChange.emit($event)\">\n    </cqa-custom-input>\n  </div>\n</div>\n\n<div *ngIf=\"createElementVisible\">\n  <cqa-element-form\n    [isCreateMode]=\"true\"\n    [screenNameOptions]=\"screenNameOptions\"\n    [hasMoreScreenNames]=\"hasMoreScreenNames\"\n    [isLoadingScreenNames]=\"isLoadingScreenNames\"\n    [isEditInDepthAvailable]=\"false\"\n    (createElement)=\"onCreateElement($event)\"\n    (cancel)=\"onCancelElementForm()\"\n    (searchScreenName)=\"searchScreenName.emit($event)\"\n    (loadMoreScreenNames)=\"loadMoreScreenNames.emit($event)\"\n    (createScreenNameRequest)=\"createScreenNameRequest.emit($event)\">\n  </cqa-element-form>\n</div>\n<div class=\"cqa-flex cqa-justify-end cqa-pt-2\" *ngIf=\"!createElementVisible\">\n  <cqa-button \n    *ngIf=\"selectorVariableAvailable\"\n    variant=\"text\" \n    size=\"sm\"\n    text=\"Create Element\"\n    (clicked)=\"onShowElementForm()\">\n  </cqa-button>\n  <!-- <cqa-button \n    *ngIf=\"parameterVariableAvailable\"\n    variant=\"filled\" \n    text=\"Create Parameter\"\n    (clicked)=\"onCreateParameter()\">\n  </cqa-button>\n  <cqa-button \n    *ngIf=\"environmentVariableAvailable\"\n    variant=\"filled\" \n    text=\"Create Environment\"\n    (clicked)=\"onCreateEnvironment()\">\n  </cqa-button> -->\n</div>"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template-variables-form.component.js","sourceRoot":"","sources":["../../../../../../src/lib/step-builder/template-variables-form/template-variables-form.component.ts","../../../../../../src/lib/step-builder/template-variables-form/template-variables-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, OnChanges, SimpleChanges, ChangeDetectionStrategy, ChangeDetectorRef } from '@angular/core';\nimport { FormGroup, FormControl, FormArray } from '@angular/forms';\nimport { DynamicSelectFieldConfig, SelectOption } from '../../dynamic-select/dynamic-select-field.component';\nimport { ElementCreatePayload, ScreenNameOption } from '../../test-case-details/element-popup/element-popup-form-data';\n\n// Import Element type - using any for now since Element is from ts-portal-ui\n// In a real scenario, you might want to create a shared interface or import from a shared package\ninterface Element {\n  id?: number;\n  name: string;\n  locatorValue?: string;\n  otherLocator?: string[];\n  [key: string]: any;\n}\n\nexport interface TemplateVariable {\n  name: string;\n  dataKey: string;\n  label: string;\n  value: any;\n  type?: string;\n  options?: string[];\n  // Additional properties for managing variable state\n  dataType?: 'plain-text' | 'parameter' | 'runtime' | 'environment';\n  rawValue?: string; // Raw value without formatting (for select dropdowns)\n  selectedEnvironment?: string; // Selected environment name (for environment type)\n  selectedEnvironmentId?: number; // Selected environment ID (for environment type)\n  selectedTestDataProfile?: string; // Selected test data profile name (for parameter type)\n  selectedTestDataProfileId?: number; // Selected test data profile ID (for parameter type)\n  selectedDataSet?: string; // Selected data set name (for parameter type)\n}\n\n@Component({\n  selector: 'cqa-template-variables-form',\n  templateUrl: './template-variables-form.component.html',\n  styleUrls: [],\n  host: { class: 'cqa-ui-root' },\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class TemplateVariablesFormComponent implements OnChanges {\n  @Input() templateVariables: TemplateVariable[] = [];\n  @Input() variablesForm: FormArray = new FormArray([]);\n  @Input() metadata: string = '';\n  @Input() description: string = '';\n  @Input() elementOptions: Element[] = []; // Element objects for element dropdown\n  @Input() hasMoreElements: boolean = false; // Whether more elements are available\n  @Input() isLoadingElements: boolean = false; // Loading state for elements\n  /** Screen name options for element form autocomplete (from API) */\n  @Input() screenNameOptions: ScreenNameOption[] = [];\n  /** Whether more screen names are available for infinite scroll */\n  @Input() hasMoreScreenNames: boolean = false;\n  /** True while parent is loading screen names (search or load more) */\n  @Input() isLoadingScreenNames: boolean = false;\n  /** Test data profiles for parameter dropdown (from API) - raw TestData objects */\n  @Input() parameterOptions: any[] = []; // TestData[] - using any to avoid circular dependency\n  /** Whether more parameters are available for infinite scroll */\n  @Input() hasMoreParameters: boolean = false;\n  /** True while parent is loading parameters (search or load more) */\n  @Input() isLoadingParameters: boolean = false;\n  /** Environment options for environment parameter dropdown (from API) */\n  @Input() environmentOptions: { id: string; name: string; value: string; environment: string }[] = [];\n  /** Whether more environments are available for infinite scroll */\n  @Input() hasMoreEnvironments: boolean = false;\n  /** True while parent is loading environments (search or load more) */\n  @Input() isLoadingEnvironments: boolean = false;\n  /** Default test data profile ID from test case (if available, profile and data set dropdowns will be disabled) */\n  @Input() defaultTestDataProfileId?: number;\n  /** Default test data start index from test case (data set index in the profile) */\n  @Input() defaultTestDataStartIndex?: number;\n  \n  @Output() variableValueChange = new EventEmitter<{ name: string; value: any }>();\n  @Output() variableBooleanChange = new EventEmitter<{ name: string; value: boolean }>();\n  @Output() metadataChange = new EventEmitter<string>();\n  @Output() descriptionChange = new EventEmitter<string>();\n  @Output() loadMoreElements = new EventEmitter<void>(); // Emit when load more is requested\n  @Output() searchElements = new EventEmitter<string>(); // Emit when user searches for elements\n  @Output() createElement = new EventEmitter<ElementCreatePayload>(); // Emit when element is created with payload\n  @Output() searchScreenName = new EventEmitter<string>(); // Emit when user searches screen names\n  @Output() loadMoreScreenNames = new EventEmitter<string>(); // Emit when user scrolls to load more screen names\n  @Output() createScreenNameRequest = new EventEmitter<string>(); // Emit when user requests to create a new screen name\n  @Output() searchParameters = new EventEmitter<string>(); // Emit when user searches for parameters\n  @Output() loadMoreParameters = new EventEmitter<void>(); // Emit when user scrolls to load more parameters\n  @Output() searchEnvironments = new EventEmitter<string>(); // Emit when user searches for environments\n  @Output() loadMoreEnvironments = new EventEmitter<void>(); // Emit when user scrolls to load more environments\n  @Output() cancelElementForm = new EventEmitter<void>(); // Emit when element form is cancelled\n  @Output() elementFormVisibilityChange = new EventEmitter<boolean>(); // Emit when element form visibility changes\n  \n  // Cache for select configs to avoid recalculating on every change detection\n  private selectConfigCache: Map<string, DynamicSelectFieldConfig> = new Map();\n  \n  // Cache for data type select configs\n  private dataTypeSelectConfigCache: Map<string, DynamicSelectFieldConfig> = new Map();\n  \n  // Cache for parameter select configs\n  private parameterSelectConfigCache: Map<string, DynamicSelectFieldConfig> = new Map();\n  \n  // Cache for environment select configs\n  private environmentSelectConfigCache: Map<string, DynamicSelectFieldConfig> = new Map();\n  \n  // Cache for environment parameter select configs\n  private environmentParameterSelectConfigCache: Map<string, DynamicSelectFieldConfig> = new Map();\n  \n  // Cache for test data profile select configs (first dropdown for parameters)\n  private testDataProfileSelectConfigCache: Map<string, DynamicSelectFieldConfig> = new Map();\n  \n  // Cache for data set select configs (second dropdown for parameters - shows data sets from selected profile)\n  private dataSetSelectConfigCache: Map<string, DynamicSelectFieldConfig> = new Map();\n  \n  // Cache for parameter select configs for a specific data set (third dropdown for parameters)\n  private parameterForDataSetSelectConfigCache: Map<string, DynamicSelectFieldConfig> = new Map();\n  \n  // Cache for computed properties\n  private needsDataTypeDropdownCache: Map<string, boolean> = new Map();\n  private shouldShowDropdownCache: Map<string, boolean> = new Map();\n  \n  // Pre-computed data type options (static, no need to recreate)\n  private readonly dataTypeOptions: SelectOption[] = [\n    { id: 'plain-text', value: 'plain-text', name: 'Plain Text', label: 'Plain Text' },\n    { id: 'parameter', value: 'parameter', name: '@|Parameter|', label: '@|Parameter|' },\n    { id: 'runtime', value: 'runtime', name: '$|Runtime|', label: '$|Runtime|' },\n    { id: 'environment', value: 'environment', name: '*|Environment|', label: '*|Environment|' }\n  ];\n\n  @Input() createElementVisible: boolean = false;\n  \n  constructor(private cdr: ChangeDetectorRef) {}\n\n  onCreateElement(payload: ElementCreatePayload): void {\n    console.log('onCreateElement', payload);\n    this.createElement.emit(payload);\n    this.elementFormVisibilityChange.emit(false);\n    this.cdr.markForCheck();\n  }\n\n  onCancelElementForm(): void {\n    this.elementFormVisibilityChange.emit(false);\n    this.cancelElementForm.emit();\n    this.cdr.markForCheck();\n  }\n  \n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['templateVariables'] || changes['variablesForm'] || changes['elementOptions'] || \n        changes['hasMoreElements'] || changes['isLoadingElements'] ||\n        changes['parameterOptions'] || changes['hasMoreParameters'] || changes['isLoadingParameters'] ||\n        changes['environmentOptions'] || changes['hasMoreEnvironments'] || changes['isLoadingEnvironments'] ||\n        changes['defaultTestDataProfileId'] || changes['defaultTestDataStartIndex']) {\n      // Clear all caches when inputs change\n      this.selectConfigCache.clear();\n      this.dataTypeSelectConfigCache.clear();\n      this.parameterSelectConfigCache.clear();\n      this.environmentSelectConfigCache.clear();\n      this.environmentParameterSelectConfigCache.clear();\n      this.testDataProfileSelectConfigCache.clear();\n      this.dataSetSelectConfigCache.clear();\n      this.parameterForDataSetSelectConfigCache.clear();\n      this.needsDataTypeDropdownCache.clear();\n      this.shouldShowDropdownCache.clear();\n      \n      // Initialize data types and raw values for test-data variables\n      // Also re-initialize if default values or parameterOptions change (to set default selections)\n      if ((changes['templateVariables'] || changes['defaultTestDataProfileId'] || changes['defaultTestDataStartIndex'] || changes['parameterOptions']) && this.templateVariables) {\n        this.initializeTestDataVariables();\n      }\n      \n      // Pre-compute all configs to avoid calling methods in template\n      this.precomputeConfigs();\n      \n      // If environment options changed and we have selected environments, refresh parameter configs\n      if (changes['environmentOptions']) {\n        this.templateVariables.forEach((variable, index) => {\n          if (this.isEnvironmentType(variable) && variable.selectedEnvironment) {\n            // Clear and recompute environment parameter config\n            this.environmentParameterSelectConfigCache.delete(`${variable.name}_envParam`);\n            this.getEnvironmentParameterSelectConfig(variable, index);\n          }\n        });\n      }\n      \n      // If parameter options changed and we have default values, try to initialize them\n      if (changes['parameterOptions'] && this.defaultTestDataProfileId && this.defaultTestDataStartIndex != null && this.parameterOptions.length > 0) {\n        // Re-initialize to set default values now that parameterOptions are available\n        console.log('Re-initializing with default values after parameterOptions loaded');\n        this.initializeTestDataVariables();\n        // Force change detection after initialization\n        this.cdr.markForCheck();\n      }\n      \n      // If parameter options changed and we have selected test data profiles, refresh configs\n      if (changes['parameterOptions'] || changes['defaultTestDataProfileId'] || changes['defaultTestDataStartIndex']) {\n        // Clear test data profile select config cache since profiles list may have changed\n        this.testDataProfileSelectConfigCache.clear();\n        \n        this.templateVariables.forEach((variable, index) => {\n          if (this.isParameterType(variable)) {\n            // Recompute test data profile config\n            this.getTestDataProfileSelectConfig(variable, index);\n            \n            // If a profile is already selected, recompute data set config\n            if (variable.selectedTestDataProfile) {\n              this.getDataSetSelectConfig(variable, index);\n              \n              // If a data set is already selected, recompute parameter config\n              if (variable.selectedDataSet) {\n                // Clear and recompute parameter config for the selected data set\n                // Use profile ID if available for cache key\n                const profileIdentifier = variable.selectedTestDataProfileId ? String(variable.selectedTestDataProfileId) : variable.selectedTestDataProfile;\n                this.parameterForDataSetSelectConfigCache.delete(`${variable.name}_paramForDataSet_${profileIdentifier}_${variable.selectedDataSet}`);\n                this.getParameterSelectConfig(variable, index);\n              }\n            }\n          }\n        });\n      }\n      \n      // Mark for check since we're using OnPush\n      this.cdr.markForCheck();\n    }\n  }\n  \n  private initializeTestDataVariables(): void {\n    this.templateVariables.forEach((variable, index) => {\n      if (this.needsDataTypeDropdown(variable)) {\n        const { dataType, rawValue } = this.parseTestDataValue(variable.value || '');\n        // Set properties directly on the variable object\n        variable.dataType = dataType;\n        variable.rawValue = rawValue;\n        \n        // Ensure form control exists for data type in the FormArray\n        const variableGroup = this.getVariableFormGroup(variable.name);\n        if (variableGroup) {\n          if (!variableGroup.get('dataType')) {\n            variableGroup.addControl('dataType', new FormControl(dataType));\n          } else {\n            variableGroup.get('dataType')?.setValue(dataType, { emitEvent: false });\n          }\n          \n          // For parameter type, parse the value to extract test data profile and parameter\n          if (dataType === 'parameter') {\n            // Check if default test data profile and data set are provided from test case\n            // Only proceed if parameterOptions are loaded\n            if (this.defaultTestDataProfileId && this.defaultTestDataStartIndex != null && this.parameterOptions.length > 0) {\n              // Find the test data profile by ID\n              const defaultProfile = this.parameterOptions.find((testData: any) => testData.id === this.defaultTestDataProfileId);\n              if (defaultProfile && defaultProfile.data && defaultProfile.data.length > this.defaultTestDataStartIndex) {\n                const defaultDataSet = defaultProfile.data[this.defaultTestDataStartIndex];\n                const profileName = defaultProfile.name || defaultProfile.testDataName;\n                const dataSetName = defaultDataSet.name;\n                \n                // Set variable properties - this ensures hasSelectedTestDataProfile() and hasSelectedDataSet() return true\n                variable.selectedTestDataProfile = profileName;\n                variable.selectedTestDataProfileId = defaultProfile.id;\n                variable.selectedDataSet = dataSetName;\n                \n                // Set form controls with the actual values so dropdowns display selected options\n                if (!variableGroup.get('selectedTestDataProfile')) {\n                  variableGroup.addControl('selectedTestDataProfile', new FormControl(profileName));\n                } else {\n                  variableGroup.get('selectedTestDataProfile')?.setValue(profileName, { emitEvent: false });\n                }\n                if (!variableGroup.get('selectedDataSet')) {\n                  variableGroup.addControl('selectedDataSet', new FormControl(dataSetName));\n                } else {\n                  variableGroup.get('selectedDataSet')?.setValue(dataSetName, { emitEvent: false });\n                }\n                // Don't set parameter value yet - user will select it\n                if (variableGroup.get('value')) {\n                  variableGroup.get('value')?.setValue('', { emitEvent: false });\n                }\n                \n                // Clear caches to force recomputation of configs with new values\n                // Clear all cache entries for this variable to ensure fresh configs\n                this.testDataProfileSelectConfigCache.delete(`${variable.name}_testDataProfile`);\n                // Clear data set cache - need to clear all possible keys since we don't know the exact format\n                const dataSetKeysToDelete: string[] = [];\n                this.dataSetSelectConfigCache.forEach((value, key) => {\n                  if (key.startsWith(`${variable.name}_dataSet`)) {\n                    dataSetKeysToDelete.push(key);\n                  }\n                });\n                dataSetKeysToDelete.forEach(key => this.dataSetSelectConfigCache.delete(key));\n                // Clear parameter cache - need to clear all possible keys\n                const paramKeysToDelete: string[] = [];\n                this.parameterForDataSetSelectConfigCache.forEach((value, key) => {\n                  if (key.startsWith(`${variable.name}_paramForDataSet`)) {\n                    paramKeysToDelete.push(key);\n                  }\n                });\n                paramKeysToDelete.forEach(key => this.parameterForDataSetSelectConfigCache.delete(key));\n                \n                console.log('Default test data initialized:', {\n                  variableName: variable.name,\n                  profileName,\n                  profileId: defaultProfile.id,\n                  dataSetName,\n                  hasSelectedProfile: !!variable.selectedTestDataProfile,\n                  hasSelectedDataSet: !!variable.selectedDataSet\n                });\n              } else {\n                console.warn('Default test data profile not found or invalid:', {\n                  defaultTestDataProfileId: this.defaultTestDataProfileId,\n                  defaultTestDataStartIndex: this.defaultTestDataStartIndex,\n                  parameterOptionsLength: this.parameterOptions.length,\n                  foundProfile: !!defaultProfile\n                });\n              }\n            } else {\n              // No default values - use existing logic to find from parameter value\n              const paramName = rawValue;\n              if (paramName) {\n                // Find the test data profile and data set that contains this parameter\n                // Search through all test data profiles and their data sets\n                let foundProfile: any = null;\n                let foundDataSet: any = null;\n                \n                for (const testDataProfile of this.parameterOptions) {\n                  if (testDataProfile.data && testDataProfile.data.length > 0) {\n                    // Search through all data sets in this profile\n                    for (const dataSet of testDataProfile.data) {\n                      if (dataSet && dataSet.data && dataSet.data.hasOwnProperty(paramName)) {\n                        foundProfile = testDataProfile;\n                        foundDataSet = dataSet;\n                        break;\n                      }\n                    }\n                    if (foundProfile) break;\n                  }\n                }\n                \n                if (foundProfile && foundDataSet) {\n                  const profileName = foundProfile.name || foundProfile.testDataName;\n                  const dataSetName = foundDataSet.name;\n                  \n                  variable.selectedTestDataProfile = profileName;\n                  variable.selectedTestDataProfileId = foundProfile.id;\n                  variable.selectedDataSet = dataSetName;\n                  \n                  // Set form controls\n                  if (!variableGroup.get('selectedTestDataProfile')) {\n                    variableGroup.addControl('selectedTestDataProfile', new FormControl(profileName));\n                  } else {\n                    variableGroup.get('selectedTestDataProfile')?.setValue(profileName, { emitEvent: false });\n                  }\n                  if (!variableGroup.get('selectedDataSet')) {\n                    variableGroup.addControl('selectedDataSet', new FormControl(dataSetName));\n                  } else {\n                    variableGroup.get('selectedDataSet')?.setValue(dataSetName, { emitEvent: false });\n                  }\n                  // Set form control to param name (for dropdown display)\n                  if (variableGroup.get('value')) {\n                    variableGroup.get('value')?.setValue(paramName, { emitEvent: false });\n                  }\n                  // Ensure variable.value is formatted correctly as @|paramName|\n                  variable.value = this.formatTestDataValue(paramName, 'parameter');\n                } else {\n                  // If parameter not found, format the raw value if it's a parameter type\n                  if (variableGroup.get('value')) {\n                    variableGroup.get('value')?.setValue(rawValue, { emitEvent: false });\n                  }\n                  // Ensure variable.value is formatted correctly\n                  variable.value = this.formatTestDataValue(rawValue, dataType);\n                }\n              }\n            }\n          }\n          \n          // For environment type, parse the value to extract environment and parameter\n          if (dataType === 'environment') {\n            // Environment values are in format *|parameterName|\n            // We need to find which environment this parameter belongs to\n            const paramName = rawValue;\n            if (paramName) {\n              // Find the environment that contains this parameter\n              const envOption = this.environmentOptions.find(env => env.name === paramName);\n              if (envOption) {\n                variable.selectedEnvironment = envOption.environment;\n                \n                // Extract and store environment ID\n                const idMatch = envOption.id.match(/env-(\\d+)-/);\n                if (idMatch && idMatch[1]) {\n                  variable.selectedEnvironmentId = parseInt(idMatch[1], 10);\n                }\n                \n                // Set form controls\n                if (!variableGroup.get('selectedEnvironment')) {\n                  variableGroup.addControl('selectedEnvironment', new FormControl(envOption.environment));\n                } else {\n                  variableGroup.get('selectedEnvironment')?.setValue(envOption.environment, { emitEvent: false });\n                }\n                if (variableGroup.get('value')) {\n                  variableGroup.get('value')?.setValue(`*|${paramName}|`, { emitEvent: false });\n                }\n              }\n            }\n          }\n        }\n      }\n    });\n  }\n  \n  /** Get form group for a variable by name from FormArray */\n  getVariableFormGroup(variableName: string): FormGroup | null {\n    const variableIndex = this.variablesForm.controls.findIndex(\n      control => (control as FormGroup).get('name')?.value === variableName\n    );\n    if (variableIndex !== -1) {\n      return this.variablesForm.at(variableIndex) as FormGroup;\n    }\n    return null;\n  }\n  \n  /** Get form group at a specific index from FormArray (for template use) */\n  getFormGroupAt(index: number): FormGroup | null {\n    if (index >= 0 && index < this.variablesForm.length) {\n      return this.variablesForm.at(index) as FormGroup;\n    }\n    return null;\n  }\n  \n  private precomputeConfigs(): void {\n    if (!this.templateVariables) return;\n    \n    // Pre-compute all select configs\n    this.templateVariables.forEach((variable, index) => {\n      // Pre-compute regular select configs\n      if (this.shouldShowDropdown(variable)) {\n        this.getSelectConfig(variable, index);\n      }\n      \n      // Pre-compute data type select configs\n      if (this.needsDataTypeDropdown(variable)) {\n        this.getDataTypeSelectConfig(variable, index);\n        // Pre-compute parameter and environment select configs if needed\n        const dataType = variable.dataType || 'plain-text';\n        if (dataType === 'parameter') {\n          this.getTestDataProfileSelectConfig(variable, index);\n          // Pre-compute data set config if test data profile is already selected\n          if (variable.selectedTestDataProfile) {\n            this.getDataSetSelectConfig(variable, index);\n            // Pre-compute parameter config if data set is already selected\n            if (variable.selectedDataSet) {\n              this.getParameterSelectConfig(variable, index);\n            }\n          }\n        } else if (dataType === 'environment') {\n          this.getEnvironmentSelectConfig(variable, index);\n          // Pre-compute environment parameter config if environment is already selected\n          if (variable.selectedEnvironment) {\n            this.getEnvironmentParameterSelectConfig(variable, index);\n          }\n        }\n      }\n    });\n  }\n  \n  private parseTestDataValue(value: string): { dataType: 'plain-text' | 'parameter' | 'runtime' | 'environment', rawValue: string } {\n    if (!value || typeof value !== 'string') {\n      return { dataType: 'plain-text', rawValue: '' };\n    }\n    \n    // Check for parameter format: @|value|\n    if (value.startsWith('@|') && value.endsWith('|')) {\n      return { dataType: 'parameter', rawValue: value.slice(2, -1) };\n    }\n    // Check for runtime format: $|value|\n    else if (value.startsWith('$|') && value.endsWith('|')) {\n      return { dataType: 'runtime', rawValue: value.slice(2, -1) };\n    }\n    // Check for environment format: *|value|\n    else if (value.startsWith('*|') && value.endsWith('|')) {\n      return { dataType: 'environment', rawValue: value.slice(2, -1) };\n    }\n    // Plain text (no formatting)\n    else {\n      return { dataType: 'plain-text', rawValue: value };\n    }\n  }\n  \n  private formatTestDataValue(rawValue: string, dataType: 'plain-text' | 'parameter' | 'runtime' | 'environment'): string {\n    if (!rawValue) {\n      return '';\n    }\n    \n    switch (dataType) {\n      case 'parameter':\n        return `@|${rawValue}|`;\n      case 'runtime':\n        return `$|${rawValue}|`;\n      case 'environment':\n        return `*|${rawValue}|`;\n      case 'plain-text':\n      default:\n        return rawValue;\n    }\n  }\n  \n  trackByVariable(index: number, variable: TemplateVariable): any {\n    return variable.name || index;\n  }\n  \n  getSelectConfig(variable: TemplateVariable, index: number): DynamicSelectFieldConfig {\n    // Use cache to avoid recalculating on every change detection\n    // For element variables, include elementOptions, hasMoreElements, and isLoadingElements in cache key\n    const optionsKey = variable.dataKey === 'element' || variable.dataKey === 'label'\n      ? this.elementOptions.map(el => String(el.name || '')).join(',') \n      : (variable.options?.join(',') || '');\n    // Include hasMoreElements and isLoadingElements in cache key for selector variables\n    const cacheKey = variable.dataKey === 'element' || variable.dataKey === 'label'\n      ? `${variable.name}_${optionsKey}_${this.hasMoreElements}_${this.isLoadingElements}`\n      : `${variable.name}_${optionsKey}`;\n    if (this.selectConfigCache.has(cacheKey)) {\n      return this.selectConfigCache.get(cacheKey)!;\n    }\n\n    // Use elementOptions if variable name is 'selector', otherwise use variable.options\n    // Extract element names from Element objects\n    let optionsArray: SelectOption[] = [];\n    if (variable.dataKey === 'element' || variable.dataKey === 'label') {\n      // For element options, use locatorValue as both id and value so the component returns locatorValue\n      // This ensures the selected value is the locatorValue (not the element id)\n      optionsArray = this.elementOptions\n        .map(el => {\n          const locatorValue = el.locatorValue || '';\n          return {\n            id: locatorValue, // Use locatorValue as id so it gets returned as the value\n            elementId: el.id?.toString() || '',\n            value: locatorValue, // Also set value for consistency\n            name: el.name,\n            label: el.name\n          };\n        });\n    } else {\n      optionsArray = variable.options?.map(opt => {return {id: opt, value: opt, name: opt, label: opt}}) as SelectOption[] || [];\n    }\n\n    console.log('optionsArray', optionsArray);\n    const config: DynamicSelectFieldConfig = {\n      key: 'value', // Use 'value' as key since we're accessing from FormArray\n      placeholder: `Select ${variable.label}`,\n      multiple: false,\n      searchable: false,\n      options: optionsArray,\n      onChange: (value: any) => {\n        this.onVariableValueChange(variable.name, value);\n      }\n    };\n    \n    // Add load more and search support for selector variables\n    if (variable.dataKey === 'element' || variable.dataKey === 'label') {\n      config.searchable = true; // Enable search for selector dropdown\n      config.serverSearch = true; // Enable server-side search\n      config.hasMore = this.hasMoreElements;\n      config.isLoading = this.isLoadingElements;\n      config.onLoadMore = () => {\n        this.loadMoreElements.emit();\n      };\n      config.onSearch = (query: string) => {\n        // Emit search event when user types in the search box\n        this.searchElements.emit(query);\n      };\n    }\n    \n    this.selectConfigCache.set(cacheKey, config);\n    return config;\n  }\n  \n  onVariableValueChange(variableName: string, value: any): void {\n    console.log(\"onVariableValueChange\", variableName, value);\n    const variable = this.templateVariables.find(v => v.name === variableName);\n    if (!variable) return;\n    \n    // If this is a test-data variable, parse and update raw value and data type\n    if (this.needsDataTypeDropdown(variable)) {\n      const { dataType, rawValue } = this.parseTestDataValue(value || '');\n      variable.dataType = dataType;\n      variable.rawValue = rawValue;\n      \n      // Update data type form control in FormArray\n      const variableGroup = this.getVariableFormGroup(variableName);\n      if (variableGroup && variableGroup.get('dataType')) {\n        variableGroup.get('dataType')?.setValue(dataType, { emitEvent: false });\n      }\n    }\n    \n    // Update the variable in templateVariables array\n    variable.value = value;\n    \n    // Also update form control in FormArray (use emitEvent: false to prevent triggering valueChanges)\n    const variableGroup = this.getVariableFormGroup(variableName);\n    if (variableGroup && variableGroup.get('value')) {\n      variableGroup.get('value')?.setValue(value, { emitEvent: false });\n    }\n    \n    // Mark for check since we're using OnPush\n    this.cdr.markForCheck();\n    \n    // Emit the change event\n    this.variableValueChange.emit({ name: variableName, value: value });\n  }\n  \n  onVariableBooleanChange(variableName: string, value: boolean): void {\n    // Update the variable in templateVariables array\n    const variable = this.templateVariables.find(v => v.name === variableName);\n    if (variable) {\n      variable.value = value;\n    }\n    // Also update form control in FormArray (use emitEvent: false to prevent triggering valueChanges)\n    const variableGroup = this.getVariableFormGroup(variableName);\n    if (variableGroup && variableGroup.get('value')) {\n      variableGroup.get('value')?.setValue(value, { emitEvent: false });\n    }\n    // Note: If variable doesn't exist in FormArray, it should be added by parent component\n    \n    // Mark for check since we're using OnPush\n    this.cdr.markForCheck();\n    \n    // Emit the change event\n    this.variableBooleanChange.emit({ name: variableName, value: value });\n  }\n  \n  shouldShowDropdown(variable: TemplateVariable): boolean {\n    // Use cache to avoid repeated calculations\n    if (this.shouldShowDropdownCache.has(variable.name)) {\n      return this.shouldShowDropdownCache.get(variable.name)!;\n    }\n    const result = variable.name === 'type' || variable.name === 'scrollTo' || variable.dataKey === 'element' || variable.dataKey === 'label';\n    this.shouldShowDropdownCache.set(variable.name, result);\n    return result;\n  }\n  \n  needsDataTypeDropdown(variable: TemplateVariable): boolean {\n    // Use cache to avoid repeated calculations\n    if (this.needsDataTypeDropdownCache.has(variable.name)) {\n      return this.needsDataTypeDropdownCache.get(variable.name)!;\n    }\n    const dataKey = variable.dataKey?.toLowerCase() || '';\n    const result = dataKey === 'test_data' || dataKey === 'source_value' || dataKey === 'target_value';\n    this.needsDataTypeDropdownCache.set(variable.name, result);\n    return result;\n  }\n  \n  getDataTypeOptions(): SelectOption[] {\n    // Return cached static array\n    return this.dataTypeOptions;\n  }\n  \n  getDataTypeSelectConfig(variable: TemplateVariable, index: number): DynamicSelectFieldConfig {\n    // Use cache to avoid recalculating on every change detection\n    const cacheKey = `${variable.name}_dataType`;\n    if (this.dataTypeSelectConfigCache.has(cacheKey)) {\n      return this.dataTypeSelectConfigCache.get(cacheKey)!;\n    }\n    \n    // Ensure form control exists in FormArray\n    const variableGroup = this.getVariableFormGroup(variable.name);\n    if (variableGroup && !variableGroup.get('dataType')) {\n      const currentDataType = variable.dataType || 'plain-text';\n      variableGroup.addControl('dataType', new FormControl(currentDataType));\n    }\n    \n    const config: DynamicSelectFieldConfig = {\n      key: 'dataType', // Use 'dataType' as key since we're accessing from FormArray\n      placeholder: 'Select Type',\n      multiple: false,\n      searchable: false,\n      options: this.dataTypeOptions,\n      onChange: (value: any) => {\n        this.onDataTypeChange(variable.name, value);\n      }\n    };\n    \n    this.dataTypeSelectConfigCache.set(cacheKey, config);\n    return config;\n  }\n  \n  getCurrentDataType(variable: TemplateVariable): 'plain-text' | 'parameter' | 'runtime' | 'environment' {\n    return variable.dataType || 'plain-text';\n  }\n  \n  getRawValue(variable: TemplateVariable): string {\n    return variable.rawValue || '';\n  }\n\n  /**\n   * Check if selector variable is available in templateVariables\n   */\n  get selectorVariableAvailable(): boolean {\n    return this.templateVariables.some(v => v.dataKey === 'element' || v.dataKey === 'label');\n  }\n\n  /**\n   * Check if parameter variable is available (testData with parameter type)\n   */\n  get parameterVariableAvailable(): boolean {\n    return this.templateVariables.some(v => {\n      const dataKey = v.dataKey?.toLowerCase() || '';\n      if (dataKey === 'test_data' || dataKey === 'source_value' || dataKey === 'target_value') {\n        const dataType = v.dataType || 'plain-text';\n        return dataType === 'parameter';\n      }\n      return false;\n    });\n  }\n\n  /**\n   * Check if environment variable is available (testData with environment type)\n   */\n  get environmentVariableAvailable(): boolean {\n    return this.templateVariables.some(v => {\n      const dataKey = v.dataKey?.toLowerCase() || '';\n      if (dataKey === 'test_data' || dataKey === 'source_value' || dataKey === 'target_value') {\n        const dataType = v.dataType || 'plain-text';\n        return dataType === 'environment';\n      }\n      return false;\n    });\n  }\n  \n  onDataTypeChange(variableName: string, dataType: 'plain-text' | 'parameter' | 'runtime' | 'environment'): void {\n    // Find the variable\n    const variable = this.templateVariables.find(v => v.name === variableName);\n    if (!variable) return;\n    \n    // Update stored data type on the variable object\n    variable.dataType = dataType;\n    \n    // Clear parameter and environment select config caches since data type changed\n    this.testDataProfileSelectConfigCache.delete(`${variableName}_testDataProfile`);\n    this.dataSetSelectConfigCache.delete(`${variableName}_dataSet`);\n    this.parameterForDataSetSelectConfigCache.delete(`${variableName}_paramForDataSet`);\n    this.environmentSelectConfigCache.delete(`${variableName}_environment`);\n    this.environmentParameterSelectConfigCache.delete(`${variableName}_envParam`);\n    \n    // Clear selected test data profile and data set if switching away from parameter type\n    if (dataType !== 'parameter') {\n      variable.selectedTestDataProfile = undefined;\n      variable.selectedTestDataProfileId = undefined;\n      variable.selectedDataSet = undefined;\n    }\n    \n    // Clear selected environment if switching away from environment type\n    if (dataType !== 'environment') {\n      variable.selectedEnvironment = undefined;\n      variable.selectedEnvironmentId = undefined;\n    }\n    \n    // Get current raw value\n    const rawValue = variable.rawValue || '';\n    \n    // Format the value based on new data type\n    const formattedValue = this.formatTestDataValue(rawValue, dataType);\n    \n    // Update variable value (always store formatted value in variable)\n    variable.value = formattedValue;\n    \n    // Update form control in FormArray\n    const variableGroup = this.getVariableFormGroup(variableName);\n    if (variableGroup) {\n      if (variableGroup.get('value')) {\n        // For parameter type, set form control to raw value so select can display it\n        if (dataType === 'parameter') {\n          variableGroup.get('value')?.setValue(rawValue, { emitEvent: false });\n        } else if (dataType === 'environment') {\n          // For environment type, clear value and selectedEnvironment\n          variableGroup.get('value')?.setValue('', { emitEvent: false });\n          if (variableGroup.get('selectedEnvironment')) {\n            variableGroup.get('selectedEnvironment')?.setValue('', { emitEvent: false });\n          }\n        } else {\n          variableGroup.get('value')?.setValue(formattedValue, { emitEvent: false });\n        }\n      }\n      \n      // Remove selectedEnvironment control if not environment type\n      if (dataType !== 'environment' && variableGroup.get('selectedEnvironment')) {\n        variableGroup.removeControl('selectedEnvironment');\n      }\n    }\n    \n    // If switching to parameter type, check for default values and initialize them\n    if (dataType === 'parameter') {\n      const index = this.templateVariables.indexOf(variable);\n      // Check if default test data profile and data set are provided from test case\n      if (this.defaultTestDataProfileId && this.defaultTestDataStartIndex != null && this.parameterOptions.length > 0) {\n        // Find the test data profile by ID\n        const defaultProfile = this.parameterOptions.find((testData: any) => testData.id === this.defaultTestDataProfileId);\n        if (defaultProfile && defaultProfile.data && defaultProfile.data.length > this.defaultTestDataStartIndex) {\n          const defaultDataSet = defaultProfile.data[this.defaultTestDataStartIndex];\n          const profileName = defaultProfile.name || defaultProfile.testDataName;\n          const dataSetName = defaultDataSet.name;\n          \n          // Set variable properties - this ensures hasSelectedTestDataProfile() and hasSelectedDataSet() return true\n          variable.selectedTestDataProfile = profileName;\n          variable.selectedTestDataProfileId = defaultProfile.id;\n          variable.selectedDataSet = dataSetName;\n          \n          // Set form controls with the actual values so dropdowns display selected options\n          if (variableGroup) {\n            if (!variableGroup.get('selectedTestDataProfile')) {\n              variableGroup.addControl('selectedTestDataProfile', new FormControl(profileName));\n            } else {\n              variableGroup.get('selectedTestDataProfile')?.setValue(profileName, { emitEvent: false });\n            }\n            if (!variableGroup.get('selectedDataSet')) {\n              variableGroup.addControl('selectedDataSet', new FormControl(dataSetName));\n            } else {\n              variableGroup.get('selectedDataSet')?.setValue(dataSetName, { emitEvent: false });\n            }\n          }\n          \n          // Clear caches to force recomputation of configs with new values\n          this.testDataProfileSelectConfigCache.delete(`${variableName}_testDataProfile`);\n          const dataSetKeysToDelete: string[] = [];\n          this.dataSetSelectConfigCache.forEach((value, key) => {\n            if (key.startsWith(`${variableName}_dataSet`)) {\n              dataSetKeysToDelete.push(key);\n            }\n          });\n          dataSetKeysToDelete.forEach(key => this.dataSetSelectConfigCache.delete(key));\n          const paramKeysToDelete: string[] = [];\n          this.parameterForDataSetSelectConfigCache.forEach((value, key) => {\n            if (key.startsWith(`${variableName}_paramForDataSet`)) {\n              paramKeysToDelete.push(key);\n            }\n          });\n          paramKeysToDelete.forEach(key => this.parameterForDataSetSelectConfigCache.delete(key));\n        }\n      }\n    }\n    \n    // Pre-compute the new select config if needed\n    if (variable) {\n      const index = this.templateVariables.indexOf(variable);\n      if (dataType === 'parameter') {\n        // Pre-compute test data profile config\n        this.getTestDataProfileSelectConfig(variable, index);\n        // If a profile is already selected, pre-compute data set config\n        if (variable.selectedTestDataProfile) {\n          this.getDataSetSelectConfig(variable, index);\n          // If a data set is already selected, pre-compute parameter config\n          if (variable.selectedDataSet) {\n            this.getParameterSelectConfig(variable, index);\n          }\n        }\n      } else if (dataType === 'environment') {\n        this.getEnvironmentSelectConfig(variable, index);\n      }\n    }\n    \n    // Mark for check since we're using OnPush\n    this.cdr.markForCheck();\n    console.log('onDataTypeChange', variableName, dataType, formattedValue);\n    // Emit the change event with formatted value\n    this.variableValueChange.emit({ name: variableName, value: formattedValue });\n  }\n  \n  onElementSearch(event: { key: string; query: string }): void {\n    // Only handle search for selector variables\n    // The key will be 'value' since that's what we set in the config\n    // Emit the search query to parent component\n    this.searchElements.emit(event.query);\n  }\n\n  onTestDataValueChange(variableName: string, rawValue: string): void {\n    // Find the variable\n    const variable = this.templateVariables.find(v => v.name === variableName);\n    if (!variable) return;\n    \n    // Update stored raw value on the variable object\n    variable.rawValue = rawValue;\n    \n    // Get current data type\n    const dataType = variable.dataType || 'plain-text';\n    \n    // Format the value based on data type\n    const formattedValue = this.formatTestDataValue(rawValue, dataType);\n    \n    // Update variable value\n    variable.value = formattedValue;\n    \n    // Update form control in FormArray\n    const variableGroup = this.getVariableFormGroup(variableName);\n    if (variableGroup && variableGroup.get('value')) {\n      variableGroup.get('value')?.setValue(formattedValue, { emitEvent: false });\n    }\n    \n    // Mark for check since we're using OnPush\n    this.cdr.markForCheck();\n    \n    // Emit the change event\n    this.variableValueChange.emit({ name: variableName, value: formattedValue });\n  }\n\n  /**\n   * Get unique test data profiles from parameter options (raw TestData objects)\n   */\n  getUniqueTestDataProfiles(): { id: string; name: string }[] {\n    const profileMap = new Map<string, { id: string; name: string }>();\n    this.parameterOptions.forEach((testData: any) => {\n      // testData.name is the testDataName (profile name)\n      const profileName = testData.name || testData.testDataName;\n      if (profileName && !profileMap.has(profileName)) {\n        profileMap.set(profileName, {\n          id: String(testData.id),\n          name: profileName\n        });\n      }\n    });\n    const profiles = Array.from(profileMap.values());\n    return profiles;\n  }\n\n  /**\n   * Get data sets for a specific test data profile\n   * Returns all data sets from the profile's data array\n   */\n  getDataSetsForTestDataProfile(profileId: string): { id: string; name: string }[] {\n    // Find the test data profile by id\n    const testDataProfile = this.parameterOptions.find((testData: any) => {\n      return testData.id === Number(profileId);\n    });\n    \n    if (!testDataProfile || !testDataProfile.data || testDataProfile.data.length === 0) {\n      return [];\n    }\n    \n    // Return all data sets from the profile\n    return testDataProfile.data.map((dataSet: any) => ({\n      id: dataSet.name,\n      name: dataSet.name\n    }));\n  }\n\n  /**\n   * Get parameters for a specific data set in a test data profile\n   * Extracts parameter names from the selected data set's data object\n   */\n  getParametersForDataSet(profileIdOrName: string, dataSetName: string): { id: string; name: string }[] {\n    // Find the test data profile by id or name\n    const testDataProfile = this.parameterOptions.find((testData: any) => {\n      // Try to match by ID first (if profileIdOrName is a number)\n      const idMatch = !isNaN(Number(profileIdOrName)) && testData.id === Number(profileIdOrName);\n      // Otherwise try to match by name\n      const nameMatch = (testData.name || testData.testDataName) === profileIdOrName;\n      return idMatch || nameMatch;\n    });\n    \n    if (!testDataProfile || !testDataProfile.data || testDataProfile.data.length === 0) {\n      return [];\n    }\n    \n    // Find the specific data set by name\n    const dataSet = testDataProfile.data.find((ds: any) => ds.name === dataSetName);\n    if (!dataSet || !dataSet.data) {\n      return [];\n    }\n    \n    // Get all parameter keys from the data set's data object\n    const parameterNames = Object.keys(dataSet.data);\n    return parameterNames.map(paramName => ({\n      id: paramName,\n      name: paramName,\n    }));\n  }\n\n  /**\n   * Get select config for test data profile dropdown (first dropdown for parameters)\n   */\n  getTestDataProfileSelectConfig(variable: TemplateVariable, index: number): DynamicSelectFieldConfig {\n    const cacheKey = `${variable.name}_testDataProfile`;\n    \n    // Get unique test data profiles\n    const profiles = this.getUniqueTestDataProfiles();\n    // Create options with profile name and ID (display name with ID)\n    const optionsArray: SelectOption[] = profiles.map(profile => {\n      // Find the test data profile to get the ID\n      const testDataProfile = this.parameterOptions.find((testData: any) => {\n        const name = testData.name || testData.testDataName;\n        return name === profile.name;\n      });\n      const profileId = testDataProfile?.id || profile.id;\n      \n      return {\n        id: String(profileId),\n        value: profile.name,\n        name: `${profile.name}`, // Display name with ID\n        label: `${profile.name}`\n      };\n    });\n\n    // Ensure form control exists for test data profile selection and update it\n    const variableGroup = this.getVariableFormGroup(variable.name);\n    if (variableGroup) {\n      if (!variableGroup.get('selectedTestDataProfile')) {\n        // Use profile ID if available, otherwise use profile name\n        const currentValue = variable.selectedTestDataProfileId \n          ? String(variable.selectedTestDataProfileId) \n          : (variable.selectedTestDataProfile || '');\n        variableGroup.addControl('selectedTestDataProfile', new FormControl(currentValue));\n      }\n      \n      // Always update form control value if variable has a selected profile\n      // This ensures the value is set even if config was cached\n      // Use profile ID (which matches opt.id) instead of profile name (which matches opt.value)\n      if (variable.selectedTestDataProfileId != null) {\n        const profileIdString = String(variable.selectedTestDataProfileId);\n        // Verify the profile ID exists in options before setting\n        const profileExists = optionsArray.some(opt => opt.id === profileIdString);\n        if (profileExists) {\n          const currentControlValue = variableGroup.get('selectedTestDataProfile')?.value;\n          if (currentControlValue !== profileIdString) {\n            variableGroup.get('selectedTestDataProfile')?.setValue(profileIdString, { emitEvent: false });\n            console.log('Updated test data profile form control with ID:', {\n              variableName: variable.name,\n              profileId: profileIdString,\n              profileName: variable.selectedTestDataProfile,\n              optionsCount: optionsArray.length\n            });\n          }\n        } else {\n          console.warn('Selected test data profile ID not found in options:', {\n            variableName: variable.name,\n            profileId: profileIdString,\n            profileName: variable.selectedTestDataProfile,\n            availableOptionIds: optionsArray.map(opt => opt.id)\n          });\n        }\n      } else if (variable.selectedTestDataProfile) {\n        // Fallback: if we only have the profile name, find the matching option and use its ID\n        const matchingOption = optionsArray.find(opt => opt.value === variable.selectedTestDataProfile);\n        if (matchingOption) {\n          const currentControlValue = variableGroup.get('selectedTestDataProfile')?.value;\n          if (currentControlValue !== matchingOption.id) {\n            variableGroup.get('selectedTestDataProfile')?.setValue(matchingOption.id, { emitEvent: false });\n            // Also update the variable's profile ID for consistency\n            variable.selectedTestDataProfileId = Number(matchingOption.id);\n            console.log('Updated test data profile form control with ID from name:', {\n              variableName: variable.name,\n              profileId: matchingOption.id,\n              profileName: variable.selectedTestDataProfile\n            });\n          }\n        }\n      }\n    }\n\n    // Check cache after ensuring form control is set\n    if (this.testDataProfileSelectConfigCache.has(cacheKey)) {\n      return this.testDataProfileSelectConfigCache.get(cacheKey)!;\n    }\n\n    // Check if default values are set - if so, disable the dropdown\n    const isDisabled = this.hasDefaultTestDataSelection();\n    \n    const config: DynamicSelectFieldConfig = {\n      key: 'selectedTestDataProfile',\n      placeholder: 'Select Test Data Profile',\n      multiple: false,\n      searchable: false,\n      options: optionsArray,\n      hasMore: false,\n      isLoading: false,\n      disabled: isDisabled,\n      onChange: (value: any) => {\n        // Value is the profile ID (string) from the mat-option\n        // Find the test data profile by ID to get the name\n        const testDataProfile = this.parameterOptions.find((testData: any) => {\n          return testData.id === Number(value);\n        });\n        \n        // Store both ID and name\n        variable.selectedTestDataProfileId = testDataProfile?.id;\n        variable.selectedTestDataProfile = testDataProfile?.name || testDataProfile?.testDataName || '';\n        \n        // Clear data set and parameter selection when profile changes\n        variable.selectedDataSet = undefined;\n        variable.rawValue = '';\n        variable.value = '';\n        \n        // Update form controls\n        const varGroup = this.getVariableFormGroup(variable.name);\n        if (varGroup) {\n          if (varGroup.get('selectedTestDataProfile')) {\n            varGroup.get('selectedTestDataProfile')?.setValue(value, { emitEvent: false });\n          }\n          if (varGroup.get('selectedDataSet')) {\n            varGroup.get('selectedDataSet')?.setValue('', { emitEvent: false });\n          }\n          if (varGroup.get('value')) {\n            varGroup.get('value')?.setValue('', { emitEvent: false });\n          }\n        }\n        \n        // Clear caches for data set and parameter select configs since profile changed\n        // Clear all data set and parameter configs for this variable\n        const dataSetKeysToDelete: string[] = [];\n        this.dataSetSelectConfigCache.forEach((value: DynamicSelectFieldConfig, key: string) => {\n          if (key.startsWith(`${variable.name}_dataSet`)) {\n            dataSetKeysToDelete.push(key);\n          }\n        });\n        dataSetKeysToDelete.forEach(key => this.dataSetSelectConfigCache.delete(key));\n        \n        const paramKeysToDelete: string[] = [];\n        this.parameterForDataSetSelectConfigCache.forEach((value: DynamicSelectFieldConfig, key: string) => {\n          if (key.startsWith(`${variable.name}_paramForDataSet`)) {\n            paramKeysToDelete.push(key);\n          }\n        });\n        paramKeysToDelete.forEach(key => this.parameterForDataSetSelectConfigCache.delete(key));\n        \n        // Clear selected data set when profile changes\n        variable.selectedDataSet = undefined;\n        \n        // Mark for check\n        this.cdr.markForCheck();\n      }\n    };\n\n    this.testDataProfileSelectConfigCache.set(cacheKey, config);\n    return config;\n  }\n\n  /**\n   * Get select config for data set dropdown (second dropdown for parameters - shows data sets from selected profile)\n   */\n  getDataSetSelectConfig(variable: TemplateVariable, index: number): DynamicSelectFieldConfig {\n    // Get selected test data profile ID (preferred) or name (fallback)\n    const selectedProfileId = variable.selectedTestDataProfileId;\n    const selectedProfile = variable.selectedTestDataProfile;\n    \n    if (!selectedProfileId && !selectedProfile) {\n      // Return empty config if no profile is selected\n      return {\n        key: 'selectedDataSet',\n        placeholder: 'Select Test Data Profile first',\n        multiple: false,\n        searchable: false,\n        options: []\n      };\n    }\n\n    // Use profile ID if available, otherwise find ID from profile name\n    let profileIdToUse: string;\n    if (selectedProfileId) {\n      profileIdToUse = String(selectedProfileId);\n    } else {\n      // Find the profile ID from the profile name\n      const testDataProfile = this.parameterOptions.find((testData: any) => {\n        const name = testData.name || testData.testDataName;\n        return name === selectedProfile;\n      });\n      profileIdToUse = testDataProfile?.id ? String(testDataProfile.id) : '';\n    }\n\n    // Use profile ID for cache key if available, otherwise use profile name\n    const cacheKey = `${variable.name}_dataSet_${profileIdToUse || selectedProfile || ''}`;\n    if (this.dataSetSelectConfigCache.has(cacheKey)) {\n      return this.dataSetSelectConfigCache.get(cacheKey)!;\n    }\n\n    // Get data sets for the selected test data profile using ID\n    const dataSets = this.getDataSetsForTestDataProfile(profileIdToUse);\n    const optionsArray: SelectOption[] = dataSets.map(dataSet => ({\n      id: dataSet.name,\n      value: dataSet.name,\n      name: dataSet.name,\n      label: dataSet.name\n    }));\n\n    // Ensure form control exists for data set selection\n    const variableGroup = this.getVariableFormGroup(variable.name);\n    if (variableGroup) {\n      if (!variableGroup.get('selectedDataSet')) {\n        const currentDataSet = variable.selectedDataSet || '';\n        variableGroup.addControl('selectedDataSet', new FormControl(currentDataSet));\n      } else {\n        // Update form control value if variable has a selected data set\n        if (variable.selectedDataSet) {\n          variableGroup.get('selectedDataSet')?.setValue(variable.selectedDataSet, { emitEvent: false });\n        }\n      }\n    }\n\n    // Check if default values are set - if so, disable the dropdown\n    const isDisabled = this.hasDefaultTestDataSelection();\n    \n    const config: DynamicSelectFieldConfig = {\n      key: 'selectedDataSet',\n      placeholder: 'Select Data Set',\n      multiple: false,\n      searchable: false,\n      options: optionsArray,\n      hasMore: false,\n      isLoading: false,\n      disabled: isDisabled,\n      onChange: (value: any) => {\n        // Store selected data set\n        variable.selectedDataSet = value;\n        \n        // Clear parameter selection when data set changes\n        variable.rawValue = '';\n        variable.value = '';\n        \n        // Update form controls\n        const varGroup = this.getVariableFormGroup(variable.name);\n        if (varGroup) {\n          if (varGroup.get('selectedDataSet')) {\n            varGroup.get('selectedDataSet')?.setValue(value, { emitEvent: false });\n          }\n          if (varGroup.get('value')) {\n            varGroup.get('value')?.setValue('', { emitEvent: false });\n          }\n        }\n        \n        // Clear caches for parameter select config since data set changed\n        const paramKeysToDelete: string[] = [];\n        this.parameterForDataSetSelectConfigCache.forEach((configValue, key) => {\n          if (key.startsWith(`${variable.name}_paramForDataSet_`)) {\n            paramKeysToDelete.push(key);\n          }\n        });\n        paramKeysToDelete.forEach(key => this.parameterForDataSetSelectConfigCache.delete(key));\n        \n        // Mark for check\n        this.cdr.markForCheck();\n      }\n    };\n\n    this.dataSetSelectConfigCache.set(cacheKey, config);\n    return config;\n  }\n\n  /**\n   * Get select config for parameter dropdown (third dropdown for parameters - shows parameters from selected data set)\n   */\n  getParameterSelectConfig(variable: TemplateVariable, index: number): DynamicSelectFieldConfig {\n    // Get selected test data profile ID (preferred) or name (fallback) and data set\n    const selectedProfileId = variable.selectedTestDataProfileId;\n    const selectedProfile = variable.selectedTestDataProfile;\n    const selectedDataSet = variable.selectedDataSet;\n    \n    if ((!selectedProfileId && !selectedProfile) || !selectedDataSet) {\n      // Return empty config if profile or data set is not selected\n      return {\n        key: 'value',\n        placeholder: (selectedProfileId || selectedProfile) ? 'Select Data Set first' : 'Select Test Data Profile first',\n        multiple: false,\n        searchable: false,\n        options: []\n      };\n    }\n\n    // Use profile ID if available, otherwise use profile name\n    const profileIdentifier = selectedProfileId ? String(selectedProfileId) : (selectedProfile || '');\n    const cacheKey = `${variable.name}_paramForDataSet_${profileIdentifier}_${selectedDataSet}`;\n    if (this.parameterForDataSetSelectConfigCache.has(cacheKey)) {\n      return this.parameterForDataSetSelectConfigCache.get(cacheKey)!;\n    }\n\n    // Get parameters for the selected data set using profile ID or name\n    const parameters = this.getParametersForDataSet(profileIdentifier, selectedDataSet);\n    const optionsArray: SelectOption[] = parameters.map(param => ({\n      id: `@|${param.name}|`, // Use param.name as id (mat-option will use this)\n      value: `@|${param.name}|`, // Formatted value for display\n      name: param.name,\n      label: param.name\n    }));\n\n    // Ensure form control exists and is initialized with the current value\n    const variableGroup = this.getVariableFormGroup(variable.name);\n    if (variableGroup && variableGroup.get('value')) {\n      // If we have a value, ensure form control matches the option id (formatted value)\n      const currentValue = variable.value || '';\n      // Check if value is already formatted (e.g., \"@|email|\")\n      const formattedValue = currentValue.startsWith('@|') && currentValue.endsWith('|')\n        ? currentValue\n        : (currentValue ? `@|${currentValue}|` : '');\n      // Set form control to formatted value (matches opt.id) so select displays correctly\n      if (formattedValue && parameters.some(p => `@|${p.name}|` === formattedValue)) {\n        variableGroup.get('value')?.setValue(formattedValue, { emitEvent: false });\n      }\n    }\n\n    const config: DynamicSelectFieldConfig = {\n      key: 'value', // Use 'value' as key since we're accessing from FormArray\n      placeholder: `Select ${variable.label}`,\n      multiple: false,\n      searchable: true,\n      serverSearch: false, // Client-side search since we already have all parameters from the selected data set\n      options: optionsArray,\n      hasMore: false, // No pagination for parameters within a data set\n      isLoading: false,\n      onChange: (value: any) => {\n        // Value received is the formatted value (e.g., \"@|email|\") because mat-option uses opt.id\n        // Extract parameter name from formatted value\n        const formattedValue = value; // This is already formatted as @|paramName|\n        const paramName = formattedValue.startsWith('@|') && formattedValue.endsWith('|')\n          ? formattedValue.slice(2, -1)\n          : formattedValue;\n        \n        // Update raw value (store parameter name without formatting)\n        variable.rawValue = paramName;\n        \n        // Update variable value (store formatted value for template)\n        variable.value = formattedValue;\n        \n        // Update form control in FormArray - use formatted value (matches opt.id) so select displays correctly\n        const varGroup = this.getVariableFormGroup(variable.name);\n        if (varGroup && varGroup.get('value')) {\n          // Set to formatted value so the select can match and display the selected option\n          varGroup.get('value')?.setValue(formattedValue, { emitEvent: false });\n        }\n        \n        // Mark for check and emit\n        this.cdr.markForCheck();\n        \n        // Emit formatted value for parent component (this is what gets used in the template)\n        this.variableValueChange.emit({ name: variable.name, value: formattedValue });\n      }\n    };\n\n    this.parameterForDataSetSelectConfigCache.set(cacheKey, config);\n    return config;\n  }\n\n  /**\n   * Get unique environments from environment options\n   */\n  getUniqueEnvironments(): { id: string; name: string }[] {\n    const envMap = new Map<string, { id: string; name: string }>();\n    this.environmentOptions.forEach(env => {\n      if (!envMap.has(env.environment)) {\n        envMap.set(env.environment, {\n          id: env.environment,\n          name: env.environment\n        });\n      }\n    });\n    return Array.from(envMap.values());\n  }\n\n  /**\n   * Get parameters for a specific environment\n   */\n  getParametersForEnvironment(environmentName: string): { id: string; name: string }[] {\n    return this.environmentOptions\n      .filter(env => env.environment === environmentName)\n      .map(env => ({\n        id: env.name,\n        name: env.name\n      }));\n  }\n\n  /**\n   * Get select config for environment dropdown (first dropdown - select environment)\n   */\n  getEnvironmentSelectConfig(variable: TemplateVariable, index: number): DynamicSelectFieldConfig {\n    const cacheKey = `${variable.name}_environment`;\n    if (this.environmentSelectConfigCache.has(cacheKey)) {\n      return this.environmentSelectConfigCache.get(cacheKey)!;\n    }\n\n    // Get unique environments\n    const uniqueEnvironments = this.getUniqueEnvironments();\n    const optionsArray: SelectOption[] = uniqueEnvironments.map(env => ({\n      id: env.id,\n      value: env.name,\n      name: env.name,\n      label: env.name\n    }));\n\n    // Ensure form control exists for environment selection\n    const variableGroup = this.getVariableFormGroup(variable.name);\n    if (variableGroup && !variableGroup.get('selectedEnvironment')) {\n      const currentEnv = variable.selectedEnvironment || '';\n      variableGroup.addControl('selectedEnvironment', new FormControl(currentEnv));\n    }\n\n    const config: DynamicSelectFieldConfig = {\n      key: 'selectedEnvironment', // Use 'selectedEnvironment' as key\n      placeholder: `Select Environment`,\n      multiple: false,\n      searchable: true,\n      serverSearch: true,\n      options: optionsArray,\n      hasMore: this.hasMoreEnvironments,\n      isLoading: this.isLoadingEnvironments,\n      onChange: (value: any) => {\n        // Store selected environment name on the variable object\n        variable.selectedEnvironment = value;\n        \n        // Extract and store environment ID from environmentOptions\n        // Find the first environment option with matching environment name to get the ID\n        const envOption = this.environmentOptions.find(env => env.environment === value);\n        if (envOption) {\n          // Extract numeric ID from envOption.id (format: \"env-74-test\" -> 74)\n          const idMatch = envOption.id.match(/env-(\\d+)-/);\n          if (idMatch && idMatch[1]) {\n            variable.selectedEnvironmentId = parseInt(idMatch[1], 10);\n          }\n        }\n        \n        // Clear the parameter selection when environment changes\n        variable.rawValue = undefined;\n        variable.value = '';\n        \n        // Clear environment parameter config cache to force refresh\n        this.environmentParameterSelectConfigCache.delete(`${variable.name}_envParam`);\n        \n        // Update form control\n        const variableGroup = this.getVariableFormGroup(variable.name);\n        if (variableGroup) {\n          if (variableGroup.get('value')) {\n            variableGroup.get('value')?.setValue('', { emitEvent: false });\n          }\n          // Update selectedEnvironment control\n          if (variableGroup.get('selectedEnvironment')) {\n            variableGroup.get('selectedEnvironment')?.setValue(value, { emitEvent: false });\n          }\n        }\n        \n        // Pre-compute environment parameter config for the new environment\n        const index = this.templateVariables.findIndex(v => v.name === variable.name);\n        if (index !== -1) {\n          this.getEnvironmentParameterSelectConfig(variable, index);\n        }\n        \n        // Mark for check to update UI\n        this.cdr.markForCheck();\n      },\n      onLoadMore: () => {\n        this.loadMoreEnvironments.emit();\n      },\n      onSearch: (query: string) => {\n        this.searchEnvironments.emit(query);\n      }\n    };\n\n    this.environmentSelectConfigCache.set(cacheKey, config);\n    return config;\n  }\n\n  /**\n   * Get select config for environment parameter dropdown (second dropdown - select parameter from environment)\n   */\n  getEnvironmentParameterSelectConfig(variable: TemplateVariable, index: number): DynamicSelectFieldConfig {\n    const cacheKey = `${variable.name}_envParam`;\n    if (this.environmentParameterSelectConfigCache.has(cacheKey)) {\n      return this.environmentParameterSelectConfigCache.get(cacheKey)!;\n    }\n\n    // Get selected environment\n    const selectedEnvironment = variable.selectedEnvironment;\n    if (!selectedEnvironment) {\n      // Return empty config if no environment is selected\n      return {\n        key: 'value',\n        placeholder: 'Select Environment first',\n        multiple: false,\n        searchable: false,\n        options: []\n      };\n    }\n\n    // Get parameters for the selected environment\n    const parameters = this.getParametersForEnvironment(selectedEnvironment);\n    const optionsArray: SelectOption[] = parameters.map(param => ({\n      id: `*|${param.name}|`,\n      value: `*|${param.name}|`,\n      name: param.name,\n      label: param.name\n    }));\n\n    const config: DynamicSelectFieldConfig = {\n      key: 'value', // Use 'value' as key since we're accessing from FormArray\n      placeholder: `Select Parameter`,\n      multiple: false,\n      searchable: false,\n      options: optionsArray,\n      onChange: (value: any) => {\n        // When parameter is selected, update raw value and format it\n        variable.rawValue = value;\n        const formattedValue = `${value}`;\n        \n        // Update variable value (store formatted value)\n        variable.value = formattedValue;\n        \n        // Environment ID is already stored on variable.selectedEnvironmentId\n        // (it was set when environment was selected)\n        \n        // Update form control in FormArray - keep raw value so select displays correctly\n        const variableGroup = this.getVariableFormGroup(variable.name);\n        if (variableGroup && variableGroup.get('value')) {\n          // Set to raw value so the select can match and display the selected option\n          variableGroup.get('value')?.setValue(value, { emitEvent: false });\n        }\n        \n        // Mark for check and emit\n        this.cdr.markForCheck();\n        // Emit formatted value for parent component\n        this.variableValueChange.emit({ name: variable.name, value: formattedValue });\n      }\n    };\n\n    this.environmentParameterSelectConfigCache.set(cacheKey, config);\n    return config;\n  }\n\n  /**\n   * Get selected environment for a variable\n   */\n  getSelectedEnvironment(variable: TemplateVariable): string {\n    return variable.selectedEnvironment || '';\n  }\n\n  /**\n   * Check if environment is selected for a variable\n   */\n  hasSelectedEnvironment(variable: TemplateVariable): boolean {\n    return !!variable.selectedEnvironment;\n  }\n\n  /**\n   * Get selected environment ID for a variable\n   */\n  getSelectedEnvironmentId(variable: TemplateVariable): number | null {\n    return variable.selectedEnvironmentId || null;\n  }\n\n  /**\n   * Get all environment IDs for variables that use environment type\n   * Returns a map of variable name to environment ID\n   */\n  getEnvironmentIdsForVariables(): Map<string, number> {\n    const envIds = new Map<string, number>();\n    this.templateVariables.forEach(variable => {\n      if (this.isEnvironmentType(variable) && variable.selectedEnvironmentId) {\n        envIds.set(variable.name, variable.selectedEnvironmentId);\n      }\n    });\n    return envIds;\n  }\n\n  /**\n   * Check if current data type is plain-text\n   */\n  isPlainTextType(variable: TemplateVariable): boolean {\n    const dataType = variable.dataType || 'plain-text';\n    return dataType === 'plain-text';\n  }\n\n  /**\n   * Check if current data type is parameter\n   */\n  isParameterType(variable: TemplateVariable): boolean {\n    const dataType = variable.dataType || 'plain-text';\n    return dataType === 'parameter';\n  }\n\n  /**\n   * Check if test data profile is selected for a variable\n   */\n  hasSelectedTestDataProfile(variable: TemplateVariable): boolean {\n    return !!variable.selectedTestDataProfile;\n  }\n\n  /**\n   * Check if data set is selected for a variable\n   */\n  hasSelectedDataSet(variable: TemplateVariable): boolean {\n    return !!variable.selectedDataSet;\n  }\n\n  /**\n   * Check if default test data profile and data set are set (from test case)\n   * If true, profile and data set dropdowns should be disabled\n   */\n  hasDefaultTestDataSelection(): boolean {\n    return !!(this.defaultTestDataProfileId != null && this.defaultTestDataStartIndex != null);\n  }\n\n  /**\n   * Check if current data type is environment\n   */\n  isEnvironmentType(variable: TemplateVariable): boolean {\n    const dataType = variable.dataType || 'plain-text';\n    return dataType === 'environment';\n  }\n\n\n  /**\n   * Check if current data type is runtime\n   */\n  isRuntimeType(variable: TemplateVariable): boolean {\n    const dataType = variable.dataType || 'plain-text';\n    return dataType === 'runtime';\n  }\n}\n\n","<style>\n  .capitalize-first::first-letter {\n    text-transform: uppercase;\n  }\n</style>\n\n<div class=\"cqa-flex cqa-gap-x-6 cqa-gap-y-4 cqa-flex-wrap template-variables-form\" *ngIf=\"!createElementVisible\">\n  \n  <!-- Metadata -->\n  <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n    <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n      Metadata\n    </label>\n    <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"metadata\" [fullWidth]=\"true\"\n      (valueChange)=\"metadataChange.emit($event)\">\n    </cqa-custom-input>\n  </div>\n\n  <!-- Description -->\n  <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n    <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n      Description\n    </label>\n    <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"description\" [fullWidth]=\"true\"\n      (valueChange)=\"descriptionChange.emit($event)\">\n    </cqa-custom-input>\n  </div>\n  \n  <ng-container *ngFor=\"let variable of templateVariables; let i = index; trackBy: trackByVariable\">\n    <!-- Boolean variables with mat-slide-toggle -->\n    <ng-container *ngIf=\"variable.type === 'boolean'\">\n      <div class=\"cqa-flex cqa-items-center cqa-gap-2\" style=\"width: calc(50% - 12px);\">\n        <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 capitalize-first\">\n          {{ variable.label }}\n        </label>\n        <mat-slide-toggle [checked]=\"variablesForm.at(i)?.get('value')?.value || variable.value || false\"\n          (change)=\"onVariableBooleanChange(variable.name, $event.checked)\" color=\"primary\">\n        </mat-slide-toggle>\n      </div>\n    </ng-container>\n\n    <!-- Non-boolean, non-custom_code variables -->\n    <ng-container *ngIf=\"variable.name !== 'custom_code' && variable.type !== 'boolean'\">\n      <ng-container *ngIf=\"shouldShowDropdown(variable); else defaultInput\">\n        <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n          <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1 capitalize-first\">\n            {{ variable.label }}\n          </label>\n          <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getSelectConfig(variable, i)\">\n          </cqa-dynamic-select>\n        </div>\n      </ng-container>\n      <ng-template #defaultInput>\n        <!-- Test-data, source-value, or target-value with data type dropdown -->\n        <ng-container *ngIf=\"needsDataTypeDropdown(variable); else regularInput\">\n          <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1 capitalize-first\">\n              {{ variable.label }} Type\n            </label>\n            <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getDataTypeSelectConfig(variable, i)\">\n            </cqa-dynamic-select>\n          </div>\n          <ng-container *ngIf=\"isEnvironmentType(variable)\">\n          <div *ngIf=\"isEnvironmentType(variable)\" class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n              Environment Name\n            </label>\n            <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getEnvironmentSelectConfig(variable, i)\">\n            </cqa-dynamic-select>\n          </div>\n          <div *ngIf=\"hasSelectedEnvironment(variable)\" class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n              Environment Value\n            </label>\n            <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getEnvironmentParameterSelectConfig(variable, i)\">\n            </cqa-dynamic-select>\n          </div>\n          </ng-container>\n          <ng-container *ngIf=\"isParameterType(variable)\">\n            <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n              <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n                Test Data Profile\n              </label>\n              <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getTestDataProfileSelectConfig(variable, i)\">\n              </cqa-dynamic-select>\n            </div>\n            <div *ngIf=\"hasSelectedTestDataProfile(variable)\" class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n              <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1\">\n                Data Set\n              </label>\n              <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getDataSetSelectConfig(variable, i)\">\n              </cqa-dynamic-select>\n            </div>\n            <div *ngIf=\"hasSelectedDataSet(variable)\" class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n              <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1 capitalize-first\">\n                {{ variable.label }}\n              </label>\n              <cqa-dynamic-select [form]=\"getFormGroupAt(i)!\" [config]=\"getParameterSelectConfig(variable, i)\">\n              </cqa-dynamic-select>\n            </div>\n          </ng-container>\n          <div *ngIf=\"isPlainTextType(variable) || isRuntimeType(variable)\" class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1  capitalize-first\">\n              {{ variable.label }} \n            </label>\n            <!-- Show custom input for plain-text type -->\n            <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"getRawValue(variable)\" [fullWidth]=\"true\"\n              (valueChange)=\"onTestDataValueChange(variable.name, $event)\">\n            </cqa-custom-input>\n          </div>\n        </ng-container>\n        <ng-template #regularInput>\n          <div class=\"cqa-flex cqa-flex-col\" style=\"width: calc(50% - 12px);\">\n            <label class=\"cqa-text-sm cqa-font-medium cqa-text-gray-700 cqa-mb-1 capitalize-first\">\n              {{ variable.label }}\n            </label>\n            <cqa-custom-input [placeholder]=\"'Text Input'\" [value]=\"variable.value\" [fullWidth]=\"true\"\n              (valueChange)=\"onVariableValueChange(variable.name, $event)\">\n            </cqa-custom-input>\n          </div>\n        </ng-template>\n      </ng-template>\n    </ng-container>\n  </ng-container>\n</div>\n\n<div *ngIf=\"createElementVisible\">\n  <cqa-element-form\n    [isCreateMode]=\"true\"\n    [screenNameOptions]=\"screenNameOptions\"\n    [hasMoreScreenNames]=\"hasMoreScreenNames\"\n    [isLoadingScreenNames]=\"isLoadingScreenNames\"\n    [isEditInDepthAvailable]=\"false\"\n    (createElement)=\"onCreateElement($event)\"\n    (cancel)=\"onCancelElementForm()\"\n    (searchScreenName)=\"searchScreenName.emit($event)\"\n    (loadMoreScreenNames)=\"loadMoreScreenNames.emit($event)\"\n    (createScreenNameRequest)=\"createScreenNameRequest.emit($event)\">\n  </cqa-element-form>\n</div>"]}