cloud-ide-element 1.1.87 → 1.1.89

package/fesm2022/cloud-ide-element.mjs

@@ -10052,10 +10052,17 @@ class CideEleDataGridComponent {
         if (!treeConfig)
             return treeItems;
         const { childrenKey = 'children' } = treeConfig;
-        // Flatten all items (both expanded and collapsed) for grouping
+        // Flatten all items for grouping, but preserve the children structure in each parent
+        // This ensures that when we restore, we can show children when parent is expanded
         const flatten = (items) => {
             items.forEach(item => {
-                result.push(item);
+                // Create a copy of the item to add to flat list
+                // But preserve the original children array in the item itself
+                const itemCopy = { ...item };
+                result.push(itemCopy);
+                // Recursively flatten children
+                // Note: The children remain in the original item's children array
+                // They are also added to the flat list for grouping
                 const children = this.getNestedValue(item, childrenKey) || [];
                 if (children.length > 0) {
                     flatten(children);
@@ -10073,78 +10080,75 @@ class CideEleDataGridComponent {
         const treeConfig = this.mergedConfig().tree;
         if (!treeConfig)
             return groupedData;
-        const { primaryKey = '_id', foreignKey, childrenKey = 'children' } = treeConfig;
+        const { primaryKey, foreignKey, childrenKey = 'children', expandedKey = 'isExpanded', levelKey = 'level' } = treeConfig;
         const result = [];
-        const processedItems = new Set();
-        // Helper to find parent in result array (including nested in group headers)
-        const findParentInResult = (parentId) => {
-            const searchInArray = (items) => {
-                for (const item of items) {
-                    // Skip group headers for parent search
-                    if (item?._isGroupHeader) {
-                        continue;
-                    }
-                    const itemId = String(this.getNestedValue(item, primaryKey) || '');
-                    if (itemId === parentId) {
-                        return item;
-                    }
-                    // Check children recursively
-                    const children = this.getNestedValue(item, childrenKey) || [];
-                    if (children.length > 0) {
-                        const found = searchInArray(children);
-                        if (found)
-                            return found;
-                    }
-                }
-                return null;
-            };
-            return searchInArray(result);
-        };
-        // Process each item in grouped data
+        const itemMap = new Map();
+        // First pass: build a map of all items and nest children under parents
         groupedData.forEach(item => {
-            // If it's a group header, add it directly
+            // If it's a group header, add it directly to result
             if (item?._isGroupHeader) {
                 result.push(item);
                 return;
             }
             const itemId = String(this.getNestedValue(item, primaryKey) || '');
-            if (!itemId || processedItems.has(itemId)) {
+            if (!itemId) {
+                result.push(item);
                 return;
             }
+            // Store item in map
+            itemMap.set(itemId, item);
+            // Get parent ID
             const parentIdValue = this.getNestedValue(item, foreignKey);
-            // Extract parent ID generically - handle both string IDs and nested objects
             const parentId = this.extractIdFromForeignKey(parentIdValue, primaryKey);
-            if (parentId) {
-                // Item has a parent - try to find parent
-                const parent = findParentInResult(parentId);
-                if (parent) {
-                    // Parent found - add as child
-                    let children = this.getNestedValue(parent, childrenKey) || [];
-                    if (!Array.isArray(children)) {
-                        children = [];
-                    }
-                    // Check if already added
-                    const exists = children.some(child => String(this.getNestedValue(child, primaryKey) || '') === itemId);
-                    if (!exists) {
-                        children.push(item);
-                        this.setNestedValue(parent, childrenKey, children);
-                        this.setNestedValue(parent, 'hasChildren', true);
-                        processedItems.add(itemId);
-                    }
+            if (parentId && itemMap.has(parentId)) {
+                // Item has a parent - add to parent's children
+                const parent = itemMap.get(parentId);
+                let children = this.getNestedValue(parent, childrenKey) || [];
+                if (!Array.isArray(children)) {
+                    children = [];
                 }
-                else {
-                    // Parent not found yet - add as root for now (will be moved if parent appears later)
-                    result.push(item);
-                    processedItems.add(itemId);
+                // Check if already added
+                const exists = children.some(child => String(this.getNestedValue(child, primaryKey) || '') === itemId);
+                if (!exists) {
+                    children.push(item);
+                    this.setNestedValue(parent, childrenKey, children);
+                    this.setNestedValue(parent, 'hasChildren', true);
                 }
             }
             else {
-                // No parent - add as root
+                // No parent or parent not found - add as root
                 result.push(item);
-                processedItems.add(itemId);
             }
         });
-        return result;
+        // Second pass: flatten the tree structure for display, showing children when parent is expanded
+        const flattenedResult = [];
+        const processItem = (item, depth = 0) => {
+            // If it's a group header, add it directly
+            if (item?._isGroupHeader) {
+                flattenedResult.push(item);
+                return;
+            }
+            // Add the item with its level
+            const itemWithLevel = {
+                ...item,
+                [levelKey]: depth
+            };
+            flattenedResult.push(itemWithLevel);
+            // Check if item has children and is expanded
+            const children = this.getNestedValue(item, childrenKey) || [];
+            const isExpanded = this.getNestedValue(item, expandedKey) || false;
+            // If item is expanded and has children, recursively process children
+            if (isExpanded && Array.isArray(children) && children.length > 0) {
+                children.forEach(child => {
+                    processItem(child, depth + 1);
+                });
+            }
+        };
+        // Process all root items (items that were added directly to result)
+        result.forEach(item => {
+            processItem(item);
+        });
+        return flattenedResult;
     }
     /**
      * Toggle expand/collapse state of a tree item with unlimited nesting support
@@ -11663,12 +11667,12 @@ class CideEleDataGridComponent {
             // If tree is enabled, we need to flatten tree first for grouping, then preserve structure
             const treeConfig = this.mergedConfig().tree;
             if (treeConfig?.enabled) {
-                // Flatten tree structure for grouping, but preserve parent-child relationships
+                // Flatten tree structure completely for grouping (all items including children)
                 data = this.flattenTreeForGrouping(data);
             }
             // Apply grouping
             data = this.getGroupedData(data, grouped);
-            // If tree is enabled, restore tree structure within groups
+            // If tree is enabled, restore tree structure within groups and show children when expanded
             if (treeConfig?.enabled) {
                 data = this.restoreTreeStructureInGroups(data);
             }