@one-grid-core/angular 0.4.0 → 0.5.0

package/fesm2022/one-grid-core-angular.mjs

@@ -1516,6 +1516,11 @@ class OneGridApi {
         }
         const validRowIds = new Set();
         this.buildRowNodes(rowData, null, 0, validRowIds);
+        // Prune BEFORE sorting and filtering: both read `_originalRowNodes`, and
+        // with the prune last, a data swap while a sort was active resurrected
+        // the removed rows into `_rowNodes` for one whole render — the old and
+        // the new dataset on screen together until the next rebuild.
+        this.pruneRemovedNodes(validRowIds);
         // Re-apply the active sort. `buildRowNodes` rebuilds the row list in the
         // order the data arrived, so without this a data update silently returned
         // the rows to that order while `sortModel` — and therefore the header's
@@ -1524,12 +1529,11 @@ class OneGridApi {
         if (this._sortModel.length > 0)
             this.applySorting();
         this.applyFilters();
-        this.pruneRemovedNodes(validRowIds);
     }
     /**
      * Recursive Build Row Nodes (Optimized)
      */
-    buildRowNodes(rowData, parent = null, level = 0, validRowIds = new Set(), expandedIds = new Set(this.expansionService.getExpandedIds()), collapsedIds = new Set(this.expansionService.getCollapsedIds()), selectedIds = new Set(this.selectionService.getSelectedIds())) {
+    buildRowNodes(rowData, parent = null, level = 0, validRowIds = new Set(), expandedIds = new Set(this.expansionService.getExpandedIds()), collapsedIds = new Set(this.expansionService.getCollapsedIds()), selectedIds = new Set(this.selectionService.getSelectedIds()), visitedData = new Set()) {
         if (parent === null) {
             this._rowNodes = [];
             this._currentIndex = 0;
@@ -1539,6 +1543,16 @@ class OneGridApi {
         const nodes = [];
         for (const data of rowData) {
             const rowId = this.rowService.generateRowId(data, this._currentIndex);
+            // A cycle in the children graph — a row reachable from its own subtree,
+            // the classic ORM back-reference — used to recurse until the stack blew,
+            // freezing the app; and with generated row ids it did so while minting
+            // nodes the whole way down. The same guard also drops a duplicate row id
+            // (or the same row object appearing twice): first occurrence wins.
+            if (visitedData.has(data) || validRowIds.has(rowId)) {
+                console.warn(`[one-grid] cyclic or duplicate row (id "${rowId}") — skipped, first occurrence wins. Tree data must be acyclic and row ids unique.`);
+                continue;
+            }
+            visitedData.add(data);
             const children = data[this.treeDataChildrenField] || null;
             let node = this._originalRowNodes.get(rowId);
             validRowIds.add(rowId);
@@ -1575,7 +1589,7 @@ class OneGridApi {
             this._currentIndex++;
             this._rowNodes.push(node);
             nodes.push(node);
-            node.children = this.treeData && childrenExist ? this.buildRowNodes(children || [], node, level + 1, validRowIds, expandedIds, collapsedIds, selectedIds) : [];
+            node.children = this.treeData && childrenExist ? this.buildRowNodes(children || [], node, level + 1, validRowIds, expandedIds, collapsedIds, selectedIds, visitedData) : [];
         }
         return nodes;
     }
@@ -1774,7 +1788,7 @@ class OneGridApi {
             this._rowNodes = [...this._originalRowNodes.values()];
             return;
         }
-        this._rowNodes = [...this._originalRowNodes.values()].sort((a, b) => {
+        const comparator = (a, b) => {
             for (const sortItem of this._sortModel) {
                 const { colId, sort } = sortItem;
                 const valA = getFieldValue(a.data, colId);
@@ -1785,7 +1799,31 @@ class OneGridApi {
                 }
             }
             return 0;
-        });
+        };
+        if (!this.treeData) {
+            this._rowNodes = [...this._originalRowNodes.values()].sort(comparator);
+            return;
+        }
+        // A tree sorts siblings within their parent, never across it — a flat
+        // sort of the whole list interleaved parents with other parents' children
+        // and scrambled the hierarchy. Sorting the sibling arrays and re-walking
+        // depth-first keeps every parent immediately above its own children,
+        // which `refreshVisibleNodes` also depends on for its visibility cache.
+        // Group rows carry their aggregates in `data`, so sorting a grouped grid
+        // on an aggregated column orders the groups by their aggregate.
+        const flattened = [];
+        const walk = (siblings) => {
+            const sorted = [...siblings].sort(comparator);
+            for (const node of sorted) {
+                flattened.push(node);
+                if (node.children?.length) {
+                    node.children = walk(node.children);
+                }
+            }
+            return sorted;
+        };
+        walk([...this._originalRowNodes.values()].filter(node => !node.parent));
+        this._rowNodes = flattened;
     }
     compareValues(valA, valB, sortDirection) {
         // `undefined` has to be treated as empty alongside `null`: getFieldValue