fixed bug with duplicate in script

formula_editor/formula_editor/doctype/formula_editor/formula_editor.js

@@ -343,16 +343,8 @@ frappe.require([
             functions.push(generateReportFieldsFunction(report_fields));
         }
 
-        // Добавляем обработчики для ay и il - для расчета универсальных полей
+        // НЕ добавляем обработчики для ay и il здесь отдельно
-        triggerHandlers["ay"] = {
+        // Они будут добавлены позже вместе с другими обработчиками
-            isAsync: true,
-            handlers: ["// Вычисляем универсальные поля только когда меняется ay", "await calculate_universal_fields(frm);"]
-        };
-
-        triggerHandlers["il"] = {
-            isAsync: true,
-            handlers: ["// Вычисляем универсальные поля только когда меняется il", "await calculate_universal_fields(frm);"]
-        };
 
         // Добавляем функцию преобразования выражений
         functions.push(generateTransformExpressionFunction(universal_fields, report_fields));
@@ -577,23 +569,76 @@ frappe.require([
                 'frappe.ui.form.on("' + target_doctype + '", {\n' + refreshHandlerBody);
         }
 
-        // Теперь создаем обработчики для каждого триггера
-        Object.keys(triggerHandlers).forEach(trigger => {
-            const handler = triggerHandlers[trigger];
-            main_script += `    "${trigger}": ${handler.isAsync ? 'async ' : ''}function(frm) {
-        ${handler.handlers.join('\n        ')}
-    },\n`;
-        });
-
         // Обработчики для табличных частей и триггеры, связанные с ними
         const tableRowFormulaHandlers = processTableRowFormulas(table_row_formulas, table_doctypes);
+        
+        // ВАЖНО: Объединяем обработчики формул строк таблиц с основными обработчиками
         Object.keys(tableRowFormulaHandlers).forEach(trigger => {
             const handler = tableRowFormulaHandlers[trigger];
-            main_script += `    "${trigger}": ${handler.isAsync ? 'async ' : ''}function(frm) {
-        ${handler.isAsync ? 'await calculate_universal_fields(frm);' : '// Универсальные поля не используются'}
             
-        ${handler.handlers.join('\n        ')}
+            // Проверяем, есть ли уже обработчик для этого триггера
-    },\n`;
+            if (triggerHandlers[trigger]) {
+                // Объединяем обработчики
+                // Если хотя бы один требует async, делаем весь обработчик async
+                if (handler.isAsync) {
+                    triggerHandlers[trigger].isAsync = true;
+                }
+                // Добавляем новые обработчики к существующим
+                triggerHandlers[trigger].handlers = triggerHandlers[trigger].handlers.concat(handler.handlers);
+            } else {
+                // Если обработчика еще нет, создаем новый
+                triggerHandlers[trigger] = handler;
+            }
+        });
+
+        // Проверяем, нужны ли обработчики для ay и il для универсальных полей и основных формул
+        const needsAyIlHandlers = fieldsUsingUniversalOrReports.some(f => f.uses_universal) || 
+                                Object.keys(table_row_formulas).some(id => {
+                                    const formula = table_row_formulas[id];
+                                    return formula.formula && formula.formula.includes("univ(");
+                                });
+
+        if (needsAyIlHandlers) {
+            // Добавляем или обновляем обработчики для ay и il
+            ['ay', 'il'].forEach(field => {
+                if (!triggerHandlers[field]) {
+                    triggerHandlers[field] = {
+                        isAsync: true,
+                        handlers: []
+                    };
+                } else {
+                    triggerHandlers[field].isAsync = true;
+                }
+                
+                // Добавляем вызов calculate_universal_fields в начало обработчика
+                const hasUniversalCall = triggerHandlers[field].handlers.some(h => 
+                    h.includes('calculate_universal_fields')
+                );
+                
+                if (!hasUniversalCall) {
+                    triggerHandlers[field].handlers.unshift('await calculate_universal_fields(frm);');
+                }
+            });
+        }
+
+        // Теперь создаем обработчики для каждого триггера (без дубликатов)
+        Object.keys(triggerHandlers).forEach(trigger => {
+            const handler = triggerHandlers[trigger];
+            main_script += `    "${trigger}": ${handler.isAsync ? 'async ' : ''}function(frm) {\n`;
+            
+            // Для ay и il добавляем комментарий о вычислении универсальных полей
+            if (trigger === 'ay' || trigger === 'il') {
+                if (handler.handlers.some(h => h.includes('calculate_universal_fields'))) {
+                    main_script += `        // Вычисляем универсальные поля только когда меняется ${trigger}\n`;
+                }
+            }
+            
+            // Добавляем все обработчики
+            handler.handlers.forEach(handlerCode => {
+                main_script += `        ${handlerCode}\n`;
+            });
+            
+            main_script += '    },\n';
         });
 
         main_script += `});`;