@nyaruka/temba-components 0.131.1 → 0.131.2

package/out-tsc/src/flow/nodes/wait_for_response.js

@@ -1,6 +1,8 @@
-import { COLORS } from '../types';
-import { generateUUID } from '../../utils';
+import { SPLIT_GROUPS } from '../types';
+import { generateUUID, createRulesRouter } from '../../utils';
 import { getWaitForResponseOperators, operatorsToSelectOptions, getOperatorConfig } from '../operators';
+import { resultNameField } from './shared';
+import { createRulesArrayConfig, extractUserRules, casesToFormRules } from './shared-rules';
 const TIMEOUT_OPTIONS = [
     { value: '60', name: '1 minute' },
     { value: '120', name: '2 minutes' },
@@ -21,458 +23,31 @@ const TIMEOUT_OPTIONS = [
     { value: '259200', name: '3 days' },
     { value: '604800', name: '1 week' }
 ];
-// Helper function to check if a category is a system category
-const isSystemCategory = (categoryName) => {
-    return ['No Response', 'Other', 'All Responses', 'Timeout'].includes(categoryName);
-};
-// Helper function to check if a UUID belongs to a system category
-const isSystemCategoryUuid = (uuid, categories) => {
-    const category = categories.find((cat) => cat.uuid === uuid);
-    return category ? isSystemCategory(category.name) : false;
-};
-// Helper function to generate default category name based on operator and operands
-const generateDefaultCategoryName = (operator, value1, value2) => {
-    const operatorConfig = getOperatorConfig(operator);
-    if (!operatorConfig)
-        return '';
-    // Fixed category names (no operands)
-    if (operatorConfig.operands === 0) {
-        return operatorConfig.categoryName || '';
-    }
-    // Dynamic category names based on operands
-    const cleanValue1 = (value1 || '').trim();
-    const cleanValue2 = (value2 || '').trim();
-    // Helper to capitalize first letter
-    const capitalize = (str) => {
-        if (!str)
-            return '';
-        return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
-    };
-    // Handle different operator types
-    switch (operator) {
-        // Word/phrase operators - capitalize first letter of value
-        case 'has_any_word':
-        case 'has_all_words':
-        case 'has_phrase':
-        case 'has_only_phrase':
-        case 'has_beginning':
-            return cleanValue1 ? capitalize(cleanValue1) : '';
-        // Pattern operators - show as-is
-        case 'has_pattern':
-            return cleanValue1;
-        // Number comparison operators - include symbol
-        case 'has_number_eq':
-            return cleanValue1 ? `= ${cleanValue1}` : '';
-        case 'has_number_lt':
-            return cleanValue1 ? `< ${cleanValue1}` : '';
-        case 'has_number_lte':
-            return cleanValue1 ? `≤ ${cleanValue1}` : '';
-        case 'has_number_gt':
-            return cleanValue1 ? `> ${cleanValue1}` : '';
-        case 'has_number_gte':
-            return cleanValue1 ? `≥ ${cleanValue1}` : '';
-        // Number between - range format
-        case 'has_number_between':
-            if (cleanValue1 && cleanValue2) {
-                return `${cleanValue1} - ${cleanValue2}`;
-            }
-            return '';
-        // Date operators - format with relative expressions
-        case 'has_date_lt':
-        case 'has_date_lte':
-            if (cleanValue1) {
-                // Parse relative date expression (e.g., "today + 5" or "today - 3")
-                const match = cleanValue1.match(/^(today)\s*([+-])\s*(\d+)$/i);
-                if (match) {
-                    const [, base, operator, days] = match;
-                    const dayWord = days === '1' ? 'day' : 'days';
-                    return `Before ${base} ${operator} ${days} ${dayWord}`;
-                }
-                // Fallback for other date formats
-                return `Before ${cleanValue1}`;
-            }
-            return '';
-        case 'has_date_gt':
-        case 'has_date_gte':
-            if (cleanValue1) {
-                // Parse relative date expression
-                const match = cleanValue1.match(/^(today)\s*([+-])\s*(\d+)$/i);
-                if (match) {
-                    const [, base, operator, days] = match;
-                    const dayWord = days === '1' ? 'day' : 'days';
-                    return `After ${base} ${operator} ${days} ${dayWord}`;
-                }
-                // Fallback for other date formats
-                return `After ${cleanValue1}`;
-            }
-            return '';
-        case 'has_date_eq':
-            if (cleanValue1) {
-                // Parse relative date expression
-                const match = cleanValue1.match(/^(today)\s*([+-])\s*(\d+)$/i);
-                if (match) {
-                    const [, base, operator, days] = match;
-                    const dayWord = days === '1' ? 'day' : 'days';
-                    return `${base} ${operator} ${days} ${dayWord}`;
-                }
-                return cleanValue1;
-            }
-            return '';
-        default:
-            // Fallback - capitalize first value
-            return cleanValue1 ? capitalize(cleanValue1) : '';
-    }
-};
 // Helper function to create a wait_for_response router with user rules
+// This is a thin wrapper around createRulesRouter that adds the No Response category for timeouts
 const createWaitForResponseRouter = (userRules, existingCategories = [], existingExits = [], existingCases = []) => {
-    const categories = [];
-    const exits = [];
-    const cases = [];
-    // Filter existing categories to get only user-defined rules (exclude system categories)
-    const existingUserCategories = existingCategories.filter((cat) => !isSystemCategory(cat.name));
-    // Track categories as we create them (case-insensitive lookup)
-    const createdCategories = new Map();
-    // Process rules in their original order to preserve rule order
-    userRules.forEach((rule, ruleIndex) => {
-        const categoryKey = rule.category.trim().toLowerCase();
-        const categoryName = rule.category.trim(); // Use original casing
-        let categoryInfo = createdCategories.get(categoryKey);
-        if (!categoryInfo) {
-            // First time seeing this category - create it
-            // Smart category matching: try by name first, then fall back to position
-            let existingCategory = existingUserCategories.find((cat) => cat.name.toLowerCase() === categoryKey);
-            // If no match by name, try by position (for category rename scenarios)
-            const categoryCreationOrder = Array.from(createdCategories.keys()).length;
-            if (!existingCategory &&
-                categoryCreationOrder < existingUserCategories.length) {
-                const candidateCategory = existingUserCategories[categoryCreationOrder];
-                // Double-check that this candidate is not a system category UUID
-                if (candidateCategory &&
-                    !isSystemCategoryUuid(candidateCategory.uuid, existingCategories)) {
-                    existingCategory = candidateCategory;
-                }
-            }
-            const existingExit = existingCategory
-                ? existingExits.find((exit) => exit.uuid === existingCategory.exit_uuid)
-                : null;
-            // Generate UUIDs, ensuring we don't reuse system category UUIDs
-            let exitUuid = (existingExit === null || existingExit === void 0 ? void 0 : existingExit.uuid) || generateUUID();
-            let categoryUuid = (existingCategory === null || existingCategory === void 0 ? void 0 : existingCategory.uuid) || generateUUID();
-            // Additional safety check: if somehow we got a system category UUID, generate new ones
-            if (isSystemCategoryUuid(categoryUuid, existingCategories)) {
-                categoryUuid = generateUUID();
-                exitUuid = generateUUID();
-            }
-            categoryInfo = {
-                uuid: categoryUuid,
-                name: categoryName,
-                exit_uuid: exitUuid
-            };
-            createdCategories.set(categoryKey, categoryInfo);
-            // Add category and exit
-            categories.push({
-                uuid: categoryUuid,
-                name: categoryName,
-                exit_uuid: exitUuid
-            });
-            exits.push({
-                uuid: exitUuid,
-                destination_uuid: (existingExit === null || existingExit === void 0 ? void 0 : existingExit.destination_uuid) || null
-            });
-        }
-        // Create case for this rule
-        let existingCase = existingCases[ruleIndex];
-        // If we can't find by position, try to find by matching rule content
-        if (!existingCase && existingCases.length > 0) {
-            existingCase = existingCases.find((case_) => {
-                // Find the category for this case
-                const caseCategory = existingCategories.find((cat) => cat.uuid === case_.category_uuid);
-                // Match by operator type and category name
-                return (case_.type === rule.operator &&
-                    (caseCategory === null || caseCategory === void 0 ? void 0 : caseCategory.name.toLowerCase()) === categoryKey);
-            });
-        }
-        const caseUuid = (existingCase === null || existingCase === void 0 ? void 0 : existingCase.uuid) || generateUUID();
-        // Parse rule value based on operator configuration
-        const operatorConfig = getOperatorConfig(rule.operator);
-        let arguments_ = [];
-        if (operatorConfig) {
-            if (operatorConfig.operands === 0) {
-                // No operands needed
-                arguments_ = [];
-            }
-            else if (operatorConfig.operands === 2) {
-                // Split value for two operands (e.g., "1 10" for between)
-                arguments_ = rule.value.split(' ').filter((arg) => arg.trim());
-            }
-            else {
-                // Single operand - but split words for operators that expect multiple words
-                if (rule.value && rule.value.trim()) {
-                    // Split on spaces and filter out empty strings
-                    arguments_ = rule.value
-                        .trim()
-                        .split(/\s+/)
-                        .filter((arg) => arg.length > 0);
-                }
-                else {
-                    arguments_ = [];
-                }
-            }
-        }
-        else {
-            // Fallback for unknown operators - split on spaces if value exists
-            if (rule.value && rule.value.trim()) {
-                arguments_ = rule.value
-                    .trim()
-                    .split(/\s+/)
-                    .filter((arg) => arg.length > 0);
-            }
-            else {
-                arguments_ = [];
-            }
-        }
-        cases.push({
-            uuid: caseUuid,
-            type: rule.operator,
-            arguments: arguments_,
-            category_uuid: categoryInfo.uuid
-        });
-    });
-    // Add default category (always present)
-    // Name is "Other" if there are user rules, "All Responses" if there are no user rules
-    const defaultCategoryName = userRules.length > 0 ? 'Other' : 'All Responses';
-    // Try to find existing default category by name (prefer exact match)
-    let existingDefaultCategory = existingCategories.find((cat) => cat.name === defaultCategoryName);
-    // If no exact match, try to find the other possible default category name
-    if (!existingDefaultCategory) {
-        const alternateName = userRules.length > 0 ? 'All Responses' : 'Other';
-        existingDefaultCategory = existingCategories.find((cat) => cat.name === alternateName);
-    }
-    const existingDefaultExit = existingDefaultCategory
-        ? existingExits.find((exit) => exit.uuid === existingDefaultCategory.exit_uuid)
-        : null;
-    const defaultExitUuid = (existingDefaultExit === null || existingDefaultExit === void 0 ? void 0 : existingDefaultExit.uuid) || generateUUID();
-    const defaultCategoryUuid = (existingDefaultCategory === null || existingDefaultCategory === void 0 ? void 0 : existingDefaultCategory.uuid) || generateUUID();
-    categories.push({
-        uuid: defaultCategoryUuid,
-        name: defaultCategoryName,
-        exit_uuid: defaultExitUuid
-    });
-    exits.push({
-        uuid: defaultExitUuid,
-        destination_uuid: (existingDefaultExit === null || existingDefaultExit === void 0 ? void 0 : existingDefaultExit.destination_uuid) || null
-    });
+    const { router, exits } = createRulesRouter('@input.text', userRules, getOperatorConfig, existingCategories, existingExits, existingCases);
     // Add "No Response" category last (if it exists in the original)
     const existingNoResponseCategory = existingCategories.find((cat) => cat.name === 'No Response' || cat.name === 'Timeout');
     if (existingNoResponseCategory) {
         const existingNoResponseExit = existingExits.find((exit) => exit.uuid === existingNoResponseCategory.exit_uuid);
         if (existingNoResponseExit) {
-            categories.push(existingNoResponseCategory);
-            exits.push(existingNoResponseExit);
+            router.categories.push(existingNoResponseCategory);
+            exits.push({
+                uuid: existingNoResponseExit.uuid,
+                destination_uuid: existingNoResponseExit.destination_uuid || null
+            });
         }
     }
-    // Find the default category (either "Other" or "All Responses")
-    const defaultCategory = categories.find((cat) => cat.name === 'Other' || cat.name === 'All Responses');
-    return {
-        router: {
-            type: 'switch',
-            categories: categories,
-            default_category_uuid: defaultCategory === null || defaultCategory === void 0 ? void 0 : defaultCategory.uuid,
-            operand: '@input.text',
-            cases: cases
-        },
-        exits: exits
-    };
+    return { router, exits };
 };
 export const wait_for_response = {
     type: 'wait_for_response',
     name: 'Wait for Response',
-    color: COLORS.wait,
+    group: SPLIT_GROUPS.wait,
     dialogSize: 'large',
     form: {
-        rules: {
-            type: 'array',
-            helpText: 'Define rules to categorize responses',
-            itemLabel: 'Rule',
-            minItems: 0,
-            maxItems: 100,
-            sortable: true,
-            maintainEmptyItem: true, // Explicitly enable empty item maintenance
-            isEmptyItem: (item) => {
-                // Helper function to get operator value from various formats
-                const getOperatorValue = (operator) => {
-                    if (typeof operator === 'string') {
-                        return operator.trim();
-                    }
-                    else if (Array.isArray(operator) && operator.length > 0) {
-                        // Handle array format: [{value: "has_any_word", name: "..."}]
-                        const firstOperator = operator[0];
-                        if (firstOperator &&
-                            typeof firstOperator === 'object' &&
-                            firstOperator.value) {
-                            return firstOperator.value.trim();
-                        }
-                    }
-                    else if (operator &&
-                        typeof operator === 'object' &&
-                        operator.value) {
-                        // Handle object format: {value: "has_any_word", name: "..."}
-                        return operator.value.trim();
-                    }
-                    return '';
-                };
-                // Check if operator and category are provided
-                const operatorValue = getOperatorValue(item.operator);
-                if (!operatorValue || !item.category || item.category.trim() === '') {
-                    return true;
-                }
-                // Check if value is required based on operator configuration
-                const operatorConfig = getOperatorConfig(operatorValue);
-                if (operatorConfig && operatorConfig.operands === 1) {
-                    // value1 is required for this operator
-                    return !item.value1 || item.value1.trim() === '';
-                }
-                else if (operatorConfig && operatorConfig.operands === 2) {
-                    // Both value1 and value2 are required for this operator
-                    return (!item.value1 ||
-                        item.value1.trim() === '' ||
-                        !item.value2 ||
-                        item.value2.trim() === '');
-                }
-                // No value required for this operator
-                return false;
-            },
-            onItemChange: (itemIndex, field, value, allItems) => {
-                const updatedItems = [...allItems];
-                const item = { ...updatedItems[itemIndex] };
-                // Helper to get operator value from various formats
-                const getOperatorValue = (operator) => {
-                    if (typeof operator === 'string') {
-                        return operator.trim();
-                    }
-                    else if (Array.isArray(operator) && operator.length > 0) {
-                        const firstOperator = operator[0];
-                        if (firstOperator &&
-                            typeof firstOperator === 'object' &&
-                            firstOperator.value) {
-                            return firstOperator.value.trim();
-                        }
-                    }
-                    else if (operator &&
-                        typeof operator === 'object' &&
-                        operator.value) {
-                        return operator.value.trim();
-                    }
-                    return '';
-                };
-                // Update the changed field
-                item[field] = value;
-                // Get operator values (before and after the change)
-                const oldItem = allItems[itemIndex] || {};
-                const oldOperatorValue = field === 'operator'
-                    ? getOperatorValue(oldItem.operator)
-                    : getOperatorValue(item.operator);
-                const newOperatorValue = getOperatorValue(item.operator);
-                // Calculate what the default category name should be before the change
-                const oldDefaultCategory = generateDefaultCategoryName(oldOperatorValue, field === 'value1' ? oldItem.value1 : item.value1, field === 'value2' ? oldItem.value2 : item.value2);
-                // Calculate what the new default category name should be after the change
-                const newDefaultCategory = generateDefaultCategoryName(newOperatorValue, item.value1, item.value2);
-                // Determine if we should auto-update the category
-                const shouldUpdateCategory = 
-                // Category is empty
-                !item.category ||
-                    item.category.trim() === '' ||
-                    // Category matches the old default (user hasn't customized it)
-                    item.category === oldDefaultCategory;
-                // Auto-populate or update category if conditions are met
-                if (shouldUpdateCategory && newDefaultCategory) {
-                    item.category = newDefaultCategory;
-                }
-                updatedItems[itemIndex] = item;
-                return updatedItems;
-            },
-            itemConfig: {
-                operator: {
-                    type: 'select',
-                    required: true,
-                    multi: false, // Explicitly set as single-select
-                    options: operatorsToSelectOptions(getWaitForResponseOperators()),
-                    flavor: 'xsmall',
-                    width: '200px'
-                },
-                value1: {
-                    type: 'text',
-                    flavor: 'xsmall',
-                    conditions: {
-                        visible: (formData) => {
-                            // Helper function to get operator value from various formats
-                            const getOperatorValue = (operator) => {
-                                if (typeof operator === 'string') {
-                                    return operator.trim();
-                                }
-                                else if (Array.isArray(operator) && operator.length > 0) {
-                                    const firstOperator = operator[0];
-                                    if (firstOperator &&
-                                        typeof firstOperator === 'object' &&
-                                        firstOperator.value) {
-                                        return firstOperator.value.trim();
-                                    }
-                                }
-                                else if (operator &&
-                                    typeof operator === 'object' &&
-                                    operator.value) {
-                                    return operator.value.trim();
-                                }
-                                return '';
-                            };
-                            // Show value1 field for operators that require 1 or 2 operands
-                            const operatorValue = getOperatorValue(formData.operator);
-                            const operatorConfig = getOperatorConfig(operatorValue);
-                            return operatorConfig ? operatorConfig.operands >= 1 : true;
-                        }
-                    }
-                },
-                value2: {
-                    type: 'text',
-                    flavor: 'xsmall',
-                    conditions: {
-                        visible: (formData) => {
-                            // Helper function to get operator value from various formats
-                            const getOperatorValue = (operator) => {
-                                if (typeof operator === 'string') {
-                                    return operator.trim();
-                                }
-                                else if (Array.isArray(operator) && operator.length > 0) {
-                                    const firstOperator = operator[0];
-                                    if (firstOperator &&
-                                        typeof firstOperator === 'object' &&
-                                        firstOperator.value) {
-                                        return firstOperator.value.trim();
-                                    }
-                                }
-                                else if (operator &&
-                                    typeof operator === 'object' &&
-                                    operator.value) {
-                                    return operator.value.trim();
-                                }
-                                return '';
-                            };
-                            // Show value2 field only if operator requires exactly 2 operands
-                            const operatorValue = getOperatorValue(formData.operator);
-                            const operatorConfig = getOperatorConfig(operatorValue);
-                            return operatorConfig ? operatorConfig.operands === 2 : false;
-                        }
-                    }
-                },
-                category: {
-                    type: 'text',
-                    placeholder: 'Category',
-                    required: true,
-                    maxWidth: '120px',
-                    flavor: 'xsmall'
-                }
-            }
-        },
+        rules: createRulesArrayConfig(operatorsToSelectOptions(getWaitForResponseOperators()), 'Define rules to categorize responses'),
         timeout_enabled: {
             type: 'checkbox',
             label: (formData) => {
@@ -486,7 +61,7 @@ export const wait_for_response = {
             type: 'select',
             placeholder: '5 minutes',
             multi: false,
-            maxWidth: '150px',
+            maxWidth: '100px',
             flavor: 'xsmall',
             options: TIMEOUT_OPTIONS,
             conditions: {
@@ -495,12 +70,7 @@ export const wait_for_response = {
                 }
             }
         },
-        result_name: {
-            type: 'text',
-            label: 'Result Name',
-            helpText: 'The name to save the response as',
-            placeholder: 'response'
-        }
+        result_name: resultNameField
     },
     layout: ['rules', 'result_name'],
     gutter: [
@@ -520,53 +90,11 @@ export const wait_for_response = {
         };
     },
     toFormData: (node) => {
-        var _a, _b, _c, _d, _e, _f;
-        // Extract rules from router cases
-        const rules = [];
-        if (((_a = node.router) === null || _a === void 0 ? void 0 : _a.cases) && ((_b = node.router) === null || _b === void 0 ? void 0 : _b.categories)) {
-            node.router.cases.forEach((case_) => {
-                // Find the category for this case
-                const category = node.router.categories.find((cat) => cat.uuid === case_.category_uuid);
-                // Skip system categories
-                if (category && !isSystemCategory(category.name)) {
-                    // Handle different operator types
-                    const operatorConfig = getOperatorConfig(case_.type);
-                    const operatorDisplayName = operatorConfig
-                        ? operatorConfig.name
-                        : case_.type;
-                    let value1 = '';
-                    let value2 = '';
-                    if (operatorConfig && operatorConfig.operands === 0) {
-                        // No value needed for operators like has_text, has_number
-                        value1 = '';
-                        value2 = '';
-                    }
-                    else if (operatorConfig && operatorConfig.operands === 1) {
-                        // Single value for operators like has_number_lt - use value1
-                        value1 = case_.arguments.join(' ');
-                        value2 = '';
-                    }
-                    else if (operatorConfig && operatorConfig.operands === 2) {
-                        // Two separate values for operators like has_number_between
-                        value1 = case_.arguments[0] || '';
-                        value2 = case_.arguments[1] || '';
-                    }
-                    else {
-                        // Fallback: use first argument for unknown operators
-                        value1 = case_.arguments.join(' ');
-                        value2 = '';
-                    }
-                    rules.push({
-                        operator: { value: case_.type, name: operatorDisplayName },
-                        value1: value1,
-                        value2: value2,
-                        category: category.name
-                    });
-                }
-            });
-        }
+        var _a, _b, _c, _d;
+        // Extract rules from router cases using shared function
+        const rules = casesToFormRules(node);
         // Extract timeout configuration
-        const timeoutSeconds = (_e = (_d = (_c = node.router) === null || _c === void 0 ? void 0 : _c.wait) === null || _d === void 0 ? void 0 : _d.timeout) === null || _e === void 0 ? void 0 : _e.seconds;
+        const timeoutSeconds = (_c = (_b = (_a = node.router) === null || _a === void 0 ? void 0 : _a.wait) === null || _b === void 0 ? void 0 : _b.timeout) === null || _c === void 0 ? void 0 : _c.seconds;
         let timeoutOption = TIMEOUT_OPTIONS.find((opt) => opt.value === String(timeoutSeconds));
         if (!timeoutOption) {
             timeoutOption = { value: '300', name: '5 minutes' };
@@ -576,82 +104,13 @@ export const wait_for_response = {
             rules: rules,
             timeout_enabled: !!timeoutSeconds,
             timeout_duration: timeoutOption,
-            result_name: ((_f = node.router) === null || _f === void 0 ? void 0 : _f.result_name) || 'response'
+            result_name: ((_d = node.router) === null || _d === void 0 ? void 0 : _d.result_name) || ''
         };
     },
     fromFormData: (formData, originalNode) => {
         var _a, _b, _c, _d, _e, _f, _g, _h;
-        // Helper function to get operator value from various formats
-        const getOperatorValue = (operator) => {
-            if (typeof operator === 'string') {
-                return operator.trim();
-            }
-            else if (Array.isArray(operator) && operator.length > 0) {
-                // Handle array format: [{value: "has_any_word", name: "..."}]
-                const firstOperator = operator[0];
-                if (firstOperator &&
-                    typeof firstOperator === 'object' &&
-                    firstOperator.value) {
-                    return firstOperator.value.trim();
-                }
-            }
-            else if (operator && typeof operator === 'object' && operator.value) {
-                // Handle object format: {value: "has_any_word", name: "..."}
-                return operator.value.trim();
-            }
-            return '';
-        };
-        // Get user rules
-        const userRules = (formData.rules || [])
-            .filter((rule) => {
-            // Always need operator and category
-            const operatorValue = getOperatorValue(rule === null || rule === void 0 ? void 0 : rule.operator);
-            if (!operatorValue ||
-                !(rule === null || rule === void 0 ? void 0 : rule.category) ||
-                operatorValue === '' ||
-                rule.category.trim() === '') {
-                return false;
-            }
-            // Check if value is required based on operator
-            const operatorConfig = getOperatorConfig(operatorValue);
-            if (operatorConfig && operatorConfig.operands === 1) {
-                // value1 is required for this operator
-                return (rule === null || rule === void 0 ? void 0 : rule.value1) && rule.value1.trim() !== '';
-            }
-            else if (operatorConfig && operatorConfig.operands === 2) {
-                // Both value1 and value2 are required for this operator
-                return ((rule === null || rule === void 0 ? void 0 : rule.value1) &&
-                    rule.value1.trim() !== '' &&
-                    (rule === null || rule === void 0 ? void 0 : rule.value2) &&
-                    rule.value2.trim() !== '');
-            }
-            // No value required for this operator
-            return true;
-        })
-            .map((rule) => {
-            const operatorValue = getOperatorValue(rule.operator);
-            const operatorConfig = getOperatorConfig(operatorValue);
-            let value = '';
-            if (operatorConfig && operatorConfig.operands === 1) {
-                // Single value from value1
-                value = rule.value1 ? rule.value1.trim() : '';
-            }
-            else if (operatorConfig && operatorConfig.operands === 2) {
-                // Two values - combine them with space
-                const val1 = rule.value1 ? rule.value1.trim() : '';
-                const val2 = rule.value2 ? rule.value2.trim() : '';
-                value = `${val1} ${val2}`.trim();
-            }
-            else {
-                // No value needed for 0-operand operators
-                value = '';
-            }
-            return {
-                operator: operatorValue,
-                value: value,
-                category: rule.category.trim()
-            };
-        });
+        // Get user rules using shared extraction function
+        const userRules = extractUserRules(formData);
         // If no user rules, clear cases but preserve other router config
         if (userRules.length === 0) {
             // Get existing router data for preservation
@@ -691,9 +150,12 @@ export const wait_for_response = {
             );
             const router = {
                 ...noRulesRouter,
-                result_name: formData.result_name || 'response',
                 cases: [] // Clear all cases when no rules
             };
+            // Only set result_name if provided
+            if (formData.result_name && formData.result_name.trim() !== '') {
+                router.result_name = formData.result_name.trim();
+            }
             // Build wait configuration based on form data
             const waitConfig = {
                 type: 'msg'
@@ -752,9 +214,12 @@ export const wait_for_response = {
         const { router, exits } = createWaitForResponseRouter(userRules, existingCategories, existingExits, existingCases);
         // Build final router with wait configuration and result_name
         const finalRouter = {
-            ...router,
-            result_name: formData.result_name || 'response'
+            ...router
         };
+        // Only set result_name if provided
+        if (formData.result_name && formData.result_name.trim() !== '') {
+            finalRouter.result_name = formData.result_name.trim();
+        }
         // Build wait configuration based on form data
         const waitConfig = {
             type: 'msg'