@myrtex-org/form 1.1.95 → 1.1.96

package/fesm2022/myrtex-org-form.mjs

@@ -17,7 +17,7 @@ import { AutoSaveStore, ToasterType, LabelModule, ModalServiceComponent, MODAL_D
 import { HttpHeaders, HttpClient, HTTP_INTERCEPTORS } from '@angular/common/http';
 import * as i2$1 from '@myrtex-org/templates';
 import { FormHeaderModule, MenuAdminModule } from '@myrtex-org/templates';
-import { cloneDeep } from 'lodash-es';
+import { cloneDeep, isArray } from 'lodash-es';
 import * as i2$2 from '@angular/forms';
 import { FormsModule } from '@angular/forms';
 import { provideNgxMask } from 'ngx-mask';
@@ -1264,51 +1264,8 @@ class ComponentFactoryDirective {
         }
     }
     applyValues(values) {
-        if (!this.dynamicComponent) {
-            return;
-        }
-        // Сохраняем базовое поведение системы Myrtex
-        this.dynamicComponent.instance.values = values;
-        // ХАК ДЛЯ РЕЖИМА МОДАЛКИ (MANUAL):
-        // Принудительно инициализируем компоненты дат в обход пустого Стора
-        const currentMode = this.valueMode || this.dynamicComponent.instance.valueMode;
-        if (currentMode === 'manual' && values && this.data) {
-            const targetField = values.find((v) => v.sysName === this.data?.sysName);
-            const instance = this.dynamicComponent.instance;
-            if (targetField && targetField.value !== undefined && targetField.value !== null) {
-                const componentOptions = this.data?.options;
-                // Специфичный хак для InputDate с range: true
-                if (this.type === 'inputDate' && componentOptions?.range && Array.isArray(targetField.value)) {
-                    // Проверяем, что лежит внутри массива. Если там строки, заворачиваем их в объекты, которые ждет компонент
-                    const firstElement = targetField.value[0];
-                    const secondElement = targetField.value[1];
-                    const startValue = firstElement?.sysName ? firstElement.value : firstElement;
-                    const endValue = secondElement?.sysName ? secondElement.value : secondElement;
-                    // Формируем полноценные структуры ComponentValueModel
-                    instance.modelStart = {
-                        sysName: targetField.sysName,
-                        type: targetField.type,
-                        valueType: targetField.valueType,
-                        value: startValue || null
-                    };
-                    instance.modelEnd = {
-                        sysName: targetField.sysName,
-                        type: targetField.type,
-                        valueType: targetField.valueType,
-                        value: endValue || null
-                    };
-                    if (typeof instance._customInit === 'function') {
-                        instance._customInit();
-                    }
-                }
-                else if (this.type === 'inputDate') {
-                    // Для одиночной даты
-                    instance.model = structuredClone(targetField);
-                    if (typeof instance._customInit === 'function') {
-                        instance._customInit();
-                    }
-                }
-            }
+        if (this.dynamicComponent) {
+            this.dynamicComponent.instance.values = values;
         }
     }
     applyValueMode(valueMode) {
@@ -1832,9 +1789,8 @@ class InputDateComponent extends BaseFieldComponent {
     _initSubscriptionForValue() {
         this._subscriptions$.push(this._store.select(selectValueModel(this.settings))
             .subscribe((result) => {
-            if (!result || this._isUpdatingInternal) {
+            if (!result || this._isUpdatingInternal)
                 return;
-            }
             // Если компонент уже инициализирован, проверяем, нужно ли обновляться.
             // Мы НЕ обновляемся, если данные в Store идентичны тем, что мы уже держим в памяти.
             if (this._isInit) {
@@ -1892,6 +1848,7 @@ class InputDateComponent extends BaseFieldComponent {
         const start = new Date(startDate);
         const end = new Date(endDate);
         if (isNaN(start.getTime()) || isNaN(end.getTime())) {
+            console.error('Invalid date format');
             return 0;
         }
         const differenceInMs = Math.abs(end.getTime() - start.getTime());
@@ -1901,9 +1858,11 @@ class InputDateComponent extends BaseFieldComponent {
         if (startDate) {
             const start = new Date(startDate);
             if (isNaN(start.getTime())) {
+                console.error('Invalid start date format');
                 return startDate;
             }
             if (!Number.isInteger(days) || days < 0) {
+                console.error('Days must be a non-negative integer');
                 return startDate;
             }
             let newDate = new Date(start.getTime() + days * this._millisecondsInDay);
@@ -2238,26 +2197,12 @@ class InputTableModalComponent extends ModalServiceComponent {
         this.result = { result: false, rowModel: this.rowModel };
     }
     componentValueChanged(valueModel) {
-        if (Array.isArray(valueModel) && valueModel.length > 0) {
-            // Проверяем, это элементы диапазона дат (одинаковый sysName) или это разные компоненты
-            const firstSysName = valueModel[0].sysName;
-            const isRangeDate = valueModel.every(m => m.sysName === firstSysName && m.type === ComponentType.InputDate);
-            if (isRangeDate) {
-                // Собираем чистый массив значений дат [string | null, string | null]
-                const rangeValues = valueModel.map(m => m.value);
-                // Создаем синтетическую модель, где value — это массив дат
-                const rangePayload = {
-                    ...valueModel[0],
-                    value: rangeValues
-                };
-                this._transformValues(rangePayload);
-            }
-            else {
-                // Если это массив от разных компонентов (стандартная логика dispenser)
-                valueModel.forEach(model => this._transformValues(model));
-            }
+        if (isArray(valueModel)) {
+            valueModel.forEach(model => {
+                this._transformValues(model);
+            });
         }
-        else if (valueModel && !Array.isArray(valueModel)) {
+        else {
             this._transformValues(valueModel);
         }
         this._recalculateFormulaFields();
@@ -2284,7 +2229,7 @@ class InputTableModalComponent extends ModalServiceComponent {
         const cloneRowModel = structuredClone(this.rowModel);
         const findValue = cloneRowModel.data.find((c) => c.sysName === value.sysName);
         if (findValue) {
-            findValue.value = value.value; // Теперь сюда запишется массив ['2026-05-05', '2026-05-07']
+            findValue.value = value.value;
         }
         this.rowModel = cloneRowModel;
     }
@@ -2452,37 +2397,10 @@ class InputTableComponent {
         this._subscriptions$.push(this._store.select(selectValueModel(this.settings))
             .subscribe((result) => {
             const cloneResult = structuredClone(result);
-            if (cloneResult && !Array.isArray(cloneResult) && cloneResult.sysName === this.settings.sysName) {
-                // --- ОБНОВЛЕННЫЙ БЛОК ПАРСИНГА И ЗАЩИТЫ ОТ NULL ---
-                if (cloneResult.data && Array.isArray(cloneResult.data)) {
-                    cloneResult.data.forEach((row) => {
-                        if (row.data && Array.isArray(row.data)) {
-                            row.data.forEach((cell) => {
-                                // 1. Если пришла строка со слэшем — парсим в массив
-                                if (cell.type === 'inputDate' && typeof cell.value === 'string' && cell.value.includes('/')) {
-                                    cell.value = cell.value.split('/');
-                                }
-                                // 2. ЗАЩИТА: Если бэк прислал null, но у нас в текущей модели таблицы КУДА-ТО УЖЕ введена дата
-                                if (cell.type === 'inputDate' && cell.value === null) {
-                                    // Ищем эту же ячейку в наших текущих строках на UI
-                                    const currentRow = this._rows?.find((r) => r.id === row.id);
-                                    const currentCell = currentRow?.data?.find((c) => c.sysName === cell.sysName);
-                                    if (currentCell && currentCell.value) {
-                                        // Не даем занулить! Возвращаем ей текущее валидное значение из UI
-                                        cell.value = structuredClone(currentCell.value);
-                                    }
-                                }
-                            });
-                        }
-                    });
-                }
-                // -------------------------------------------------
-                const isDataChanged = JSON.stringify(this.model?.data) !== JSON.stringify(cloneResult.data);
-                if (isDataChanged) {
-                    this.model = structuredClone(cloneResult);
-                    this._rows = this._extractRows(this.model.data);
-                    this._initDataSource(this._rows);
-                }
+            if (cloneResult && !Array.isArray(cloneResult) && this.model.data !== cloneResult.data) {
+                this.model = structuredClone(cloneResult);
+                this._rows = this._extractRows(this.model.data);
+                this._initDataSource(this._rows);
             }
         }));
     }
@@ -2491,7 +2409,6 @@ class InputTableComponent {
         this._subscriptions$.forEach((subscription) => subscription.unsubscribe());
     }
     createRow() {
-        const initialRowModel = getRowModel(this.settings);
         this._modalService.open(InputTableModalComponent, {
             title: 'Создание строки',
             okText: 'Создать',
@@ -2499,12 +2416,9 @@ class InputTableComponent {
             rowModel: getRowModel(this.settings),
             isCheckRequired: this._isCheckRequired
         }).afterClosed().subscribe(resolve => {
-            if (resolve && resolve.result && resolve.rowModel) {
-                // Накатываем модель из модалки (там внутри ДАТЫ ЕЩЕ В ВИДЕ МАССИВА Array(2))
+            if (resolve.result) {
                 this._rows = [...structuredClone(this._rows), resolve.rowModel];
-                // Инициализируем Грид МАССИВОМ — DevExtreme сразу отрендерит "дд.мм.гггг - дд.мм.гггг" без мигания!
                 this._initDataSource(this._rows);
-                // А вот теперь принудительно вызываем сборку модели, которая сама сожмет массивы в строки ДЛЯ СТОРА
                 this._changeSubject$.next(this._buildTableValueModel());
             }
         });
@@ -2521,54 +2435,26 @@ class InputTableComponent {
         return !this._canEditObject;
     }
     editRow(event) {
-        const rowId = event.row?.data?.id || event.data?.id;
-        const localRow = this._rows.find((r) => r.id === rowId);
-        if (!localRow)
-            return;
-        const rowModel = structuredClone(localRow);
-        const gridData = event.row?.data || event.data;
-        if (rowModel.data && Array.isArray(rowModel.data)) {
-            rowModel.data = rowModel.data.map((cell) => {
-                if (gridData && gridData[cell.sysName] !== undefined) {
-                    const currentValue = gridData[cell.sysName];
-                    // Если это range-дата и в гриде лежит массив из 2-х элементов
-                    if (cell.type === 'inputDate' && cell.options?.range && Array.isArray(currentValue)) {
-                        // Формируем структуру [ modelStart, modelEnd ], которую ждет InputDateComponent
-                        cell.value = [
-                            { sysName: cell.sysName, type: cell.type, valueType: cell.valueType, value: currentValue[0] },
-                            { sysName: cell.sysName, type: cell.type, valueType: cell.valueType, value: currentValue[1] }
-                        ];
-                    }
-                    else {
-                        cell.value = structuredClone(currentValue);
+        const findRow = this._rows.find(item => item.id === event.row.data.id);
+        if (findRow) {
+            this._modalService.open(InputTableModalComponent, {
+                title: 'Редактирование строки',
+                okText: 'Сохранить',
+                settings: this.settings,
+                rowModel: findRow
+            }).afterClosed().subscribe(resolve => {
+                if (resolve.result) {
+                    const cloneRows = structuredClone(this._rows);
+                    const editableRow = cloneRows.find(row => row.id === resolve.rowModel.id);
+                    if (editableRow) {
+                        editableRow.data = resolve.rowModel.data;
+                        this._rows = cloneRows;
+                        this._initDataSource(this._rows);
+                        this._changeSubject$.next(this._buildTableValueModel());
                     }
                 }
-                return cell;
             });
         }
-        this._modalService.open(InputTableModalComponent, {
-            title: 'Редактирование строки',
-            okText: 'Сохранить',
-            settings: this.settings,
-            rowModel: rowModel,
-            isCheckRequired: this._isCheckRequired
-        }).afterClosed().subscribe(resolve => {
-            if (resolve && resolve.result && resolve.rowModel) {
-                // При сохранении вытаскиваем из структуры [modelStart, modelEnd] чистый массив дат обратно для грида
-                if (resolve.rowModel.data && Array.isArray(resolve.rowModel.data)) {
-                    resolve.rowModel.data = resolve.rowModel.data.map((cell) => {
-                        if (cell.type === 'inputDate' && cell.options?.range && Array.isArray(cell.value)) {
-                            // Если там прилетел массив моделей (или массив строк от componentValueChanged)
-                            cell.value = cell.value.map((item) => item?.sysName ? item.value : item);
-                        }
-                        return cell;
-                    });
-                }
-                this._rows = this._rows.map((r) => r.id === rowId ? resolve.rowModel : r);
-                this._initDataSource(this._rows);
-                this._changeSubject$.next(this._buildTableValueModel());
-            }
-        });
     }
     getFormat(component) {
         switch (component.type) {
@@ -2616,9 +2502,7 @@ class InputTableComponent {
         this.dataSource = data.map((item) => {
             const newDataItem = {};
             for (let i in item.data) {
-                const cell = item.data[i];
-                // Напрямую берем значение ячейки (будь то строка или массив дат)
-                newDataItem[cell.sysName] = cell.value;
+                newDataItem[item.data[i].sysName] = item.data[i].value;
             }
             newDataItem.id = item.id;
             return newDataItem;
@@ -2663,31 +2547,6 @@ class InputTableComponent {
             format: this.getFormat(component),
             minWidth: 160
         };
-        if (component.type === ComponentType.InputDate && component.options.range) {
-            column.calculateCellValue = (rowData) => {
-                const dateRange = rowData[component.sysName];
-                if (Array.isArray(dateRange) && dateRange.length === 2) {
-                    const formatDate = (dateStr) => {
-                        if (!dateStr)
-                            return '';
-                        const d = new Date(dateStr);
-                        if (isNaN(d.getTime()))
-                            return '';
-                        const day = String(d.getDate()).padStart(2, '0');
-                        const month = String(d.getMonth() + 1).padStart(2, '0');
-                        const year = d.getFullYear();
-                        return `${day}.${month}.${year}`;
-                    };
-                    const startFormatted = formatDate(dateRange[0]);
-                    const endFormatted = formatDate(dateRange[1]);
-                    if (startFormatted && endFormatted) {
-                        return `${startFormatted} — ${endFormatted}`;
-                    }
-                    return startFormatted || endFormatted || '';
-                }
-                return dateRange || '';
-            };
-        }
         if (dataType === 'boolean') {
             column.calculateCellValue = (rowData) => {
                 const value = rowData[component.sysName];
@@ -2756,22 +2615,8 @@ class InputTableComponent {
         });
     }
     _buildTableValueModel() {
-        // 1. Пробегаемся по ТЕКУЩИМ локальным строкам таблицы и принудительно жмем массивы дат в строки
-        if (this._rows && Array.isArray(this._rows)) {
-            this._rows.forEach(row => {
-                if (row.data && Array.isArray(row.data)) {
-                    row.data.forEach((cell) => {
-                        if (cell.type === 'inputDate' && Array.isArray(cell.value)) {
-                            cell.value = cell.value.join('/');
-                        }
-                    });
-                }
-            });
-        }
-        // 2. Делаем стандартную группировку Myrtex
         const groupedData = this._buildGroupedItems(this._rows, this.settings.options.groups || [], 0);
         const totals = this._calculateTotals(this._rows);
-        // 3. Формируем финальную модель, где внутри data уже гарантированно лежат строки вместо массивов
         this.model = {
             sysName: this.settings.sysName,
             type: this.settings.type,