cloud-ide-element 1.0.64 → 1.0.66

package/fesm2022/cloud-ide-element.mjs

@@ -4499,46 +4499,20 @@ class CideEleFileImageDirective {
     }
     displayImage(fileData) {
         const imgElement = this.elementRef.nativeElement;
-        // Check if it's an image file
-        const isImage = this.isImageFile(fileData.cyfm_name || '', fileData.cyfm_type || '');
-        if (isImage) {
-            // For now, we'll use a placeholder or the file path
-            // In a real implementation, you might need to fetch the actual file content
-            if (fileData.cyfm_path) {
-                // If you have a direct URL to the file, use it
-                imgElement.src = fileData.cyfm_path;
-                imgElement.alt = fileData.cyfm_alt_text || this.altText;
-                console.log('✅ [FileImageDirective] Image loaded from path:', fileData.cyfm_path);
-            }
-            else if (fileData.cyfm_file_base64) {
-                // If base64 data is available, use it
-                let base64Data = fileData.cyfm_file_base64;
-                if (!base64Data.startsWith('data:')) {
-                    const mimeType = fileData.cyfm_type || 'image/jpeg';
-                    base64Data = `data:${mimeType};base64,${base64Data}`;
-                }
-                imgElement.src = base64Data;
-                imgElement.alt = fileData.cyfm_alt_text || this.altText;
-                console.log('✅ [FileImageDirective] Image loaded from base64 data');
-            }
-            else {
-                console.warn('⚠️ [FileImageDirective] No image data available for file:', fileData.cyfm_name);
+        // Use base64 data directly
+        if (fileData.cyfm_file_base64) {
+            let base64Data = fileData.cyfm_file_base64;
+            if (!base64Data.startsWith('data:')) {
+                const mimeType = fileData.cyfm_type || 'image/jpeg';
+                base64Data = `data:${mimeType};base64,${base64Data}`;
             }
+            imgElement.src = base64Data;
+            imgElement.alt = fileData.cyfm_alt_text || this.altText;
+            console.log('✅ [FileImageDirective] Image loaded from base64 data');
         }
         else {
-            console.warn('⚠️ [FileImageDirective] File is not an image:', fileData.cyfm_name);
-        }
-    }
-    isImageFile(fileName, fileType) {
-        if (fileType && fileType.startsWith('image/')) {
-            return true;
-        }
-        if (fileName) {
-            const imageExtensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.svg'];
-            const lowerFileName = fileName.toLowerCase();
-            return imageExtensions.some(ext => lowerFileName.endsWith(ext));
+            console.warn('⚠️ [FileImageDirective] No base64 data available for file');
         }
-        return false;
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: CideEleFileImageDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
     static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.1.7", type: CideEleFileImageDirective, isStandalone: true, selector: "[cideEleFileImage]", inputs: { fileId: "fileId", altText: "altText" }, ngImport: i0 });
@@ -5593,10 +5567,17 @@ class CideEleDataGridComponent {
                     const baseOrder = Math.min(...this.displayedData.map(item => this.getItemOrder(item)));
                     const newOrderValue = baseOrder + index;
                     currentEntry.newPosition = newOrderValue;
+                    // IMPORTANT: Update the actual sequence value in the item itself
+                    this.setNestedValue(item, dragDropConfig.orderField, newOrderValue);
                 }
                 else {
                     // Fallback to index-based position
-                    currentEntry.newPosition = index + 1;
+                    const newOrderValue = index + 1;
+                    currentEntry.newPosition = newOrderValue;
+                    // Update the actual sequence value in the item itself
+                    if (dragDropConfig?.orderField) {
+                        this.setNestedValue(item, dragDropConfig.orderField, newOrderValue);
+                    }
                 }
                 this.rowOrderMap.set(itemId, currentEntry);
             }
@@ -5684,6 +5665,23 @@ class CideEleDataGridComponent {
             .sort((a, b) => a.newPosition - b.newPosition)
             .map(orderedItem => orderedItem.item);
     }
+    /**
+     * Get only the items that have actually changed order
+     */
+    getChangedOrders() {
+        const changedItems = [];
+        // Get the full dataset from the config
+        const fullData = this.mergedConfig().data || [];
+        // Check each item to see if its position has changed
+        this.rowOrderMap.forEach((orderInfo, itemId) => {
+            const item = fullData.find(dataItem => this.getItemId(dataItem) === itemId);
+            if (item && orderInfo.oldPosition !== orderInfo.newPosition) {
+                changedItems.push(item);
+                console.log('🔍 Item changed order:', itemId, 'from', orderInfo.oldPosition, 'to', orderInfo.newPosition);
+            }
+        });
+        return changedItems;
+    }
     /**
      * Update local data order for visual reordering (LOCAL ONLY)
      */
@@ -5735,25 +5733,32 @@ class CideEleDataGridComponent {
             console.log('🔍 Reset clicked, row order map reset locally, visual display reverted');
         }
         else if (action.key === 'save-order') {
-            this.hasOrderChanged.set(false);
-            // Update the row order map to current positions as new baseline
-            this.updateRowOrderMapBaseline();
-            // Clear local reordered data as it's now the baseline
-            this.localReorderedData = [];
-            console.log('🔍 Save clicked, row order map updated to new baseline, local data cleared');
-            // NOW emit the reorder event to update external components
-            const currentOrder = this.getCurrentOrderFromMap();
-            if (currentOrder.length > 0) {
-                console.log('🔍 Emitting rowReorder event to update external components:', currentOrder);
+            // Check if there are any actual changes before proceeding
+            const hasActualChanges = this.checkIfOrderChanged();
+            if (!hasActualChanges) {
+                console.log('🔍 No actual order changes detected, skipping save');
+                this.hasOrderChanged.set(false);
+                return;
+            }
+            // Get only the changed orders and emit them BEFORE clearing local data
+            const changedOrders = this.getChangedOrders();
+            if (changedOrders.length > 0) {
+                console.log('🔍 Emitting rowReorder event with changed orders only:', changedOrders);
+                console.log('🔍 Number of changed records:', changedOrders.length, 'out of', this.getCurrentOrderFromMap().length, 'total records');
                 // Use the expected GridEvent structure for rowReorder
                 this.emitEvent('rowReorder', {
-                    sourceItem: currentOrder[0], // First item as source
+                    sourceItem: changedOrders[0], // First changed item as source
                     sourceIndex: 0, // First position as source
-                    targetItem: currentOrder[currentOrder.length - 1], // Last item as target
-                    targetIndex: currentOrder.length - 1, // Last position as target
-                    newOrder: currentOrder // The complete new order
+                    targetItem: changedOrders[changedOrders.length - 1], // Last changed item as target
+                    targetIndex: changedOrders.length - 1, // Last position as target
+                    newOrder: changedOrders, // Only the records whose order actually changed
+                    allOrders: this.getCurrentOrderFromMap() // Complete order for reference
                 });
             }
+            // DON'T clear the local data or reset the order map here
+            // Let the parent component handle the data refresh after API call
+            // The local data will be cleared when new data arrives via ngOnChanges
+            console.log('🔍 Save clicked, rowReorder event emitted, preserving local data until API response');
         }
         if (this.actionHandlers[action.onClick]) {
             this.actionHandlers[action.onClick](item, action);
@@ -5779,6 +5784,60 @@ class CideEleDataGridComponent {
             return current && typeof current === 'object' ? current[key] : undefined;
         }, obj);
     }
+    /**
+     * Set a nested value in an object using dot notation
+     * @param obj The object to modify
+     * @param path The dot notation path (e.g., 'contact.email')
+     * @param value The value to set
+     * @example
+     * const obj = { contact: { email: 'old@example.com' } };
+     * setNestedValue(obj, 'contact.email', 'new@example.com');
+     * // obj.contact.email === 'new@example.com'
+     */
+    setNestedValue(obj, path, value) {
+        const keys = path.split('.');
+        const lastKey = keys.pop();
+        const target = keys.reduce((current, key) => {
+            if (current && typeof current === 'object') {
+                if (!current[key]) {
+                    current[key] = {};
+                }
+                return current[key];
+            }
+            return undefined;
+        }, obj);
+        if (target && typeof target === 'object') {
+            target[lastKey] = value;
+        }
+    }
+    /**
+     * Compare two order arrays to check if they are different
+     * This method can be used by parent components to check if order has actually changed
+     * @param currentOrder Current order array
+     * @param originalOrder Original order array
+     * @returns true if orders are different, false if they are the same
+     */
+    compareOrders(currentOrder, originalOrder) {
+        console.log('🔍 DataGrid: Comparing orders - current length:', currentOrder.length, 'original length:', originalOrder.length);
+        // If lengths are different, there are changes
+        if (currentOrder.length !== originalOrder.length) {
+            console.log('🔍 DataGrid: Lengths are different, returning true');
+            return true;
+        }
+        // Compare the order of items by their IDs (not just their sequence values)
+        // This will detect if items have been reordered even if sequence values are the same
+        for (let i = 0; i < currentOrder.length; i++) {
+            const currentItem = currentOrder[i];
+            const originalItem = originalOrder[i];
+            console.log('🔍 DataGrid: Position', i, '- Current ID:', currentItem.id, 'Original ID:', originalItem.id);
+            if (currentItem.id !== originalItem.id) {
+                console.log('🔍 DataGrid: Different item at position', i, 'returning true');
+                return true;
+            }
+        }
+        console.log('🔍 DataGrid: No differences found, returning false');
+        return false;
+    }
     formatValue(value, column) {
         if (column.formatter) {
             if (column.formatter.type === 'custom' && column.formatter.customFunction) {