cloud-ide-element 1.1.86 → 1.1.88

package/fesm2022/cloud-ide-element.mjs

@@ -9634,7 +9634,9 @@ class CideEleDataGridComponent {
      */
     getItemId(item) {
         if (item && typeof item === 'object') {
-            const id = item['_id'];
+            // Use trackBy from config, fallback to '_id' if not specified
+            const trackBy = this.mergedConfig().trackBy || '_id';
+            const id = this.getNestedValue(item, trackBy);
             return id ? String(id) : null;
         }
         return null;
@@ -9768,26 +9770,13 @@ class CideEleDataGridComponent {
                     valueA = '';
                 if (valueB === null || valueB === undefined)
                     valueB = '';
-                // Handle objects - extract display text for comparison
+                // Handle objects - convert to string for comparison
+                // The consuming component should normalize data before passing to grid
                 if (typeof valueA === 'object' && valueA !== null && !Array.isArray(valueA) && !(valueA instanceof Date)) {
-                    const objA = valueA;
-                    const displayProps = ['name', 'title', 'label', 'text', 'display_text', 'user_fullname', 'sygms_title'];
-                    for (const prop of displayProps) {
-                        if (objA[prop] !== undefined && objA[prop] !== null) {
-                            valueA = objA[prop];
-                            break;
-                        }
-                    }
+                    valueA = String(valueA);
                 }
                 if (typeof valueB === 'object' && valueB !== null && !Array.isArray(valueB) && !(valueB instanceof Date)) {
-                    const objB = valueB;
-                    const displayProps = ['name', 'title', 'label', 'text', 'display_text', 'user_fullname', 'sygms_title'];
-                    for (const prop of displayProps) {
-                        if (objB[prop] !== undefined && objB[prop] !== null) {
-                            valueB = objB[prop];
-                            break;
-                        }
-                    }
+                    valueB = String(valueB);
                 }
                 // Convert to strings for comparison
                 const strA = String(valueA || '').toLowerCase();
@@ -9917,13 +9906,12 @@ class CideEleDataGridComponent {
                         const childExists = parentChildren.some(child => String(this.getNestedValue(child, primaryKey) || '') === itemId);
                         if (!childExists) {
                             // Calculate level based on parent - automatically set level key
-                            const parentLevel = this.getNestedValue(parent, 'level') || 0;
+                            const parentLevel = this.getNestedValue(parent, levelKey) || 0;
                             const childLevel = parentLevel + 1;
                             // Update child item with correct level
                             const updatedTreeItem = {
                                 ...treeItem,
-                                [levelKey]: childLevel,
-                                level: childLevel // Always add 'level' property for consistent access
+                                [levelKey]: childLevel
                             };
                             itemMap.set(itemId, updatedTreeItem);
                             // Add updated child to parent's children array
@@ -9947,8 +9935,7 @@ class CideEleDataGridComponent {
                     // This is a root item - automatically set level to 0
                     const updatedRootItem = {
                         ...treeItem,
-                        [levelKey]: 0,
-                        level: 0 // Always add 'level' property for consistent access
+                        [levelKey]: 0
                     };
                     itemMap.set(itemId, updatedRootItem);
                     if (!rootItems.some(rootItem => String(this.getNestedValue(rootItem, primaryKey) || '') === itemId)) {
@@ -10065,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);
@@ -10086,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
@@ -10184,13 +10175,15 @@ class CideEleDataGridComponent {
                     return updatedItem;
                 }
                 // Check children recursively
-                const children = this.getNestedValue(treeItem, 'children') || [];
+                const { childrenKey = 'children' } = treeConfig;
+                const children = this.getNestedValue(treeItem, childrenKey) || [];
                 if (children.length > 0) {
                     const updatedChildren = updateItemInTree(children);
-                    return {
-                        ...treeItem,
-                        children: updatedChildren
+                    const updatedItem = {
+                        ...treeItem
                     };
+                    this.setNestedValue(updatedItem, childrenKey, updatedChildren);
+                    return updatedItem;
                 }
                 return treeItem;
             });
@@ -10414,20 +10407,14 @@ class CideEleDataGridComponent {
      * Get item level in tree
      */
     getItemLevel(item) {
-        // Always try to get level from standard 'level' property first (set by transformToTree)
-        let level = this.getNestedValue(item, 'level');
-        // If not found, try tree config level key
-        if (level === undefined || level === null) {
-            const treeConfig = this.getTreeConfig();
-            if (treeConfig) {
-                const { levelKey = 'level' } = treeConfig;
-                level = this.getNestedValue(item, levelKey) || 0;
-            }
-            else {
-                level = 0;
-            }
+        // Get level from tree config level key
+        const treeConfig = this.getTreeConfig();
+        if (treeConfig) {
+            const { levelKey = 'level' } = treeConfig;
+            const itemLevel = this.getNestedValue(item, levelKey);
+            return itemLevel !== undefined && itemLevel !== null ? itemLevel : 0;
         }
-        return level;
+        return 0;
     }
     /**
      * Check if item is expanded
@@ -10630,10 +10617,11 @@ class CideEleDataGridComponent {
             return actualOrder;
         }
         // Final fallback to index-based calculation
+        const trackBy = this.mergedConfig().trackBy || '_id';
         const currentIndex = this.displayedData.findIndex(currentItem => {
             if (item && currentItem && typeof item === 'object' && typeof currentItem === 'object') {
-                const itemId = item['_id'];
-                const currentItemId = currentItem['_id'];
+                const itemId = this.getNestedValue(item, trackBy);
+                const currentItemId = this.getNestedValue(currentItem, trackBy);
                 return itemId && currentItemId && itemId === currentItemId;
             }
             return item === currentItem;
@@ -11204,30 +11192,15 @@ class CideEleDataGridComponent {
      * Tries common field patterns based on column key
      */
     extractValueFromRowForTemplateColumn(row, column) {
-        // Try common patterns based on column key
         const rowData = row;
-        // If column key is 'details', try common detail/display fields
-        if (column.key === 'details' || column.key.includes('detail')) {
-            // Try display_text, name, title fields
-            if (rowData['fdlds_display_text'])
-                return rowData['fdlds_display_text'];
-            if (rowData['display_text'])
-                return rowData['display_text'];
-            if (rowData['name'])
-                return rowData['name'];
-            if (rowData['title'])
-                return rowData['title'];
-        }
         // Try to find a field that matches the column key pattern
-        // For example, if key is 'details', try 'detail', 'detail_text', etc.
+        // Try variations like: key, key_text, key_name, key_title, key_display
         const keyVariations = [
             column.key,
             `${column.key}_text`,
             `${column.key}_name`,
             `${column.key}_title`,
-            `${column.key}_display`,
-            `fdlds_${column.key}`,
-            `${column.key.replace('details', 'display_text')}`
+            `${column.key}_display`
         ];
         for (const variation of keyVariations) {
             if (rowData[variation] !== undefined && rowData[variation] !== null) {
@@ -11235,12 +11208,14 @@ class CideEleDataGridComponent {
             }
         }
         // Try to find any string field in the row that might be a display value
+        // Skip ID fields using trackBy from config
+        const trackBy = this.mergedConfig().trackBy || '_id';
         for (const key in rowData) {
             if (rowData.hasOwnProperty(key)) {
                 const value = rowData[key];
                 if (value !== null && value !== undefined && typeof value === 'string' && value.trim() !== '') {
-                    // Skip common ID fields
-                    if (!key.includes('_id') && !key.includes('id_')) {
+                    // Skip ID fields - use trackBy from config
+                    if (key !== trackBy && !key.toLowerCase().includes('id')) {
                         return value;
                     }
                 }
@@ -11250,16 +11225,19 @@ class CideEleDataGridComponent {
     }
     /**
      * Get a stable key for filter value comparison
-     * Handles objects by using _id or JSON stringification
+     * Handles objects by using trackBy/primaryKey or JSON stringification
      */
     getFilterValueKey(value) {
         if (value === null || value === undefined)
             return 'null';
         if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
             const obj = value;
-            // Use _id if available for object comparison
-            if ('_id' in obj && obj['_id'] !== undefined) {
-                return `obj_${String(obj['_id'])}`;
+            // Use trackBy or primaryKey from config for object comparison
+            const trackBy = this.mergedConfig().trackBy;
+            const treeConfig = this.mergedConfig().tree;
+            const primaryKey = treeConfig?.primaryKey || trackBy;
+            if (primaryKey && primaryKey in obj && obj[primaryKey] !== undefined) {
+                return `obj_${String(obj[primaryKey])}`;
             }
             // Otherwise use JSON string for comparison
             try {
@@ -11278,34 +11256,21 @@ class CideEleDataGridComponent {
             return value ? 'Yes' : 'No';
         if (value instanceof Date)
             return value.toLocaleDateString();
-        // Handle objects - try to extract display text
+        // Handle objects - convert to string generically
+        // The consuming component should normalize data before passing to grid
         if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            // Try to get first string property (excluding ID fields)
             const obj = value;
-            // Try common display property names in order of preference
-            const displayProperties = [
-                'name', 'title', 'label', 'text', 'display_text',
-                'user_fullname', 'fullname', 'full_name',
-                'sygms_title', 'sygmt_title',
-                'user_name', 'username',
-                'email', 'description'
-            ];
-            for (const prop of displayProperties) {
-                if (obj[prop] !== undefined && obj[prop] !== null && typeof obj[prop] !== 'object') {
-                    return String(obj[prop]);
-                }
-            }
-            // If no display property found, try to get first string property
             for (const key in obj) {
                 if (obj.hasOwnProperty(key) && typeof obj[key] === 'string' && obj[key] !== '') {
-                    return String(obj[key]);
+                    // Skip ID fields
+                    if (!key.toLowerCase().includes('id') && !key.toLowerCase().includes('_id')) {
+                        return String(obj[key]);
+                    }
                 }
             }
-            // Last resort: use _id if available
-            if ('_id' in obj && obj['_id'] !== undefined) {
-                return String(obj['_id']);
-            }
-            // If still no value, return a generic label
-            return '(Object)';
+            // If no suitable string property found, convert to string
+            return String(value);
         }
         // Handle arrays
         if (Array.isArray(value)) {
@@ -11456,10 +11421,15 @@ class CideEleDataGridComponent {
      * Extract ID from foreign key value generically
      * Handles both string IDs and nested objects (e.g., { _id: "...", name: "..." })
      * @param foreignKeyValue - The foreign key value (can be string, object, or null/undefined)
-     * @param primaryKey - The primary key field name (defaults to '_id')
+     * @param primaryKey - The primary key field name (from tree config or defaults to trackBy or '_id')
      * @returns The extracted ID as a string, or empty string if not found
      */
-    extractIdFromForeignKey(foreignKeyValue, primaryKey = '_id') {
+    extractIdFromForeignKey(foreignKeyValue, primaryKey) {
+        // Get primary key from tree config or trackBy, fallback to '_id'
+        if (!primaryKey) {
+            const treeConfig = this.mergedConfig().tree;
+            primaryKey = treeConfig?.primaryKey || this.mergedConfig().trackBy || '_id';
+        }
         if (foreignKeyValue === null || foreignKeyValue === undefined) {
             return '';
         }
@@ -11697,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);
             }
@@ -11773,36 +11743,10 @@ class CideEleDataGridComponent {
             if (column.formatter) {
                 displayValue = this.formatValue(displayValue, column);
             }
-            // If display value is still an object, try to extract a meaningful value
+            // If display value is still an object, convert to string
+            // The consuming component should normalize data before passing to grid
             if (typeof displayValue === 'object' && displayValue !== null && !Array.isArray(displayValue) && !(displayValue instanceof Date)) {
-                // Try to get a name/title property from the object
-                const obj = displayValue;
-                if (obj['name']) {
-                    displayValue = obj['name'];
-                }
-                else if (obj['title']) {
-                    displayValue = obj['title'];
-                }
-                else if (obj['acabrn_name']) {
-                    displayValue = obj['acabrn_name'];
-                }
-                else if (obj['acacpm_alise_title']) {
-                    displayValue = obj['acacpm_alise_title'];
-                }
-                else if (obj['acacpm_name']) {
-                    displayValue = obj['acacpm_name'];
-                }
-                else {
-                    displayValue = String(displayValue);
-                }
-            }
-            // Handle null/undefined/empty values for optional fields (e.g., optional specialization)
-            // Use a consistent label for null/undefined values to group them together
-            if (displayValue === null || displayValue === undefined || displayValue === '') {
-                displayValue = 'No Specialization';
-            }
-            if (rawValue === null || rawValue === undefined || rawValue === '') {
-                rawValue = 'No Specialization';
+                displayValue = String(displayValue);
             }
             const groupKey = `${groupColumnKey}:${this.getFilterValueKey(rawValue)}`;
             const existing = groups.get(groupKey);
@@ -12088,32 +12032,18 @@ class CideEleDataGridComponent {
         // Handle objects - extract display text
         if (typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
             const obj = value;
-            // Try common display properties
-            const displayProperties = [
-                'name', 'title', 'label', 'text', 'display_text',
-                'user_fullname', 'fullname', 'full_name',
-                'sygms_title', 'sygmt_title',
-                'user_name', 'username',
-                'email', 'description'
-            ];
-            for (const prop of displayProperties) {
-                if (obj[prop] !== undefined && obj[prop] !== null && typeof obj[prop] !== 'object') {
-                    return String(obj[prop]);
-                }
-            }
-            // Try first string property
+            // Try to get first string property (excluding ID fields)
+            // The consuming component should normalize data before passing to grid
             for (const key in obj) {
                 if (obj.hasOwnProperty(key) && typeof obj[key] === 'string' && obj[key] !== '') {
-                    if (!key.includes('_id') && !key.includes('id_')) {
+                    // Skip ID fields
+                    if (!key.toLowerCase().includes('id') && !key.toLowerCase().includes('_id')) {
                         return String(obj[key]);
                     }
                 }
             }
-            // Use _id as fallback
-            if ('_id' in obj && obj['_id'] !== undefined) {
-                return String(obj['_id']);
-            }
-            return '';
+            // If no suitable string property found, convert to string
+            return String(value);
         }
         // Handle arrays
         if (Array.isArray(value)) {