igniteui-angular 21.0.0 → 21.0.1

package/fesm2022/igniteui-angular-grids-core.mjs

@@ -19471,10 +19471,7 @@ class CharSeparatedValueData {
         this._isSpecialData = ExportUtilities.isSpecialData(this._data[0]);
         this._escapeCharacters.push(this._delimiter);
         const headers = columns && columns.length ?
-            /* When column groups are present, always use the field as it indicates the group the column belongs to.
-            * Otherwise, in PivotGrid scenarios we can end up with many duplicated column names without a hint what they represent.
-            */
-            columns.map(c => c.columnGroupParent ? c.field : c.header ?? c.field) :
+            columns.map(c => c.header ?? c.field) :
             keys;
         this._headerRecord = this.processHeaderRecord(headers, this._data.length);
         if (keys.length === 0 || ((!this._data || this._data.length === 0) && keys.length === 0)) {
@@ -19848,6 +19845,8 @@ class IgxPdfExporterService extends IgxBaseExporter {
             }
             // Draw data rows
             pdf.setFont('helvetica', 'normal');
+            // Check if this is a tree grid export (tree grids can have both TreeGridRecord and DataRecord types for nested children)
+            const isTreeGridExport = data.some(record => record.type === ExportRecordType.TreeGridRecord);
             // For pivot grids, get row dimension columns to help with value lookup
             const rowDimensionColumnsByLevel = new Map();
             if (isPivotGrid && defaultOwner) {
@@ -19892,11 +19891,13 @@ class IgxPdfExporterService extends IgxBaseExporter {
                 // Calculate indentation for hierarchical records
                 // TreeGrid supports both hierarchical data and flat self-referencing data (with foreignKey)
                 // In both cases, the base exporter sets the level property on TreeGridRecord
-                const isTreeGrid = record.type === 'TreeGridRecord';
+                // Note: Nested child records without children are created as DataRecord type,
+                // but they still have a level property and should be treated as tree grid records
                 const recordIsHierarchicalGrid = record.type === 'HierarchicalGridRecord';
                 // For tree grids, indentation is visual (in the first column text)
                 // For hierarchical grids, we don't use indentation (level determines column offset instead)
-                const indentLevel = isTreeGrid ? (record.level || 0) : 0;
+                // If this is a tree grid export and the record has a level property, use it for indentation
+                const indentLevel = (isTreeGridExport && record.level !== undefined) ? (record.level || 0) : 0;
                 const indent = indentLevel * indentSize;
                 // Draw parent row
                 this.drawDataRow(pdf, record, leafColumns, rowDimensionFields, margin, yPosition, columnWidth, rowHeight, indent, options, allColumns, isPivotGrid, rowDimensionColumnsByLevel, i, rowDimensionHeaders);
@@ -19904,24 +19905,17 @@ class IgxPdfExporterService extends IgxBaseExporter {
                 // For hierarchical grids, check if this record has child records
                 if (recordIsHierarchicalGrid) {
                     const allDescendants = [];
-                    // Collect all descendant records (children, grandchildren, etc.) that belong to this parent
-                    // Child records have a different owner (island object) than the parent
                     let j = i + 1;
                     while (j < data.length && data[j].level > record.level) {
-                        // Include all descendants (any level deeper)
                         if (!data[j].hidden) {
-                            allDescendants.push(data[j]);
+                            // Attach the original index into data
+                            allDescendants.push({ ...data[j], __index: j });
                         }
                         j++;
                     }
-                    // If there are descendant records, draw child table(s)
                     if (allDescendants.length > 0) {
-                        // Group descendants by owner to separate different child grids
-                        // Owner is the actual island object, not a string
-                        // Only collect DIRECT children (one level deeper) for initial grouping
                         const directDescendantsByOwner = new Map();
                         for (const desc of allDescendants) {
-                            // Only include records that are exactly one level deeper (direct children)
                             if (desc.level === record.level + 1) {
                                 const owner = desc.owner;
                                 if (!directDescendantsByOwner.has(owner)) {
@@ -19930,12 +19924,11 @@ class IgxPdfExporterService extends IgxBaseExporter {
                                 directDescendantsByOwner.get(owner).push(desc);
                             }
                         }
-                        // Draw each child grid separately with its direct children only
                         for (const [owner, directChildren] of directDescendantsByOwner) {
-                            yPosition = this.drawHierarchicalChildren(pdf, data, allDescendants, // Pass all descendants so grandchildren can be found
-                            directChildren, owner, yPosition, margin, childTableIndent, usableWidth, pageHeight, headerHeight, rowHeight, options);
+                            yPosition = this.drawHierarchicalChildren(pdf, data, allDescendants, // descendants WITH __index
+                            directChildren, // direct children WITH __index
+                            owner, yPosition, margin, childTableIndent, usableWidth, pageHeight, headerHeight, rowHeight, options);
                         }
-                        // Skip the descendant records we just processed
                         i = j - 1;
                     }
                 }
@@ -20200,29 +20193,42 @@ class IgxPdfExporterService extends IgxBaseExporter {
             // Draw the child record
             this.drawDataRow(pdf, childRecord, childColumns, [], childTableX, yPosition, childColumnWidth, rowHeight, 0, options);
             yPosition += rowHeight;
-            // Check if this child has grandchildren (deeper levels in different child grids)
-            // Look for grandchildren in allDescendants that are direct descendants of this childRecord
-            const grandchildrenForThisRecord = allDescendants.filter(r => r.level === childRecord.level + 1 && r.type !== 'HeaderRecord');
-            if (grandchildrenForThisRecord.length > 0) {
-                // Group grandchildren by their owner (different child islands under this record)
-                const grandchildrenByOwner = new Map();
-                for (const gc of grandchildrenForThisRecord) {
-                    // Use the actual owner object
-                    const gcOwner = gc.owner;
-                    // Only include grandchildren that have a different owner (separate child grid)
-                    if (gcOwner !== childOwner) {
-                        if (!grandchildrenByOwner.has(gcOwner)) {
-                            grandchildrenByOwner.set(gcOwner, []);
+            // allDescendants here is an array of records with an extra __index property
+            const childIndex = childRecord.__index;
+            if (childIndex !== undefined) {
+                // Find this child's position in allDescendants (by original index)
+                const childPosInDesc = allDescendants.findIndex(d => d.__index === childIndex);
+                if (childPosInDesc !== -1) {
+                    const subtree = [];
+                    const childLevel = childRecord.level;
+                    // Collect all deeper records until we hit same-or-higher level
+                    for (let k = childPosInDesc + 1; k < allDescendants.length; k++) {
+                        const rec = allDescendants[k];
+                        if (rec.level <= childLevel) {
+                            break;
+                        }
+                        if (rec.type !== 'HeaderRecord') {
+                            subtree.push(rec);
+                        }
+                    }
+                    if (subtree.length > 0) {
+                        // Direct grandchildren for this child: exactly one level deeper
+                        const grandchildrenForThisRecord = subtree.filter(r => r.level === childRecord.level + 1 && r.owner !== childOwner);
+                        if (grandchildrenForThisRecord.length > 0) {
+                            const grandchildrenByOwner = new Map();
+                            for (const gc of grandchildrenForThisRecord) {
+                                const gcOwner = gc.owner;
+                                if (!grandchildrenByOwner.has(gcOwner)) {
+                                    grandchildrenByOwner.set(gcOwner, []);
+                                }
+                                grandchildrenByOwner.get(gcOwner).push(gc);
+                            }
+                            for (const [gcOwner, directGrandchildren] of grandchildrenByOwner) {
+                                yPosition = this.drawHierarchicalChildren(pdf, allData, subtree, // only this child's subtree for deeper levels
+                                directGrandchildren, gcOwner, yPosition, margin, indentPerLevel + 20, usableWidth, pageHeight, headerHeight, rowHeight, options);
+                            }
                         }
-                        grandchildrenByOwner.get(gcOwner).push(gc);
                     }
-                }
-                // Recursively draw each grandchild owner's records with increased indentation
-                for (const [gcOwner, directGrandchildren] of grandchildrenByOwner) {
-                    yPosition = this.drawHierarchicalChildren(pdf, allData, allDescendants, // Pass all descendants so great-grandchildren can be found
-                    directGrandchildren, // Direct grandchildren to render
-                    gcOwner, yPosition, margin, indentPerLevel + 20, // Increase indentation for next level
-                    usableWidth, pageHeight, headerHeight, rowHeight, options);
                 }
             }
         }