chore(*): Fix previous dim records shifting to be consistent and not dependant on how it is stored.

Author: skrustev

projects/igniteui-angular/src/lib/data-operations/pivot-strategy.ts

@@ -28,52 +28,53 @@ export class PivotRowDimensionsStrategy implements IPivotDimensionStrategy {
     }
 
     public process(
-            collection: any,
-            rows: IPivotDimension[],
-            values?: IPivotValue[],
-            pivotKeys: IPivotKeys =
-            { aggregations: 'aggregations', records: 'records', children: 'children', level: 'level'}
-        ): any[] {
-            let hierarchies;
-            let data;
-            const prevRowDims = [];
-            let prevDim;
-            let prevDimTopRecords = [];
-            const currRows = cloneArray(rows, true);
-            PivotUtil.assignLevels(currRows);
-            for (const row of currRows) {
-                if (!data) {
-                    // build hierarchies - groups and subgroups
-                    hierarchies = PivotUtil.getFieldsHierarchy(collection, [row], PivotDimensionType.Row, pivotKeys);
-                    // generate flat data from the hierarchies
-                    data = PivotUtil.processHierarchy(hierarchies, collection[0] ?? [], pivotKeys, 0, true);
-                    prevRowDims.push(row);
-                    prevDim = row;
-                    prevDimTopRecords = data;
-                } else {
-                    const newData = [...data];
-                    const curDimTopRecords = [];
-                    for (let i = 0; i < newData.length; i++) {
-                        const currData = newData[i][prevDim.memberName + '_' + pivotKeys.records];
-                        const leafData = PivotUtil.getDirectLeafs(currData, pivotKeys);
-                        const hierarchyFields = PivotUtil
-                            .getFieldsHierarchy(leafData, [row], PivotDimensionType.Row, pivotKeys);
-                        const siblingData = PivotUtil
-                            .processHierarchy(hierarchyFields, newData[i] ?? [], pivotKeys, 0);
-                        PivotUtil.processSiblingProperties(newData[i], siblingData, pivotKeys);
+        collection: any,
+        rows: IPivotDimension[],
+        values?: IPivotValue[],
+        pivotKeys: IPivotKeys =
+            { aggregations: 'aggregations', records: 'records', children: 'children', level: 'level' }
+    ): any[] {
+        let hierarchies;
+        let data;
+        const prevRowDims = [];
+        let prevDim;
+        let prevDimTopRecords = [];
+        const currRows = cloneArray(rows, true);
+        PivotUtil.assignLevels(currRows);
+        for (const row of currRows) {
+            if (!data) {
+                // build hierarchies - groups and subgroups
+                hierarchies = PivotUtil.getFieldsHierarchy(collection, [row], PivotDimensionType.Row, pivotKeys);
+                // generate flat data from the hierarchies
+                data = PivotUtil.processHierarchy(hierarchies, collection[0] ?? [], pivotKeys, 0, true);
+                prevRowDims.push(row);
+                prevDim = row;
+                prevDimTopRecords = data;
+            } else {
+                const newData = [...data];
+                const curDimTopRecords = [];
+                for (let i = 0; i < newData.length; i++) {
+                    const currData = newData[i][prevDim.memberName + '_' + pivotKeys.records];
+                    const leafData = PivotUtil.getDirectLeafs(currData, pivotKeys);
+                    const hierarchyFields = PivotUtil
+                        .getFieldsHierarchy(leafData, [row], PivotDimensionType.Row, pivotKeys);
+                    const siblingData = PivotUtil
+                        .processHierarchy(hierarchyFields, newData[i] ?? [], pivotKeys, 0);
+                    PivotUtil.processSiblingProperties(newData[i], siblingData, pivotKeys);
 
                     PivotUtil.processSubGroups(row, prevRowDims.slice(0), siblingData, pivotKeys);
-                    if ((prevDimTopRecords[i].length != undefined && prevDimTopRecords[i].length < siblingData.length) || prevDimTopRecords.length <= siblingData.length) {
+                    if ((prevDimTopRecords[i].length != undefined && prevDimTopRecords[i].length < siblingData.length) || prevDimTopRecords.length < siblingData.length) {
+                        // Add the sibling data as child records because the previous dimension contains more dense version of the previous dimension records.
                         newData[i][row.memberName + '_' + pivotKeys.records] = siblingData;
                     } else {
+                        // Replace the current record with the sibling records because the current dimension is a denser version or produces the same amount of records.
                         newData.splice(i, 1, ...siblingData);
-                        if (prevDimTopRecords[i].length == undefined ) {
-                            prevDimTopRecords.splice(siblingData.length, prevDimTopRecords.length - siblingData.length, ...prevDimTopRecords);
-                        } else {
-                            prevDimTopRecords[i].splice(siblingData.length, prevDimTopRecords.length -  siblingData.length, ...prevDimTopRecords[i]);
-                        }
+                        // Shift the prevDimTopRecords item to the right because of the previous row transforms the newData and increases the elements in newData
+                        prevDimTopRecords.splice(siblingData.length, prevDimTopRecords.length - siblingData.length, ...prevDimTopRecords);
+                        // Increase the index the amount of sibling record that replaces the current one. Subtract 1 because there is already i++ in the for cycle.
                         i += siblingData.length - 1;
                     }
+                    // Add the current top sibling elements for the dimension
                     curDimTopRecords.push(cloneArray(siblingData, true));
                 }
                 data = newData;