@one-grid-core/angular 0.1.0-beta.5 → 0.2.0

package/esm2022/lib/core/instants/one-grid-api.class.mjs

@@ -1,5 +1,5 @@
 import { OneRowNode } from "./one-row-node.class";
-import { filterTreeNode } from "../../helpers/one-filter.helper";
+import { filterTreeNode, isFilterActive } from "../../helpers/one-filter.helper";
 import { getFieldValue } from "../../helpers/one-cell.helper";
 import { v4 as uuidv4 } from 'uuid';
 import { Injectable } from "@angular/core";
@@ -11,6 +11,30 @@ import * as i4 from "../services/one-grid-event.service";
 import * as i5 from "../services/one-grid-selection.service";
 import * as i6 from "../services/one-grid-expansion.service";
 export class OneGridApi {
+    /** Unique per grid instance, assigned during `init`. */
+    get id() {
+        return this._id;
+    }
+    /** The `[context]` the grid was given. */
+    get context() {
+        return this._context;
+    }
+    /** Selection mode, captured during `init`. Changing the input later has no effect. */
+    get rowSelection() {
+        return this._rowSelection;
+    }
+    /** Which role this instance plays: simple, master, detail or tree. */
+    get apiType() {
+        return this._apiType;
+    }
+    /** Every node the grid holds, in flattened order. */
+    get rowNodes() {
+        return this._rowNodes;
+    }
+    /** The sort model currently applied. Change it with `onSortChanged`. */
+    get sortModel() {
+        return this._sortModel;
+    }
     constructor(columnService, rowService, cellService, eventService, selectionService, expansionService) {
         this.columnService = columnService;
         this.rowService = rowService;
@@ -18,17 +42,18 @@ export class OneGridApi {
         this.eventService = eventService;
         this.selectionService = selectionService;
         this.expansionService = expansionService;
-        this.context = null;
-        this.rowSelection = null;
-        this.apiType = null;
-        this.rowNodes = [];
-        this.sortModel = [];
+        this._context = null;
+        this._rowSelection = null;
+        this._apiType = null;
+        this._rowNodes = [];
+        this._sortModel = [];
         this.rowHeight = 26;
         this.headerRowHeight = 32;
         this._currentIndex = 0;
         this._quickFilterValue = null;
         this._activeFilters = [];
         this._visibleRowNodes = [];
+        this._pinnedRowNodes = { top: [], bottom: [] };
         this._originalRowNodes = new Map();
         this._nodeCleanupMap = new Map(); // Cleanup registry (prevents memory leaks)
         this._destroyed = false;
@@ -38,63 +63,83 @@ export class OneGridApi {
         this.groupDefaultExpanded = 0;
         this.masterDetail = false;
     }
-    init(gridApiType, rowSelection, columnDefs, defaultColumnDef, context, masterDetail, detailCellRendererParams, detailRendererComponent, treeData, groupColumnDefs) {
-        this.id = uuidv4();
-        this.apiType = gridApiType;
-        this.rowSelection = rowSelection;
-        this.context = context;
+    /**
+     * Stand the grid up. Called by `OneGridComponent` from `ngOnInit`.
+     *
+     * Takes a single `OneGridInitOptions` rather than the ten positional
+     * arguments it used to, so a call site reads as the configuration it is and
+     * a new option no longer means editing every caller.
+     *
+     * @internal Applications obtain a ready-made API from `(onGridReady)`; they
+     * should never call this themselves.
+     */
+    init(options) {
+        const { gridType, columnDefs, defaultColumnDef = {}, groupColumnDefs = [], context = null, rowSelection = null, masterDetail = false, detailCellRendererParams = null, detailRendererComponent = null, treeData = false, } = options;
+        this._id = uuidv4();
+        this._apiType = gridType;
+        this._rowSelection = rowSelection;
+        this._context = context;
         this.masterDetail = masterDetail;
         this.detailCellRendererParams = detailCellRendererParams;
         this.detailRendererComponent = detailRendererComponent;
         this.treeData = treeData;
-        this.selectionService.setSelectionMode(this.rowSelection);
-        this.rowService.setGetRowIdFn(this.context?.componentParent?.getRowId ?? null);
+        this.selectionService.setSelectionMode(rowSelection);
+        this.rowService.setGetRowIdFn(context?.componentParent?.getRowId ?? null);
         this.cellService.applyColumnDefs(columnDefs, context);
-        this.columnService.initColumnDefs(defaultColumnDef, columnDefs, groupColumnDefs);
+        this.cellService.setGridApi(this);
+        this.columnService.initColumnDefs(defaultColumnDef, columnDefs, groupColumnDefs, context);
         const columnState = this.columnService.getColumnState();
         setTimeout(() => this.eventService.dispatchEvent('columnChanged', columnState));
     }
     /**
-     * Create Row Node & Clear All State IDS
+     * Replace every row, discarding selection and expansion.
+     *
+     * Use this when the rows represent something new. To swap the data while
+     * keeping what the user has selected and opened, use `updateRowData`.
      */
     setRowData(rowData) {
-        const validRowIds = new Set();
-        // Clear All State IDS
-        this.selectionService.deselectAll();
-        this.expansionService.clear();
-        // Build New Row Nodes
-        this.buildRowNodes(rowData, null, 0, validRowIds);
-        // Apply Filter
-        this.applyFilters();
-        // Remove invalid nodes from map
-        for (const rowId of this._originalRowNodes.keys()) {
-            if (!validRowIds.has(rowId)) {
-                this._originalRowNodes.delete(rowId);
-            }
-        }
+        this.rebuildRows(rowData, true);
     }
     /**
-     * Create Row Nodes & Not Clear State IDS
+     * Replace every row, keeping selection and expansion.
+     *
+     * State is keyed by row id, so this only preserves anything if the grid has a
+     * `context.componentParent.getRowId` — otherwise each rebuild mints new ids
+     * and there is nothing left to match against.
      */
     updateRowData(rowData) {
+        this.rebuildRows(rowData, false);
+    }
+    /**
+     * The one row-loading path. `setRowData` and `updateRowData` differed only in
+     * whether they cleared the state services first, so everything else — build,
+     * filter, prune — lives here once.
+     */
+    rebuildRows(rowData, resetState) {
+        if (this._destroyed)
+            return;
+        if (resetState) {
+            this.selectionService.deselectAll();
+            this.expansionService.clear();
+        }
         const validRowIds = new Set();
-        // Build New Row Nodes
         this.buildRowNodes(rowData, null, 0, validRowIds);
-        // Apply Filter
+        // 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
+        // sort arrow — still said they were sorted. Sorting before filtering
+        // because filtering only sets visibility on whatever order this leaves.
+        if (this._sortModel.length > 0)
+            this.applySorting();
         this.applyFilters();
-        // Remove invalid nodes from map
-        for (const rowId of this._originalRowNodes.keys()) {
-            if (!validRowIds.has(rowId)) {
-                this._originalRowNodes.delete(rowId);
-            }
-        }
+        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())) {
         if (parent === null) {
-            this.rowNodes = [];
+            this._rowNodes = [];
             this._currentIndex = 0;
         }
         if (!rowData?.length)
@@ -120,7 +165,11 @@ export class OneGridApi {
                 }
             }
             const childrenExist = children && children.length >= 0;
-            node.group = this.masterDetail ? false : childrenExist;
+            // Coerced, because `childrenExist` is `children && children.length >= 0`
+            // — which is `null` for a row with no children field, not `false`. These
+            // are declared `boolean`, and assigning null made every consumer compare
+            // truthiness instead of the value.
+            node.group = this.masterDetail ? false : !!childrenExist;
             node.leaf = this.masterDetail ? true : !node.group;
             node.leafGroup = this.masterDetail ? false : (node.group && !childrenExist);
             node.expandable = this.masterDetail ? true : (node.group && !node.leafGroup);
@@ -128,11 +177,11 @@ export class OneGridApi {
             node.setExpanded(expandedIds.has(rowId) ? true : collapsedIds.has(rowId) ? false : defaultExpanded);
             node.setSelected(selectedIds.has(rowId));
             node.setCellStates(this.cellService.generateCellStates(node));
-            if (this.masterDetail && this.apiType === 'master') {
-                this.getDetailRowData({ data, node: node, successCallback: (detailRowData) => node.setDetailRowData(detailRowData) });
+            if (this.masterDetail && this._apiType === 'master') {
+                this._getDetailRowData({ data, node: node, successCallback: (detailRowData) => node.setDetailRowData(detailRowData) });
             }
             this._currentIndex++;
-            this.rowNodes.push(node);
+            this._rowNodes.push(node);
             nodes.push(node);
             node.children = this.treeData && childrenExist ? this.buildRowNodes(children || [], node, level + 1, validRowIds, expandedIds, collapsedIds, selectedIds) : [];
         }
@@ -144,19 +193,37 @@ export class OneGridApi {
     applyFilters() {
         const filters = this._activeFilters;
         const quick = this._quickFilterValue?.toLowerCase() ?? '';
-        this.rowNodes.forEach(node => filterTreeNode(node, filters, quick));
+        // The fields the grid actually shows. Without them the quick filter falls
+        // back to every property on the row, which lets a user match on data that
+        // has no column and never appears on screen.
+        const fields = this.quickFilterFields();
+        this._rowNodes.forEach(node => filterTreeNode(node, filters, quick, fields));
         this.refreshVisibleNodes();
     }
+    /**
+     * Which fields the quick filter searches: every column that has one.
+     *
+     * Empty while the columns are still being registered, in which case the
+     * helper falls back to searching the row — the same behaviour as before, and
+     * the only sensible answer when the grid does not yet know its columns.
+     */
+    quickFilterFields() {
+        return this.columnService
+            .getColumnState()
+            .columns
+            .map(column => column.field)
+            .filter((field) => !!field && field !== '_oneRowNumber');
+    }
     /**
      * Update Row Nodes Display
      */
-    refreshVisibleNodes() {
+    refreshVisibleNodes(dispatch = true) {
         if (this._destroyed)
             return;
         const visibleNodes = [];
         let rowNumber = 1;
         const visibilityCache = new Map();
-        for (const node of this.rowNodes) {
+        for (const node of this._rowNodes) {
             const parentVisible = node.parent ? visibilityCache.get(node.parent.rowId) : true;
             const isVisible = node.visible && parentVisible && (!node.parent || node.parent.expanded);
             visibilityCache.set(node.rowId, isVisible);
@@ -170,7 +237,132 @@ export class OneGridApi {
             }
         }
         this._visibleRowNodes = [...visibleNodes];
-        this.eventService.dispatchEvent('rowDataChanged', { nodes: visibleNodes });
+        if (dispatch)
+            this.eventService.dispatchEvent('rowDataChanged', { nodes: visibleNodes });
+    }
+    /**
+     * Replace the rows anchored to one edge of the grid.
+     *
+     * Pinned rows are deliberately kept out of `rowNodes` and
+     * `_originalRowNodes`: they are not data. Sorting, filtering, selection,
+     * expansion, pagination and the visible row count all ignore them, which is
+     * the whole point of a summary row. They render with the same column
+     * definitions, so renderers and value getters work as they do everywhere
+     * else.
+     */
+    setPinnedRowData(side, rowData) {
+        if (this._destroyed)
+            return;
+        for (const node of this._pinnedRowNodes[side])
+            node.destroy();
+        this._pinnedRowNodes[side] = (rowData ?? []).map((data, index) => {
+            // Ids are namespaced by side and position. They never collide with a data
+            // row's id, and they are stable across rebuilds, which keeps the rendered
+            // `data-cell-id` attributes stable too.
+            const node = new OneRowNode(`one-pinned-${side}-${index}`, data, index);
+            node.level = 0;
+            node.leaf = true;
+            node.visible = true;
+            node.setCellStates(this.cellService.generateCellStates(node));
+            return node;
+        });
+        this.eventService.dispatchEvent('pinnedRowDataChanged', {
+            side,
+            nodes: this._pinnedRowNodes[side],
+        });
+    }
+    /** The rows anchored to one edge. Read-only; change them with `setPinnedRowData`. */
+    getPinnedRowNodes(side) {
+        return this._pinnedRowNodes[side];
+    }
+    /**
+     * Row reordering
+     * --------------------------------------------------------------------------
+     *
+     * `_originalRowNodes` is the source of truth for row order: its insertion
+     * order is what `applySorting` falls back to when the sort model empties, and
+     * what a rebuild walks. `_rowNodes` is only the current display order. A move
+     * that touched one and not the other would either be undone by the next sort
+     * change or invisible until one happened, so both are rewritten together.
+     */
+    /**
+     * Whether the displayed order is the data order, and so whether a manual move
+     * would survive.
+     *
+     * @returns the reason reordering is unavailable, or `null` when it is fine.
+     */
+    getRowDragSuppressedReason() {
+        if (this.treeData)
+            return 'treeData';
+        if (this._sortModel.length > 0)
+            return 'sorted';
+        if (isFilterActive(this._activeFilters, this._quickFilterValue ?? ''))
+            return 'filtered';
+        return null;
+    }
+    /** Convenience inverse of {@link getRowDragSuppressedReason}. */
+    canReorderRows() {
+        return this.getRowDragSuppressedReason() === null;
+    }
+    /**
+     * Move a row from one position to another.
+     *
+     * Indices are positions in the grid's row order, the same order
+     * `getAllRowNodes()` returns. `targetIndex` is where the row ends up *after*
+     * it has been lifted out of `sourceIndex` — dragging row 0 to the bottom of a
+     * 5-row grid is `moveRow(0, 4)`, not `moveRow(0, 5)`.
+     *
+     * @returns `true` if the rows moved. `false` when the move was rejected —
+     *          out-of-range indices, a no-op, or an order the grid does not own
+     *          (see {@link getRowDragSuppressedReason}) — so a caller can tell a
+     *          refused move from an applied one.
+     */
+    moveRow(sourceIndex, targetIndex) {
+        if (this._destroyed)
+            return false;
+        if (!this.canReorderRows())
+            return false;
+        const order = [...this._originalRowNodes.values()];
+        if (!Number.isInteger(sourceIndex) || !Number.isInteger(targetIndex))
+            return false;
+        if (sourceIndex < 0 || sourceIndex >= order.length)
+            return false;
+        if (targetIndex < 0 || targetIndex >= order.length)
+            return false;
+        if (sourceIndex === targetIndex)
+            return false;
+        const [moved] = order.splice(sourceIndex, 1);
+        order.splice(targetIndex, 0, moved);
+        // Rebuilt rather than mutated: a Map preserves insertion order, and there
+        // is no way to reposition a key within one.
+        this._originalRowNodes = new Map(order.map(node => [node.rowId, node]));
+        this._rowNodes = order;
+        this.reindexRows();
+        this.eventService.dispatchEvent('rowOrderChanged', { nodes: this._visibleRowNodes, node: moved, fromIndex: sourceIndex, toIndex: targetIndex });
+        return true;
+    }
+    /**
+     * Move a row identified by id. Convenient when the caller holds a node rather
+     * than a position — the index it was built with goes stale after any move.
+     */
+    moveRowById(rowId, targetIndex) {
+        const sourceIndex = [...this._originalRowNodes.values()].findIndex(node => node.rowId === rowId);
+        return sourceIndex === -1 ? false : this.moveRow(sourceIndex, targetIndex);
+    }
+    /**
+     * Re-stamp `rowIndex` from the current order.
+     *
+     * Row index is denormalised onto every node, and half the grid reads it —
+     * cell params, the range selection, the detail lookup. Leaving it stale after
+     * a move puts every row below the drop point one out.
+     */
+    reindexRows() {
+        this._rowNodes.forEach((node, index) => node.setRowIndex(index));
+        // Silent: row numbers and the visible list have to be rebuilt, but the
+        // `rowDataChanged` that normally follows defers a frame and re-seeds detail
+        // rows. A keyboard drag fires one of these per arrow key, and `moveRow`
+        // announces itself through `rowOrderChanged` instead.
+        this.refreshVisibleNodes(false);
     }
     getVisibleRowNodes() {
         return this._visibleRowNodes;
@@ -179,17 +371,19 @@ export class OneGridApi {
      * Sorting Model Feature
      */
     onSortChanged(sortModel) {
-        this.sortModel = sortModel;
+        if (this._destroyed)
+            return;
+        this._sortModel = sortModel;
         this.applySorting();
-        this.eventService.dispatchEvent('sortChanged', { nodes: this.rowNodes });
+        this.eventService.dispatchEvent('sortChanged', { nodes: this._rowNodes });
     }
     applySorting() {
-        if (this.sortModel.length === 0) {
-            this.rowNodes = [...this._originalRowNodes.values()];
+        if (this._sortModel.length === 0) {
+            this._rowNodes = [...this._originalRowNodes.values()];
             return;
         }
-        this.rowNodes = [...this._originalRowNodes.values()].sort((a, b) => {
-            for (const sortItem of this.sortModel) {
+        this._rowNodes = [...this._originalRowNodes.values()].sort((a, b) => {
+            for (const sortItem of this._sortModel) {
                 const { colId, sort } = sortItem;
                 const valA = getFieldValue(a.data, colId);
                 const valB = getFieldValue(b.data, colId);
@@ -202,11 +396,17 @@ export class OneGridApi {
         });
     }
     compareValues(valA, valB, sortDirection) {
-        if (valA === null && valB === null)
+        // `undefined` has to be treated as empty alongside `null`: getFieldValue
+        // returns undefined for a missing field or an unresolved dotted path, and
+        // comparing undefined with < / > yields false both ways, which made such
+        // rows settle in whatever order the sort happened to encounter them.
+        const aEmpty = valA === null || valA === undefined;
+        const bEmpty = valB === null || valB === undefined;
+        if (aEmpty && bEmpty)
             return 0;
-        if (valA === null)
+        if (aEmpty)
             return sortDirection === 'asc' ? 1 : -1;
-        if (valB === null)
+        if (bEmpty)
             return sortDirection === 'asc' ? -1 : 1;
         if (typeof valA === 'string' && typeof valB === 'string') {
             const comparison = valA.localeCompare(valB, undefined, { numeric: true });
@@ -261,7 +461,7 @@ export class OneGridApi {
         const node = this.getRowNodeById(rowId);
         if (node) {
             if (this.selectionService.getSelectionMode() === 'single') {
-                this.rowNodes.forEach(rowNode => rowNode.setSelected(rowNode.rowId === node.rowId));
+                this._rowNodes.forEach(rowNode => rowNode.setSelected(rowNode.rowId === node.rowId));
                 this._originalRowNodes.forEach(rowNode => rowNode.setSelected(rowNode.rowId === node.rowId));
             }
             else {
@@ -286,13 +486,13 @@ export class OneGridApi {
      * Get & Set Functions
      */
     getAllRowNodes() {
-        return this.rowNodes?.length > 0 ? [...this.rowNodes] : [];
+        return this._rowNodes?.length > 0 ? [...this._rowNodes] : [];
     }
     getRowDataSelected() {
-        return this.rowNodes.filter(node => node.selected).map(node => ({ ...node.data }));
+        return this._rowNodes.filter(node => node.selected).map(node => ({ ...node.data }));
     }
     getSelectedRowNodes() {
-        const nodes = this.rowNodes.filter(node => node.selected);
+        const nodes = this._rowNodes.filter(node => node.selected);
         return nodes && nodes.length > 0 ? [...nodes] : [];
     }
     /**
@@ -302,6 +502,8 @@ export class OneGridApi {
         return this._activeFilters;
     }
     setFilterModel(model) {
+        if (this._destroyed)
+            return;
         this._activeFilters = model;
         this.applyFilters();
     }
@@ -312,76 +514,69 @@ export class OneGridApi {
      * Quick filter
      */
     setQuickFilter(value) {
+        if (this._destroyed)
+            return;
         this._quickFilterValue = (value || '').toLowerCase();
         this.applyFilters();
     }
     /**
-     * Validation Feature
+     * Run the column validators over one row.
+     *
+     * Rules run in order and stop at the first failure, so a field appears at
+     * most once. Fields that passed are absent rather than mapped to `null`.
+     *
+     * The row type comes from the grid's own `T` — this used to declare its own
+     * `<T>`, which shadowed the class parameter and let an `OneGridApi<Employee>`
+     * happily validate an unrelated shape against employee columns.
      */
     validateRow(row, columns) {
         const errors = {};
-        columns.forEach(col => {
-            // Only check columns with validationRule
-            if (!col.validationRules || col.validationRules.length === 0)
-                return;
-            const rules = col.validationRules;
-            for (const rule of rules) {
-                const error = rule(row[col.field], row);
+        for (const column of columns) {
+            // A column can only contribute an error if it has both rules and a field
+            // to key them under.
+            if (!column.field || !column.validationRules?.length)
+                continue;
+            for (const rule of column.validationRules) {
+                const error = rule(row[column.field], row);
                 if (error) {
-                    errors[col.field] = error;
-                    break; // stop at first error for this column
+                    errors[column.field] = error;
+                    break; // first failure per column wins
                 }
             }
-        });
+        }
         return errors;
     }
     /**
-     * Validate all rows and return both errors and a flag indicating if there are any errors
+     * Run the column validators over a whole dataset.
+     *
+     * Delegates to `validateRow` so the two can never disagree about what counts
+     * as invalid — they previously carried separate copies of the same loop.
      */
     validateAllRows(rowData, columns) {
-        const allErrors = rowData.map(row => {
-            const errors = {};
-            columns.forEach(col => {
-                if (!col.validationRules || col.validationRules.length === 0)
-                    return;
-                for (const rule of col.validationRules) {
-                    const error = rule(row[col.field], row);
-                    if (error) {
-                        errors[col.field] = error;
-                        break;
-                    }
-                }
-            });
-            return errors;
-        });
-        const hasErrors = allErrors.some(err => Object.keys(err).length > 0);
+        const allErrors = rowData.map(row => this.validateRow(row, columns));
+        const hasErrors = allErrors.some(errors => Object.keys(errors).length > 0);
         return { errors: allErrors, valid: !hasErrors, invalid: hasErrors };
     }
-    /** Traverse all nodes */
+    /**
+     * Traverse every node, depth-first, once each.
+     *
+     * `rowNodes` is already the flattened tree — `buildRowNodes` pushes every
+     * node into it as it descends — so walking it is the whole traversal. The
+     * previous implementation walked that flat list *and* recursed into
+     * `children`, visiting every nested node twice and every depth-3 node three
+     * times. `index` is the node's position in the flattened order, matching
+     * `node.rowIndex`, rather than its position among its siblings.
+     */
     forEachNode(callback) {
-        const visit = (nodes) => {
-            nodes.forEach((node, index) => {
-                callback(node, index);
-                if (node?.children?.length)
-                    visit(node.children);
-            });
-        };
-        visit(this.rowNodes);
+        this._rowNodes.forEach((node, index) => callback(node, index));
     }
-    /** Traverse only leaf nodes */
+    /** Traverse only leaf nodes, once each, in flattened order. */
     forEachLeafNode(callback) {
         let leafIndex = 0;
-        const visit = (nodes) => {
-            nodes.forEach(node => {
-                if (node.leaf) {
-                    callback(node, leafIndex++);
-                }
-                else if (node.group && node?.children?.length) {
-                    visit(node.children);
-                }
-            });
-        };
-        visit(this.rowNodes);
+        for (const node of this._rowNodes) {
+            if (node.leaf)
+                callback(node, leafIndex++);
+        }
     }
     getRowNodeById(rowId) {
         return this._originalRowNodes.get(rowId);
@@ -395,8 +590,25 @@ export class OneGridApi {
     setGroupDefaultExpanded(defaultExpanded) {
         this.groupDefaultExpanded = defaultExpanded;
     }
+    /**
+     * Expansion state lives in two places, and they answer different questions.
+     *
+     * `OneGridExpansionService` records only *deliberate* changes — a click, or
+     * one of the methods below. It is an override layer: `buildRowNodes` consults
+     * it first and falls back to `groupDefaultExpanded` for every row the user
+     * has not touched. That is what lets a later `groupDefaultExpanded` change
+     * take effect, and what lets a collapse survive a rebuild.
+     *
+     * `node.expanded` is the resolved truth for a row, defaults included. Public
+     * reads report that; the override sets stay internal.
+     *
+     * The invariant the setters below maintain: `expanded` is only ever true for
+     * a node that can expand.
+     */
     toggleExpandAll(expanded) {
         this.forEachNode(node => {
+            if (!node.expandable)
+                return;
             node.setExpanded(expanded);
             this.expansionService.toggleExpanded(node.rowId, expanded);
         });
@@ -404,7 +616,7 @@ export class OneGridApi {
     }
     setExpandedById(rowId, expanded) {
         const node = this._originalRowNodes.get(rowId);
-        if (node) {
+        if (node?.expandable) {
             node.setExpanded(expanded);
             this.expansionService.toggleExpanded(rowId, expanded);
         }
@@ -414,7 +626,7 @@ export class OneGridApi {
         if (rowIds && rowIds.length > 0) {
             for (let rowId of rowIds) {
                 const node = this._originalRowNodes.get(rowId);
-                if (node) {
+                if (node?.expandable) {
                     node.setExpanded(expanded);
                     this.expansionService.toggleExpanded(rowId, expanded);
                 }
@@ -422,20 +634,32 @@ export class OneGridApi {
             this.refreshVisibleNodes();
         }
     }
+    /**
+     * Every currently expanded row, in tree order.
+     *
+     * Derived from the nodes rather than read off the override record, so rows
+     * opened by `groupDefaultExpanded` are included — previously this returned
+     * only rows someone had explicitly toggled, and came back empty on first load
+     * while the first level was visibly open.
+     */
     getExpandedByIds() {
-        return Array.from(this.expansionService.getExpandedIds());
+        return this._rowNodes
+            .filter(node => node.expandable && node.expanded)
+            .map(node => node.rowId);
     }
     /**
      * Master Detail Feature
      */
     setDetailRowData(node, detailData) {
+        if (this._destroyed)
+            return;
         const rowNode = this.getRowNodeById(node.rowId);
         if (rowNode) {
             rowNode.setDetailRowData(detailData);
         }
     }
     setGetDetailRowData(getDetailRowData) {
-        this.getDetailRowData = getDetailRowData;
+        this._getDetailRowData = getDetailRowData;
     }
     /**
      * Columns State
@@ -444,15 +668,17 @@ export class OneGridApi {
         return this.columnService.getColumnState();
     }
     setColumnDefs(columnDefs) {
+        if (this._destroyed)
+            return;
         this.columnService.setColumnDefs(columnDefs);
         const columnState = this.columnService.getColumnState();
-        this.cellService.applyColumnDefs(columnState.columns, this.context);
+        this.cellService.applyColumnDefs(columnState.columns, this._context);
         this.eventService.dispatchEvent('columnChanged', columnState);
     }
     updateColumn(id, changes) {
         this.columnService.updateColumnDef(id, changes);
         const columnState = this.columnService.getColumnState();
-        this.cellService.applyColumnDefs(columnState.columns, this.context);
+        this.cellService.applyColumnDefs(columnState.columns, this._context);
         this.eventService.dispatchEvent('columnChanged', columnState);
     }
     reorderColumnDefs(fromIndex, toIndex) {
@@ -474,11 +700,12 @@ export class OneGridApi {
         collect(node);
         this.setSelectedByIds(Array.from(rowIds), selected);
     }
+    /**
+     * @deprecated Identical to `updateCellStates`. Kept as an alias so existing
+     * callers keep working; prefer `updateCellStates`, which says what it does.
+     */
     updateNodeStates(node) {
-        const rowNode = this.getRowNodeById(node.rowId);
-        if (rowNode) {
-            rowNode.cellStates = this.cellService.generateCellStates(rowNode);
-        }
+        this.updateCellStates(node);
     }
     updateCellState(node, column) {
         const rowNode = this.getRowNodeById(node.rowId);
@@ -486,34 +713,42 @@ export class OneGridApi {
             rowNode.cellStates[column.field] = this.cellService.generateCellState(rowNode, column);
         }
     }
+    /**
+     * Recompute every cell of one row and repaint it.
+     *
+     * The repaint is the point: this is what a caller reaches for after mutating
+     * a row in place, and it used to regenerate the state and stop there. The
+     * body renders with OnPush, so nothing marked it dirty and the new state sat
+     * unread until some unrelated event happened to trigger change detection —
+     * which is why callers ended up nudging the grid with a synthetic DOM event.
+     */
     updateCellStates(node) {
+        if (this._destroyed)
+            return;
         const rowNode = this.getRowNodeById(node.rowId);
-        if (rowNode) {
-            rowNode.cellStates = this.cellService.generateCellStates(rowNode);
-        }
+        if (!rowNode)
+            return;
+        rowNode.cellStates = this.cellService.generateCellStates(rowNode);
+        this.eventService.dispatchEvent('cellStateChanged', { data: rowNode.data, node: rowNode });
     }
     /**
      * Handler that Reacts to Detail Changes
      */
+    /**
+     * Keep a master row's reserved height in step with its detail rows.
+     *
+     * Two listeners used to be registered here and thrown away: an empty
+     * `rowDataChanged` handler whose unsubscribe was never kept, and an
+     * `expandedChanged` handler whose body was entirely commented out. Both are
+     * gone — a listener with no behaviour is a leak with no upside.
+     */
     subscribeToDetailChanges(node) {
-        const unsubRowData = node.on('rowDataChanged', ({ node, data, previousData }) => {
-        });
-        // When detail data arrives
-        const unsubDetail = node.on('detailRowDataChanged', ({ node, detailRowData, previousDetailRowData }) => {
-            if (this.apiType === 'master') {
-                this._resolvedDetailRowHeight(node);
+        const unsubscribeDetail = node.on('detailRowDataChanged', ({ node }) => {
+            if (this._apiType === 'master') {
+                this.resolveDetailRowHeight(node);
             }
         });
-        // When row expands
-        const unsubExpand = node.on('expandedChanged', ({ node, expanded }) => {
-            // if (!expanded) return;
-            // // Only fetch if detail data not already loaded
-            // if (!node.detailRowData) {
-            //   this.getDetailRowData({ data: node.data, node, successCallback: (detailRowData) => node.setDetailRowData(detailRowData) });
-            // }
-        });
-        // // Cleanup when node is removed from grid
-        this.registerNodeCleanup(node.rowId, [unsubDetail, unsubExpand]);
+        this.registerNodeCleanup(node.rowId, [unsubscribeDetail]);
     }
     registerNodeCleanup(rowId, unsubs) {
         // Merge with any existing cleanups for this rowId
@@ -525,7 +760,14 @@ export class OneGridApi {
         cleanups?.forEach(fn => fn());
         this._nodeCleanupMap.delete(rowId);
     }
-    // Call this when rows are removed
+    /**
+     * Drop nodes that are no longer in the data, releasing what they hold.
+     *
+     * This existed but was never called: `setRowData` and `updateRowData` each
+     * deleted straight out of `_originalRowNodes`, so a removed node kept its
+     * listeners and its entry in `_nodeCleanupMap` for the lifetime of the grid.
+     * Both now come through here, which unsubscribes and clears the node first.
+     */
     pruneRemovedNodes(validRowIds) {
         for (const [rowId, node] of this._originalRowNodes) {
             if (!validRowIds.has(rowId)) {
@@ -536,51 +778,72 @@ export class OneGridApi {
         }
     }
     /**
-     * Resolve Detail Row Height
+     * Height a master row must reserve for its detail grid:
+     * rowHeight x clamp(rows, minRows, maxRows) + headerHeight.
      */
-    _resolvedDetailRowHeight(node) {
-        const minRows = this.detailCellRendererParams.detailGridOptions.detailRowHeightOptions.minRows;
-        const maxRows = this.detailCellRendererParams.detailGridOptions.detailRowHeightOptions.maxRows;
+    resolveDetailRowHeight(node) {
+        const heightOptions = this.detailCellRendererParams?.detailGridOptions?.detailRowHeightOptions;
+        // Reachable whenever masterDetail is on but detailCellRendererParams is
+        // incomplete; without the guard this threw from inside an event listener.
+        if (!heightOptions)
+            return;
+        const minRows = heightOptions.minRows;
+        const maxRows = heightOptions.maxRows;
         const minHeight = (this.rowHeight * minRows) + this.headerRowHeight;
         const maxHeight = (this.rowHeight * maxRows) + this.headerRowHeight;
         const rows = node.detailRowData && node.detailRowData.length ? node.detailRowData.length : 0;
         node.detailRowHeight = rows <= minRows ? minHeight : rows >= maxRows ? maxHeight : (this.rowHeight * rows) + this.headerRowHeight;
     }
     /**
-     * On Destroy
+     * Release everything the grid holds. Called by `OneGridComponent.ngOnDestroy`.
+     *
+     * The services are deliberately *not* nulled out any more. They are injected,
+     * Angular owns their lifetime, and nulling them only guaranteed a
+     * `TypeError` for any callback that arrived after teardown — a detail-row
+     * fetch resolving late, or the body's deferred update. `_destroyed` makes
+     * those calls no-ops instead, which is what a torn-down object should do.
      */
     destroy() {
         if (this._destroyed)
             return;
         this._destroyed = true;
-        this.rowNodes.forEach(node => {
-            node.children = [];
-            node.parent = null;
-        });
-        this.rowNodes = [];
-        this._originalRowNodes.clear();
-        this._currentIndex = null;
-        // Clear services
-        if (this.selectionService) {
-            this.selectionService.deselectAll();
+        // Unsubscribe every per-node listener before dropping the nodes.
+        for (const rowId of Array.from(this._nodeCleanupMap.keys())) {
+            this.cleanupNode(rowId);
         }
-        this.selectionService = null;
-        if (this.expansionService) {
-            this.expansionService.clear();
+        // `destroy` drops the tree links and the listeners; the API no longer has
+        // to reach in and unpick each node itself.
+        this._originalRowNodes.forEach(node => node.destroy());
+        this._rowNodes.forEach(node => node.destroy());
+        for (const side of ['top', 'bottom']) {
+            this._pinnedRowNodes[side].forEach(node => node.destroy());
+            this._pinnedRowNodes[side] = [];
         }
-        this.expansionService = null;
-        this.eventService = null;
-        this.rowService = null;
-        this.cellService = null;
-        // Clear filters, sorting, context
+        this._rowNodes = [];
+        this._visibleRowNodes = [];
+        this._originalRowNodes.clear();
+        this._nodeCleanupMap.clear();
+        this._currentIndex = 0;
+        // Release the back-reference the cell service holds, so a torn-down api is
+        // not kept alive by the service that outlives this call.
+        this.cellService.setGridApi(null);
+        this.selectionService.deselectAll();
+        this.expansionService.clear();
         this._activeFilters = [];
         this._quickFilterValue = null;
-        this.sortModel = [];
-        // Clear master/detail/treeData
+        this._sortModel = [];
+        this._context = null;
         this.masterDetail = false;
         this.treeData = false;
-        this.treeDataChildrenField = '';
+        this.treeDataChildrenField = null;
         this.groupDefaultExpanded = 0;
+        this.detailCellRendererParams = null;
+        this.detailRendererComponent = null;
+        this._getDetailRowData = null;
+    }
+    /** Whether `destroy` has run. Late callbacks check this before doing work. */
+    get destroyed() {
+        return this._destroyed;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridApi, deps: [{ token: i1.OgColumnService }, { token: i2.OneGridRowService }, { token: i3.OneGridCellService }, { token: i4.OneGridEventService }, { token: i5.OneGridSelectionService }, { token: i6.OneGridExpansionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridApi }); }
@@ -588,4 +851,4 @@ export class OneGridApi {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OneGridApi, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.OgColumnService }, { type: i2.OneGridRowService }, { type: i3.OneGridCellService }, { type: i4.OneGridEventService }, { type: i5.OneGridSelectionService }, { type: i6.OneGridExpansionService }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"one-grid-api.class.js","sourceRoot":"","sources":["../../../../../../projects/one-grid/src/lib/core/instants/one-grid-api.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { OneCellRendererComponent } from '../models/one-tree-data.model';\nimport { OneColumnDef } from '../models/one-column-def-types.model';\nimport { OneRowNode } from \"./one-row-node.class\";\nimport { OneGridType, OneSortModel } from '../models/one-grid-types.model';\nimport { OneGridEventService } from '../services/one-grid-event.service';\nimport { OneGridSelectionService } from '../services/one-grid-selection.service';\nimport { OneValidationResult } from '../models/one-validation.model';\nimport { OneFilterModel } from \"../models/one-filter.model\";\nimport { OneGridExpansionService } from '../services/one-grid-expansion.service';\nimport { OneDetailCellRendererParams, OneGetDetailRowDataParams } from \"../models/one-master-detail.model\";\nimport { OneGridRowService } from \"../services/one-grid-row.service\";\nimport { filterTreeNode } from \"../../helpers/one-filter.helper\";\nimport { getFieldValue } from \"../../helpers/one-cell.helper\";\nimport { OneGridCellService } from '../services/one-grid-cell.service';\nimport { v4 as uuidv4 } from 'uuid';\nimport { Injectable, Type } from \"@angular/core\";\nimport { ColumnChangedEvent, RowSelectionMode } from \"../models/one-event-types.model\";\nimport { OneGroupColumnDef } from \"../models/one-column-def-types.model\";\nimport { OgColumnService } from \"../services/og-column.service\";\n\n@Injectable()\nexport class OneGridApi<T = any> {\n\n  // Core Features\n  public id: string;\n  public context: any = null;\n  public rowSelection: RowSelectionMode = null;\n  public apiType: OneGridType = null;\n  public rowNodes: OneRowNode<T>[] = [];\n  public sortModel: OneSortModel<T>[] = [];\n\n\n  private rowHeight: number = 26;\n  private headerRowHeight: number = 32;\n  private _currentIndex: number = 0;\n  private _quickFilterValue: string = null;\n  private _activeFilters: OneFilterModel[] = [];\n\n  private _visibleRowNodes: OneRowNode<T>[] = [];\n  private _originalRowNodes: Map<string, OneRowNode<T>> = new Map();\n  private _nodeCleanupMap = new Map<string, Array<() => void>>(); // Cleanup registry (prevents memory leaks)\n  private _destroyed: boolean = false;\n\n  // Advanced Features\n  private treeData: boolean = false;\n  private treeDataChildrenField: string = null;\n  private groupDefaultExpanded: number = 0;\n\n  private masterDetail: boolean = false;\n  private detailCellRendererParams: OneDetailCellRendererParams;\n  private detailRendererComponent?: Type<OneCellRendererComponent>;\n\n  // Helper Functions\n  public getDetailRowData: (params: OneGetDetailRowDataParams) => void;\n\n  constructor(\n    private columnService: OgColumnService,\n    private rowService: OneGridRowService,\n    private cellService: OneGridCellService,\n    private eventService: OneGridEventService,\n    private selectionService: OneGridSelectionService,\n    private expansionService: OneGridExpansionService\n  ) { }\n\n  init(\n    gridApiType: OneGridType,\n    rowSelection: RowSelectionMode,\n    columnDefs: OneColumnDef<T>[],\n    defaultColumnDef: OneColumnDef<T>,\n    context: any,\n    masterDetail: boolean,\n    detailCellRendererParams: OneDetailCellRendererParams,\n    detailRendererComponent: Type<OneCellRendererComponent>,\n    treeData: boolean,\n    groupColumnDefs: OneGroupColumnDef[]\n  ) {\n\n    this.id = uuidv4();\n    this.apiType = gridApiType;\n    this.rowSelection = rowSelection;\n    this.context = context;\n    this.masterDetail = masterDetail;\n    this.detailCellRendererParams = detailCellRendererParams;\n    this.detailRendererComponent = detailRendererComponent;\n    this.treeData = treeData;\n\n    this.selectionService.setSelectionMode(this.rowSelection);\n    this.rowService.setGetRowIdFn(this.context?.componentParent?.getRowId ?? null);\n\n    this.cellService.applyColumnDefs(columnDefs, context);\n    this.columnService.initColumnDefs(defaultColumnDef, columnDefs, groupColumnDefs);\n\n    const columnState = this.columnService.getColumnState();\n\n    setTimeout(() => this.eventService.dispatchEvent('columnChanged', columnState as ColumnChangedEvent));\n  }\n\n  /**\n   * Create Row Node & Clear All State IDS\n   */\n  public setRowData(rowData: T[]) {\n\n    const validRowIds = new Set<string>();\n\n    // Clear All State IDS\n    this.selectionService.deselectAll();\n    this.expansionService.clear();\n\n    // Build New Row Nodes\n    this.buildRowNodes(rowData, null, 0, validRowIds);\n\n    // Apply Filter\n    this.applyFilters();\n\n    // Remove invalid nodes from map\n    for (const rowId of this._originalRowNodes.keys()) {\n\n      if (!validRowIds.has(rowId)) {\n\n        this._originalRowNodes.delete(rowId);\n      }\n    }\n  }\n\n  /**\n   * Create Row Nodes & Not Clear State IDS\n   */\n  public updateRowData(rowData: T[]) {\n\n    const validRowIds = new Set<string>();\n\n    // Build New Row Nodes\n    this.buildRowNodes(rowData, null, 0, validRowIds);\n\n    // Apply Filter\n    this.applyFilters();\n\n    // Remove invalid nodes from map\n    for (const rowId of this._originalRowNodes.keys()) {\n\n      if (!validRowIds.has(rowId)) {\n\n        this._originalRowNodes.delete(rowId);\n      }\n    }\n  }\n\n  /**\n   * Recursive Build Row Nodes (Optimized)\n   */\n  private buildRowNodes<T>(\n    rowData: T[],\n    parent: OneRowNode<T> | null = null,\n    level: number = 0,\n    validRowIds: Set<string> = new Set(),\n    expandedIds: Set<string> = new Set(this.expansionService.getExpandedIds()),\n    collapsedIds: Set<string> = new Set(this.expansionService.getCollapsedIds()),\n    selectedIds: Set<string> = new Set(this.selectionService.getSelectedIds())\n  ): OneRowNode[] {\n\n    if (parent === null) {\n\n      this.rowNodes = [];\n      this._currentIndex = 0;\n    }\n\n    if (!rowData?.length) return [];\n\n    const nodes: OneRowNode<T>[] = [];\n\n    for (const data of rowData) {\n\n      const rowId = this.rowService.generateRowId(data, this._currentIndex);\n      const children = (data as any)[this.treeDataChildrenField] || null;\n\n      let node: OneRowNode = this._originalRowNodes.get(rowId);\n\n      validRowIds.add(rowId);\n\n      if (node) {\n\n        node.data = data;\n        node.setRowIndex(this._currentIndex);\n\n      } else {\n\n        node = new OneRowNode<T>(rowId, data, this._currentIndex);\n        node.level = level;\n        node.parent = parent;\n        node.detailRendererComponent = this.detailRendererComponent;\n\n        this._originalRowNodes.set(rowId, node);\n\n        if (this.masterDetail) {\n\n          this.subscribeToDetailChanges(node);\n        }\n      }\n\n      const childrenExist = children && children.length >= 0;\n\n      node.group = this.masterDetail ? false : childrenExist;\n      node.leaf = this.masterDetail ? true : !node.group;\n      node.leafGroup = this.masterDetail ? false : (node.group && !childrenExist);\n      node.expandable = this.masterDetail ? true : (node.group && !node.leafGroup);\n\n      const defaultExpanded = node.expandable && (level < this.groupDefaultExpanded || this.groupDefaultExpanded === -1);\n\n      node.setExpanded(expandedIds.has(rowId) ? true : collapsedIds.has(rowId) ? false : defaultExpanded);\n      node.setSelected(selectedIds.has(rowId));\n      node.setCellStates(this.cellService.generateCellStates(node));\n\n      if (this.masterDetail && this.apiType === 'master') {\n\n        this.getDetailRowData({ data, node: node, successCallback: (detailRowData) => node.setDetailRowData(detailRowData) });\n      }\n\n      this._currentIndex++;\n      this.rowNodes.push(node);\n\n      nodes.push(node);\n\n      node.children = this.treeData && childrenExist ? this.buildRowNodes(children || [], node, level + 1, validRowIds, expandedIds, collapsedIds, selectedIds) : [];\n    }\n\n    return nodes;\n  }\n\n  /**\n   * Filter Feature\n   */\n  private applyFilters(): void {\n\n    const filters = this._activeFilters;\n\n    const quick = this._quickFilterValue?.toLowerCase() ?? '';\n\n    this.rowNodes.forEach(node => filterTreeNode(node, filters, quick));\n\n    this.refreshVisibleNodes();\n  }\n\n  /**\n   * Update Row Nodes Display\n   */\n  private refreshVisibleNodes(): void {\n\n    if (this._destroyed) return;\n\n    const visibleNodes: OneRowNode[] = [];\n\n    let rowNumber = 1;\n\n    const visibilityCache = new Map<string, boolean>();\n\n    for (const node of this.rowNodes) {\n\n      const parentVisible = node.parent ? visibilityCache.get(node.parent.rowId) : true;\n\n      const isVisible = node.visible && parentVisible && (!node.parent || node.parent.expanded);\n\n      visibilityCache.set(node.rowId, isVisible);\n\n      if (isVisible) {\n\n        node.cellStates['_oneRowNumber'] = { type: 'text', value: rowNumber++ };\n\n        node.cellStates = { ...node.cellStates };\n\n        visibleNodes.push(node);\n\n      } else {\n\n        node.cellStates['_oneRowNumber'] = { type: 'none', value: null };\n      }\n    }\n\n    this._visibleRowNodes = [...visibleNodes];\n\n    this.eventService.dispatchEvent('rowDataChanged', { nodes: visibleNodes });\n  }\n\n  public getVisibleRowNodes(): OneRowNode<T>[] {\n\n    return this._visibleRowNodes;\n  }\n\n  /**\n   * Sorting Model Feature\n   */\n  public onSortChanged(sortModel: OneSortModel<T>[]) {\n\n    this.sortModel = sortModel;\n\n    this.applySorting();\n\n    this.eventService.dispatchEvent('sortChanged', { nodes: this.rowNodes });\n  }\n\n  private applySorting(): void {\n\n    if (this.sortModel.length === 0) {\n\n      this.rowNodes = [...this._originalRowNodes.values()];\n\n      return;\n    }\n\n    this.rowNodes = [...this._originalRowNodes.values()].sort((a, b) => {\n\n      for (const sortItem of this.sortModel) {\n\n        const { colId, sort } = sortItem;\n        const valA = getFieldValue(a.data, colId as string);\n        const valB = getFieldValue(b.data, colId as string);\n        const comparisonResult = this.compareValues(valA, valB, sort);\n\n        if (comparisonResult !== 0) {\n\n          return comparisonResult;\n        }\n      }\n      return 0;\n    });\n  }\n\n  private compareValues(valA: any, valB: any, sortDirection: 'asc' | 'desc'): number {\n\n    if (valA === null && valB === null) return 0;\n    if (valA === null) return sortDirection === 'asc' ? 1 : -1;\n    if (valB === null) return sortDirection === 'asc' ? -1 : 1;\n\n    if (typeof valA === 'string' && typeof valB === 'string') {\n\n      const comparison = valA.localeCompare(valB, undefined, { numeric: true });\n      return sortDirection === 'asc' ? comparison : -comparison;\n    }\n\n    if (valA < valB) return sortDirection === 'asc' ? -1 : 1;\n    if (valA > valB) return sortDirection === 'asc' ? 1 : -1;\n    return 0;\n  }\n\n  /**\n   * Row Selection Feature (Optimized)\n   */\n  public selectAll(): void {\n\n    const rowIds: string[] = [];\n\n    this._originalRowNodes.forEach(node => {\n\n      node.setSelected(true);\n\n      node.cellStates = { ...node.cellStates };\n\n      rowIds.push(node.rowId);\n    });\n\n    this.selectionService.selectAll(rowIds);\n\n    this.eventService.dispatchEvent('selectionChanged', { allNodesNotSelected: false, allNodesSelected: true, selected: true, node: null });\n  }\n\n  /**\n   * Deselect all nodes (optimized)\n   */\n  public deselectAll(): void {\n\n    this._originalRowNodes.forEach(node => {\n\n      node.setSelected(false);\n\n      node.cellStates = { ...node.cellStates };\n    });\n\n    this.selectionService.deselectAll();\n\n    if (this.selectionService.getSelectionMode() === 'multiple') {\n\n      this.eventService.dispatchEvent('selectionChanged', {\n        allNodesNotSelected: true,\n        allNodesSelected: false,\n        selected: false,\n        node: null\n      });\n    }\n  }\n\n  public toggleSelection(rowId: string, selected: boolean): void {\n\n    const node = this.getRowNodeById(rowId);\n\n    if (node) {\n\n      node.setSelected(selected);\n\n      this.selectionService.toggleSelection(rowId, selected);\n\n      this.eventService.dispatchEvent('selectionChanged', { node, data: node.data, selected });\n    }\n  }\n\n  public setSelectedById(rowId: string) {\n\n    const node = this.getRowNodeById(rowId);\n\n    if (node) {\n\n      if (this.selectionService.getSelectionMode() === 'single') {\n\n        this.rowNodes.forEach(rowNode => rowNode.setSelected(rowNode.rowId === node.rowId));\n\n        this._originalRowNodes.forEach(rowNode => rowNode.setSelected(rowNode.rowId === node.rowId));\n\n      } else {\n\n        node.setSelected(true);\n      }\n\n      this.selectionService.toggleSelection(rowId, true);\n\n      this.eventService.dispatchEvent('selectionChanged', { node, selected: true });\n    }\n  }\n\n  public setSelectedByIds(rowIds: string[], selected: boolean = true) {\n\n    rowIds.forEach(rowId => {\n\n      const node = this._originalRowNodes.get(rowId);\n\n      if (node) {\n\n        node.setSelected(selected);\n\n        node.cellStates = { ...node.cellStates };\n\n        this.selectionService.toggleSelection(rowId, selected);\n      }\n    });\n\n    this.eventService.dispatchEvent('selectionChanged', { node: null });\n  }\n\n  /**\n   * Get & Set Functions\n   */\n  public getAllRowNodes(): OneRowNode<T>[] {\n\n    return this.rowNodes?.length > 0 ? [...this.rowNodes] : [];\n  }\n\n  public getRowDataSelected(): T[] {\n\n    return this.rowNodes.filter(node => node.selected).map(node => ({ ...node.data }));\n  }\n\n  public getSelectedRowNodes(): OneRowNode<T>[] {\n\n    const nodes = this.rowNodes.filter(node => node.selected);\n\n    return nodes && nodes.length > 0 ? [...nodes] : [];\n  }\n\n  /**\n   * Column filters\n   */\n  public getFilterModel(): OneFilterModel[] {\n\n    return this._activeFilters;\n  }\n\n  public setFilterModel(model: OneFilterModel[]): void {\n\n    this._activeFilters = model;\n\n    this.applyFilters();\n  }\n\n  public filterActive(field: string): boolean {\n\n    return this._activeFilters.some(f => f.field === field && f.conditions.length > 0);\n  }\n\n  /**\n   * Quick filter\n   */\n  public setQuickFilter(value: string): void {\n\n    this._quickFilterValue = (value || '').toLowerCase();\n\n    this.applyFilters();\n  }\n\n  /**\n   * Validation Feature\n   */\n  public validateRow<T>(row: T, columns: OneColumnDef<T>[]): Record<string, string> {\n\n    const errors: Record<string, string> = {};\n\n    columns.forEach(col => {\n\n      // Only check columns with validationRule\n      if (!col.validationRules || col.validationRules.length === 0) return;\n\n      const rules = col.validationRules;\n\n      for (const rule of rules) {\n\n        const error = rule(row[col.field], row);\n\n        if (error) {\n\n          errors[col.field as string] = error;\n\n          break; // stop at first error for this column\n        }\n      }\n    });\n\n    return errors;\n  }\n\n  /**\n   * Validate all rows and return both errors and a flag indicating if there are any errors\n   */\n  public validateAllRows<T>(rowData: T[], columns: OneColumnDef<T>[]): OneValidationResult<T> {\n\n    const allErrors = rowData.map(row => {\n\n      const errors: Record<string, string> = {};\n\n      columns.forEach(col => {\n\n        if (!col.validationRules || col.validationRules.length === 0) return;\n\n        for (const rule of col.validationRules) {\n\n          const error = rule(row[col.field], row);\n\n          if (error) {\n\n            errors[col.field as string] = error;\n\n            break;\n          }\n        }\n      });\n\n      return errors;\n    });\n\n    const hasErrors = allErrors.some(err => Object.keys(err).length > 0);\n\n    return { errors: allErrors, valid: !hasErrors, invalid: hasErrors };\n  }\n\n  /** Traverse all nodes */\n  public forEachNode(callback: (node: OneRowNode<T>, index: number) => void) {\n\n    const visit = (nodes: OneRowNode<T>[]) => {\n\n      nodes.forEach((node, index) => {\n\n        callback(node, index);\n\n        if (node?.children?.length) visit(node.children);\n      });\n    };\n\n    visit(this.rowNodes);\n  }\n\n  /** Traverse only leaf nodes */\n  public forEachLeafNode(callback: (node: OneRowNode<T>, index: number) => void) {\n\n    let leafIndex = 0;\n\n    const visit = (nodes: OneRowNode<T>[]) => {\n\n      nodes.forEach(node => {\n\n        if (node.leaf) {\n\n          callback(node, leafIndex++);\n\n        } else if (node.group && node?.children?.length) {\n\n          visit(node.children);\n        }\n      });\n    };\n\n    visit(this.rowNodes);\n  }\n\n  public getRowNodeById(rowId: string): OneRowNode<T> {\n\n    return this._originalRowNodes.get(rowId);\n  }\n\n  /**\n   * Expand/collapse a node\n   */\n  public setTreeDataChildrenField(field: string) {\n\n    this.treeDataChildrenField = field;\n  }\n\n  public setGroupDefaultExpanded(defaultExpanded: number) {\n\n    this.groupDefaultExpanded = defaultExpanded;\n  }\n\n  public toggleExpandAll(expanded: boolean) {\n\n    this.forEachNode(node => {\n\n      node.setExpanded(expanded);\n\n      this.expansionService.toggleExpanded(node.rowId, expanded)\n    });\n\n    this.refreshVisibleNodes();\n  }\n\n  public setExpandedById(rowId: string, expanded: boolean) {\n\n    const node = this._originalRowNodes.get(rowId);\n\n    if (node) {\n\n      node.setExpanded(expanded);\n\n      this.expansionService.toggleExpanded(rowId, expanded);\n    }\n\n    this.refreshVisibleNodes();\n  }\n\n  public setExpandedByIds(rowIds: string[], expanded: boolean) {\n\n    if (rowIds && rowIds.length > 0) {\n\n      for (let rowId of rowIds) {\n\n        const node = this._originalRowNodes.get(rowId);\n\n        if (node) {\n\n          node.setExpanded(expanded);\n\n          this.expansionService.toggleExpanded(rowId, expanded);\n        }\n      }\n\n      this.refreshVisibleNodes();\n    }\n  }\n\n  public getExpandedByIds(): string[] {\n\n    return Array.from(this.expansionService.getExpandedIds());\n  }\n\n  /**\n   * Master Detail Feature\n   */\n  public setDetailRowData(node: OneRowNode<T>, detailData: any[]) {\n\n    const rowNode = this.getRowNodeById(node.rowId);\n\n    if (rowNode) {\n\n      rowNode.setDetailRowData(detailData);\n    }\n  }\n\n  public setGetDetailRowData(getDetailRowData: (params: OneGetDetailRowDataParams) => void) {\n\n    this.getDetailRowData = getDetailRowData;\n  }\n\n  /**\n   * Columns State\n   */\n  public getColumnState(): ColumnChangedEvent {\n\n    return this.columnService.getColumnState();\n  }\n\n  public setColumnDefs(columnDefs: OneColumnDef<T>[]): void {\n\n    this.columnService.setColumnDefs(columnDefs);\n\n    const columnState = this.columnService.getColumnState();\n\n    this.cellService.applyColumnDefs(columnState.columns, this.context);\n\n    this.eventService.dispatchEvent('columnChanged', columnState);\n  }\n\n  public updateColumn(id: string, changes: Partial<OneColumnDef<T>>): void {\n\n    this.columnService.updateColumnDef(id, changes);\n\n    const columnState = this.columnService.getColumnState();\n\n    this.cellService.applyColumnDefs(columnState.columns, this.context);\n\n    this.eventService.dispatchEvent('columnChanged', columnState);\n  }\n\n  public reorderColumnDefs(fromIndex: number, toIndex: number): void {\n\n    this.columnService.reorderColumnDefs(fromIndex, toIndex);\n\n    const columnState = this.columnService.getColumnState();\n\n    this.eventService.dispatchEvent('columnChanged', columnState);\n  }\n\n  /**\n   * Update checkbox selection features\n   */\n  public setNodeAndChildrenSelected(node: OneRowNode, selected: boolean) {\n\n    const rowIds = new Set<string>();\n\n    const collect = (n: OneRowNode) => {\n\n      rowIds.add(n.rowId);\n\n      if (n.children && n.children.length) {\n\n        n.children.forEach(child => collect(child));\n      }\n    };\n\n    collect(node);\n\n    this.setSelectedByIds(Array.from(rowIds), selected);\n  }\n\n  public updateNodeStates(node: OneRowNode) {\n\n    const rowNode = this.getRowNodeById(node.rowId);\n\n    if (rowNode) {\n\n      rowNode.cellStates = this.cellService.generateCellStates(rowNode);\n    }\n  }\n\n  public updateCellState(node: OneRowNode, column: OneColumnDef): void {\n\n    const rowNode = this.getRowNodeById(node.rowId);\n\n    if (rowNode) {\n\n      rowNode.cellStates[column.field] = this.cellService.generateCellState(rowNode, column);\n    }\n  }\n\n  public updateCellStates(node: OneRowNode): void {\n\n    const rowNode = this.getRowNodeById(node.rowId);\n\n    if (rowNode) {\n\n      rowNode.cellStates = this.cellService.generateCellStates(rowNode);\n    }\n  }\n\n  /**\n   * Handler that Reacts to Detail Changes\n   */\n  private subscribeToDetailChanges(node: OneRowNode): void {\n\n    const unsubRowData = node.on('rowDataChanged', ({ node, data, previousData }) => {\n\n\n    });\n\n    // When detail data arrives\n    const unsubDetail = node.on('detailRowDataChanged', ({ node, detailRowData, previousDetailRowData }) => {\n\n      if (this.apiType === 'master') {\n\n        this._resolvedDetailRowHeight(node);\n      }\n    });\n\n    // When row expands\n    const unsubExpand = node.on('expandedChanged', ({ node, expanded }) => {\n\n      // if (!expanded) return;\n\n      // // Only fetch if detail data not already loaded\n      // if (!node.detailRowData) {\n\n      //   this.getDetailRowData({ data: node.data, node, successCallback: (detailRowData) => node.setDetailRowData(detailRowData) });\n      // }\n    });\n\n    // // Cleanup when node is removed from grid\n    this.registerNodeCleanup(node.rowId, [unsubDetail, unsubExpand]);\n  }\n\n  private registerNodeCleanup(rowId: string, unsubs: Array<() => void>): void {\n\n    // Merge with any existing cleanups for this rowId\n    const existing = this._nodeCleanupMap.get(rowId) ?? [];\n\n    this._nodeCleanupMap.set(rowId, [...existing, ...unsubs]);\n  }\n\n  private cleanupNode(rowId: string): void {\n\n    const cleanups = this._nodeCleanupMap.get(rowId);\n\n    cleanups?.forEach(fn => fn());\n\n    this._nodeCleanupMap.delete(rowId);\n  }\n\n  // Call this when rows are removed\n  private pruneRemovedNodes(validRowIds: Set<string>): void {\n\n    for (const [rowId, node] of this._originalRowNodes) {\n\n      if (!validRowIds.has(rowId)) {\n\n        this.cleanupNode(rowId);  // unsubscribe listeners\n\n        node.destroy();           // clear node's own listener map\n\n        this._originalRowNodes.delete(rowId);\n      }\n    }\n  }\n\n  /**\n   * Resolve Detail Row Height\n   */\n  private _resolvedDetailRowHeight(node: OneRowNode): void {\n\n    const minRows = this.detailCellRendererParams.detailGridOptions.detailRowHeightOptions.minRows;\n    const maxRows = this.detailCellRendererParams.detailGridOptions.detailRowHeightOptions.maxRows;\n\n    const minHeight = (this.rowHeight * minRows) + this.headerRowHeight;\n    const maxHeight = (this.rowHeight * maxRows) + this.headerRowHeight;\n\n    const rows = node.detailRowData && node.detailRowData.length ? node.detailRowData.length : 0;\n\n    node.detailRowHeight = rows <= minRows ? minHeight : rows >= maxRows ? maxHeight : (this.rowHeight * rows) + this.headerRowHeight;\n  }\n\n  /**\n   * On Destroy\n   */\n  public destroy(): void {\n\n    if (this._destroyed) return;\n\n    this._destroyed = true;\n\n    this.rowNodes.forEach(node => {\n      node.children = [];\n      node.parent = null;\n    });\n\n    this.rowNodes = [];\n    this._originalRowNodes.clear();\n    this._currentIndex = null;\n\n    // Clear services\n    if (this.selectionService) {\n      this.selectionService.deselectAll();\n    }\n    this.selectionService = null as any;\n\n    if (this.expansionService) {\n      this.expansionService.clear();\n    }\n    this.expansionService = null as any;\n\n    this.eventService = null as any;\n    this.rowService = null as any;\n    this.cellService = null as any;\n\n    // Clear filters, sorting, context\n    this._activeFilters = [];\n    this._quickFilterValue = null;\n    this.sortModel = [];\n\n    // Clear master/detail/treeData\n    this.masterDetail = false;\n    this.treeData = false;\n    this.treeDataChildrenField = '';\n    this.groupDefaultExpanded = 0;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"one-grid-api.class.js","sourceRoot":"","sources":["../../../../../../projects/one-grid/src/lib/core/instants/one-grid-api.class.ts"],"names":[],"mappings":"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","sourcesContent":["import { OneCellRendererComponent } from '../models/one-tree-data.model';\nimport { OneColumnDef } from '../models/one-column-def-types.model';\nimport { OneRowNode } from \"./one-row-node.class\";\nimport { OneGridInitOptions, OneGridType, OneSortModel } from '../models/one-grid-types.model';\nimport { OneGridEventService } from '../services/one-grid-event.service';\nimport { OneGridSelectionService } from '../services/one-grid-selection.service';\nimport { OneRowValidationErrors, OneValidationResult } from '../models/one-validation.model';\nimport { OneFilterModel } from \"../models/one-filter.model\";\nimport { OneGridExpansionService } from '../services/one-grid-expansion.service';\nimport { OneDetailCellRendererParams, OneGetDetailRowDataParams } from \"../models/one-master-detail.model\";\nimport { OneGridRowService } from \"../services/one-grid-row.service\";\nimport { filterTreeNode, isFilterActive } from \"../../helpers/one-filter.helper\";\nimport { OneRowDragSuppressedReason } from \"../models/one-row-drag.model\";\nimport { getFieldValue } from \"../../helpers/one-cell.helper\";\nimport { OneGridCellService } from '../services/one-grid-cell.service';\nimport { v4 as uuidv4 } from 'uuid';\nimport { Injectable, Type } from \"@angular/core\";\nimport { ColumnChangedEvent, OnePinnedRowSide, RowSelectionMode } from \"../models/one-event-types.model\";\nimport { OneGroupColumnDef } from \"../models/one-column-def-types.model\";\nimport { OgColumnService } from \"../services/og-column.service\";\n\n@Injectable()\nexport class OneGridApi<T = any> {\n\n  // ---------------------------------------------------------------------------\n  // Public state\n  //\n  // Exposed as getters, not fields. These were writable, so a consumer could\n  // corrupt the grid by assigning to them — swapping `rowNodes` for an\n  // unrelated array, or setting `sortModel` without the rows ever being\n  // re-sorted. Reads are unchanged; only assignment is now a compile error.\n  //\n  // The array-valued ones are typed `readonly T[]`, which stops `push` and\n  // `splice` at compile time without copying on every read. Use\n  // `getAllRowNodes()` when you want a copy you own.\n  // ---------------------------------------------------------------------------\n  private _id: string;\n  private _context: any = null;\n  private _rowSelection: RowSelectionMode = null;\n  private _apiType: OneGridType = null;\n  private _rowNodes: OneRowNode<T>[] = [];\n  private _sortModel: OneSortModel<T>[] = [];\n\n  /** Unique per grid instance, assigned during `init`. */\n  public get id(): string {\n    return this._id;\n  }\n\n  /** The `[context]` the grid was given. */\n  public get context(): any {\n    return this._context;\n  }\n\n  /** Selection mode, captured during `init`. Changing the input later has no effect. */\n  public get rowSelection(): RowSelectionMode {\n    return this._rowSelection;\n  }\n\n  /** Which role this instance plays: simple, master, detail or tree. */\n  public get apiType(): OneGridType {\n    return this._apiType;\n  }\n\n  /** Every node the grid holds, in flattened order. */\n  public get rowNodes(): readonly OneRowNode<T>[] {\n    return this._rowNodes;\n  }\n\n  /** The sort model currently applied. Change it with `onSortChanged`. */\n  public get sortModel(): readonly OneSortModel<T>[] {\n    return this._sortModel;\n  }\n\n\n  private rowHeight: number = 26;\n  private headerRowHeight: number = 32;\n  private _currentIndex: number = 0;\n  private _quickFilterValue: string = null;\n  private _activeFilters: OneFilterModel[] = [];\n\n  private _visibleRowNodes: OneRowNode<T>[] = [];\n  private readonly _pinnedRowNodes: Record<OnePinnedRowSide, OneRowNode<T>[]> = { top: [], bottom: [] };\n  private _originalRowNodes: Map<string, OneRowNode<T>> = new Map();\n  private _nodeCleanupMap = new Map<string, Array<() => void>>(); // Cleanup registry (prevents memory leaks)\n  private _destroyed: boolean = false;\n\n  // Advanced Features\n  private treeData: boolean = false;\n  private treeDataChildrenField: string = null;\n  private groupDefaultExpanded: number = 0;\n\n  private masterDetail: boolean = false;\n  private detailCellRendererParams: OneDetailCellRendererParams;\n  private detailRendererComponent?: Type<OneCellRendererComponent>;\n\n  /**\n   * Supplies a master row's detail rows. Set through `setGetDetailRowData`;\n   * previously a writable public field with a setter beside it, which left two\n   * ways to do the same thing and one of them unchecked.\n   */\n  private _getDetailRowData: (params: OneGetDetailRowDataParams) => void;\n\n  constructor(\n    private columnService: OgColumnService,\n    private rowService: OneGridRowService,\n    private cellService: OneGridCellService,\n    private eventService: OneGridEventService,\n    private selectionService: OneGridSelectionService,\n    private expansionService: OneGridExpansionService\n  ) { }\n\n  /**\n   * Stand the grid up. Called by `OneGridComponent` from `ngOnInit`.\n   *\n   * Takes a single `OneGridInitOptions` rather than the ten positional\n   * arguments it used to, so a call site reads as the configuration it is and\n   * a new option no longer means editing every caller.\n   *\n   * @internal Applications obtain a ready-made API from `(onGridReady)`; they\n   * should never call this themselves.\n   */\n  init(options: OneGridInitOptions<T>): void {\n\n    const {\n      gridType,\n      columnDefs,\n      defaultColumnDef = {},\n      groupColumnDefs = [],\n      context = null,\n      rowSelection = null,\n      masterDetail = false,\n      detailCellRendererParams = null,\n      detailRendererComponent = null,\n      treeData = false,\n    } = options;\n\n    this._id = uuidv4();\n    this._apiType = gridType;\n    this._rowSelection = rowSelection;\n    this._context = context;\n    this.masterDetail = masterDetail;\n    this.detailCellRendererParams = detailCellRendererParams;\n    this.detailRendererComponent = detailRendererComponent;\n    this.treeData = treeData;\n\n    this.selectionService.setSelectionMode(rowSelection);\n    this.rowService.setGetRowIdFn(context?.componentParent?.getRowId ?? null);\n\n    this.cellService.applyColumnDefs(columnDefs, context);\n    this.cellService.setGridApi(this);\n    this.columnService.initColumnDefs(defaultColumnDef, columnDefs, groupColumnDefs, context);\n\n    const columnState = this.columnService.getColumnState();\n\n    setTimeout(() => this.eventService.dispatchEvent('columnChanged', columnState as ColumnChangedEvent));\n  }\n\n  /**\n   * Replace every row, discarding selection and expansion.\n   *\n   * Use this when the rows represent something new. To swap the data while\n   * keeping what the user has selected and opened, use `updateRowData`.\n   */\n  public setRowData(rowData: T[]) {\n\n    this.rebuildRows(rowData, true);\n  }\n\n  /**\n   * Replace every row, keeping selection and expansion.\n   *\n   * State is keyed by row id, so this only preserves anything if the grid has a\n   * `context.componentParent.getRowId` — otherwise each rebuild mints new ids\n   * and there is nothing left to match against.\n   */\n  public updateRowData(rowData: T[]) {\n\n    this.rebuildRows(rowData, false);\n  }\n\n  /**\n   * The one row-loading path. `setRowData` and `updateRowData` differed only in\n   * whether they cleared the state services first, so everything else — build,\n   * filter, prune — lives here once.\n   */\n  private rebuildRows(rowData: T[], resetState: boolean): void {\n\n    if (this._destroyed) return;\n\n    if (resetState) {\n\n      this.selectionService.deselectAll();\n      this.expansionService.clear();\n    }\n\n    const validRowIds = new Set<string>();\n\n    this.buildRowNodes(rowData, null, 0, validRowIds);\n\n    // Re-apply the active sort. `buildRowNodes` rebuilds the row list in the\n    // order the data arrived, so without this a data update silently returned\n    // the rows to that order while `sortModel` — and therefore the header's\n    // sort arrow — still said they were sorted. Sorting before filtering\n    // because filtering only sets visibility on whatever order this leaves.\n    if (this._sortModel.length > 0) this.applySorting();\n\n    this.applyFilters();\n\n    this.pruneRemovedNodes(validRowIds);\n  }\n\n  /**\n   * Recursive Build Row Nodes (Optimized)\n   */\n  private buildRowNodes(\n    rowData: T[],\n    parent: OneRowNode<T> | null = null,\n    level: number = 0,\n    validRowIds: Set<string> = new Set(),\n    expandedIds: Set<string> = new Set(this.expansionService.getExpandedIds()),\n    collapsedIds: Set<string> = new Set(this.expansionService.getCollapsedIds()),\n    selectedIds: Set<string> = new Set(this.selectionService.getSelectedIds())\n  ): OneRowNode[] {\n\n    if (parent === null) {\n\n      this._rowNodes = [];\n      this._currentIndex = 0;\n    }\n\n    if (!rowData?.length) return [];\n\n    const nodes: OneRowNode<T>[] = [];\n\n    for (const data of rowData) {\n\n      const rowId = this.rowService.generateRowId(data, this._currentIndex);\n      const children = (data as any)[this.treeDataChildrenField] || null;\n\n      let node: OneRowNode = this._originalRowNodes.get(rowId);\n\n      validRowIds.add(rowId);\n\n      if (node) {\n\n        node.data = data;\n        node.setRowIndex(this._currentIndex);\n\n      } else {\n\n        node = new OneRowNode<T>(rowId, data, this._currentIndex);\n        node.level = level;\n        node.parent = parent;\n        node.detailRendererComponent = this.detailRendererComponent;\n\n        this._originalRowNodes.set(rowId, node);\n\n        if (this.masterDetail) {\n\n          this.subscribeToDetailChanges(node);\n        }\n      }\n\n      const childrenExist = children && children.length >= 0;\n\n      // Coerced, because `childrenExist` is `children && children.length >= 0`\n      // — which is `null` for a row with no children field, not `false`. These\n      // are declared `boolean`, and assigning null made every consumer compare\n      // truthiness instead of the value.\n      node.group = this.masterDetail ? false : !!childrenExist;\n      node.leaf = this.masterDetail ? true : !node.group;\n      node.leafGroup = this.masterDetail ? false : (node.group && !childrenExist);\n      node.expandable = this.masterDetail ? true : (node.group && !node.leafGroup);\n\n      const defaultExpanded = node.expandable && (level < this.groupDefaultExpanded || this.groupDefaultExpanded === -1);\n\n      node.setExpanded(expandedIds.has(rowId) ? true : collapsedIds.has(rowId) ? false : defaultExpanded);\n      node.setSelected(selectedIds.has(rowId));\n      node.setCellStates(this.cellService.generateCellStates(node));\n\n      if (this.masterDetail && this._apiType === 'master') {\n\n        this._getDetailRowData({ data, node: node, successCallback: (detailRowData) => node.setDetailRowData(detailRowData) });\n      }\n\n      this._currentIndex++;\n      this._rowNodes.push(node);\n\n      nodes.push(node);\n\n      node.children = this.treeData && childrenExist ? this.buildRowNodes(children || [], node, level + 1, validRowIds, expandedIds, collapsedIds, selectedIds) : [];\n    }\n\n    return nodes;\n  }\n\n  /**\n   * Filter Feature\n   */\n  private applyFilters(): void {\n\n    const filters = this._activeFilters;\n\n    const quick = this._quickFilterValue?.toLowerCase() ?? '';\n\n    // The fields the grid actually shows. Without them the quick filter falls\n    // back to every property on the row, which lets a user match on data that\n    // has no column and never appears on screen.\n    const fields = this.quickFilterFields();\n\n    this._rowNodes.forEach(node => filterTreeNode(node, filters, quick, fields));\n\n    this.refreshVisibleNodes();\n  }\n\n  /**\n   * Which fields the quick filter searches: every column that has one.\n   *\n   * Empty while the columns are still being registered, in which case the\n   * helper falls back to searching the row — the same behaviour as before, and\n   * the only sensible answer when the grid does not yet know its columns.\n   */\n  private quickFilterFields(): string[] {\n\n    return this.columnService\n      .getColumnState()\n      .columns\n      .map(column => column.field as string)\n      .filter((field): field is string => !!field && field !== '_oneRowNumber');\n  }\n\n  /**\n   * Update Row Nodes Display\n   */\n  private refreshVisibleNodes(dispatch: boolean = true): void {\n\n    if (this._destroyed) return;\n\n    const visibleNodes: OneRowNode[] = [];\n\n    let rowNumber = 1;\n\n    const visibilityCache = new Map<string, boolean>();\n\n    for (const node of this._rowNodes) {\n\n      const parentVisible = node.parent ? visibilityCache.get(node.parent.rowId) : true;\n\n      const isVisible = node.visible && parentVisible && (!node.parent || node.parent.expanded);\n\n      visibilityCache.set(node.rowId, isVisible);\n\n      if (isVisible) {\n\n        node.cellStates['_oneRowNumber'] = { type: 'text', value: rowNumber++ };\n\n        node.cellStates = { ...node.cellStates };\n\n        visibleNodes.push(node);\n\n      } else {\n\n        node.cellStates['_oneRowNumber'] = { type: 'none', value: null };\n      }\n    }\n\n    this._visibleRowNodes = [...visibleNodes];\n\n    if (dispatch) this.eventService.dispatchEvent('rowDataChanged', { nodes: visibleNodes });\n  }\n\n  /**\n   * Replace the rows anchored to one edge of the grid.\n   *\n   * Pinned rows are deliberately kept out of `rowNodes` and\n   * `_originalRowNodes`: they are not data. Sorting, filtering, selection,\n   * expansion, pagination and the visible row count all ignore them, which is\n   * the whole point of a summary row. They render with the same column\n   * definitions, so renderers and value getters work as they do everywhere\n   * else.\n   */\n  public setPinnedRowData(side: OnePinnedRowSide, rowData: T[]): void {\n\n    if (this._destroyed) return;\n\n    for (const node of this._pinnedRowNodes[side]) node.destroy();\n\n    this._pinnedRowNodes[side] = (rowData ?? []).map((data, index) => {\n\n      // Ids are namespaced by side and position. They never collide with a data\n      // row's id, and they are stable across rebuilds, which keeps the rendered\n      // `data-cell-id` attributes stable too.\n      const node = new OneRowNode<T>(`one-pinned-${side}-${index}`, data, index);\n\n      node.level = 0;\n      node.leaf = true;\n      node.visible = true;\n      node.setCellStates(this.cellService.generateCellStates(node));\n\n      return node;\n    });\n\n    this.eventService.dispatchEvent('pinnedRowDataChanged', {\n      side,\n      nodes: this._pinnedRowNodes[side],\n    });\n  }\n\n  /** The rows anchored to one edge. Read-only; change them with `setPinnedRowData`. */\n  public getPinnedRowNodes(side: OnePinnedRowSide): readonly OneRowNode<T>[] {\n\n    return this._pinnedRowNodes[side];\n  }\n\n  /**\n   * Row reordering\n   * --------------------------------------------------------------------------\n   *\n   * `_originalRowNodes` is the source of truth for row order: its insertion\n   * order is what `applySorting` falls back to when the sort model empties, and\n   * what a rebuild walks. `_rowNodes` is only the current display order. A move\n   * that touched one and not the other would either be undone by the next sort\n   * change or invisible until one happened, so both are rewritten together.\n   */\n\n  /**\n   * Whether the displayed order is the data order, and so whether a manual move\n   * would survive.\n   *\n   * @returns the reason reordering is unavailable, or `null` when it is fine.\n   */\n  public getRowDragSuppressedReason(): OneRowDragSuppressedReason | null {\n\n    if (this.treeData) return 'treeData';\n\n    if (this._sortModel.length > 0) return 'sorted';\n\n    if (isFilterActive(this._activeFilters, this._quickFilterValue ?? '')) return 'filtered';\n\n    return null;\n  }\n\n  /** Convenience inverse of {@link getRowDragSuppressedReason}. */\n  public canReorderRows(): boolean {\n\n    return this.getRowDragSuppressedReason() === null;\n  }\n\n  /**\n   * Move a row from one position to another.\n   *\n   * Indices are positions in the grid's row order, the same order\n   * `getAllRowNodes()` returns. `targetIndex` is where the row ends up *after*\n   * it has been lifted out of `sourceIndex` — dragging row 0 to the bottom of a\n   * 5-row grid is `moveRow(0, 4)`, not `moveRow(0, 5)`.\n   *\n   * @returns `true` if the rows moved. `false` when the move was rejected —\n   *          out-of-range indices, a no-op, or an order the grid does not own\n   *          (see {@link getRowDragSuppressedReason}) — so a caller can tell a\n   *          refused move from an applied one.\n   */\n  public moveRow(sourceIndex: number, targetIndex: number): boolean {\n\n    if (this._destroyed) return false;\n\n    if (!this.canReorderRows()) return false;\n\n    const order = [...this._originalRowNodes.values()];\n\n    if (!Number.isInteger(sourceIndex) || !Number.isInteger(targetIndex)) return false;\n\n    if (sourceIndex < 0 || sourceIndex >= order.length) return false;\n\n    if (targetIndex < 0 || targetIndex >= order.length) return false;\n\n    if (sourceIndex === targetIndex) return false;\n\n    const [moved] = order.splice(sourceIndex, 1);\n\n    order.splice(targetIndex, 0, moved);\n\n    // Rebuilt rather than mutated: a Map preserves insertion order, and there\n    // is no way to reposition a key within one.\n    this._originalRowNodes = new Map(order.map(node => [node.rowId, node]));\n\n    this._rowNodes = order;\n\n    this.reindexRows();\n\n    this.eventService.dispatchEvent('rowOrderChanged', { nodes: this._visibleRowNodes as OneRowNode<T>[], node: moved, fromIndex: sourceIndex, toIndex: targetIndex });\n\n    return true;\n  }\n\n  /**\n   * Move a row identified by id. Convenient when the caller holds a node rather\n   * than a position — the index it was built with goes stale after any move.\n   */\n  public moveRowById(rowId: string, targetIndex: number): boolean {\n\n    const sourceIndex = [...this._originalRowNodes.values()].findIndex(node => node.rowId === rowId);\n\n    return sourceIndex === -1 ? false : this.moveRow(sourceIndex, targetIndex);\n  }\n\n  /**\n   * Re-stamp `rowIndex` from the current order.\n   *\n   * Row index is denormalised onto every node, and half the grid reads it —\n   * cell params, the range selection, the detail lookup. Leaving it stale after\n   * a move puts every row below the drop point one out.\n   */\n  private reindexRows(): void {\n\n    this._rowNodes.forEach((node, index) => node.setRowIndex(index));\n\n    // Silent: row numbers and the visible list have to be rebuilt, but the\n    // `rowDataChanged` that normally follows defers a frame and re-seeds detail\n    // rows. A keyboard drag fires one of these per arrow key, and `moveRow`\n    // announces itself through `rowOrderChanged` instead.\n    this.refreshVisibleNodes(false);\n  }\n\n  public getVisibleRowNodes(): OneRowNode<T>[] {\n\n    return this._visibleRowNodes;\n  }\n\n  /**\n   * Sorting Model Feature\n   */\n  public onSortChanged(sortModel: OneSortModel<T>[]) {\n\n    if (this._destroyed) return;\n\n    this._sortModel = sortModel;\n\n    this.applySorting();\n\n    this.eventService.dispatchEvent('sortChanged', { nodes: this._rowNodes });\n  }\n\n  private applySorting(): void {\n\n    if (this._sortModel.length === 0) {\n\n      this._rowNodes = [...this._originalRowNodes.values()];\n\n      return;\n    }\n\n    this._rowNodes = [...this._originalRowNodes.values()].sort((a, b) => {\n\n      for (const sortItem of this._sortModel) {\n\n        const { colId, sort } = sortItem;\n        const valA = getFieldValue(a.data, colId as string);\n        const valB = getFieldValue(b.data, colId as string);\n        const comparisonResult = this.compareValues(valA, valB, sort);\n\n        if (comparisonResult !== 0) {\n\n          return comparisonResult;\n        }\n      }\n      return 0;\n    });\n  }\n\n  private compareValues(valA: any, valB: any, sortDirection: 'asc' | 'desc'): number {\n\n    // `undefined` has to be treated as empty alongside `null`: getFieldValue\n    // returns undefined for a missing field or an unresolved dotted path, and\n    // comparing undefined with < / > yields false both ways, which made such\n    // rows settle in whatever order the sort happened to encounter them.\n    const aEmpty = valA === null || valA === undefined;\n    const bEmpty = valB === null || valB === undefined;\n\n    if (aEmpty && bEmpty) return 0;\n    if (aEmpty) return sortDirection === 'asc' ? 1 : -1;\n    if (bEmpty) return sortDirection === 'asc' ? -1 : 1;\n\n    if (typeof valA === 'string' && typeof valB === 'string') {\n\n      const comparison = valA.localeCompare(valB, undefined, { numeric: true });\n      return sortDirection === 'asc' ? comparison : -comparison;\n    }\n\n    if (valA < valB) return sortDirection === 'asc' ? -1 : 1;\n    if (valA > valB) return sortDirection === 'asc' ? 1 : -1;\n    return 0;\n  }\n\n  /**\n   * Row Selection Feature (Optimized)\n   */\n  public selectAll(): void {\n\n    const rowIds: string[] = [];\n\n    this._originalRowNodes.forEach(node => {\n\n      node.setSelected(true);\n\n      node.cellStates = { ...node.cellStates };\n\n      rowIds.push(node.rowId);\n    });\n\n    this.selectionService.selectAll(rowIds);\n\n    this.eventService.dispatchEvent('selectionChanged', { allNodesNotSelected: false, allNodesSelected: true, selected: true, node: null });\n  }\n\n  /**\n   * Deselect all nodes (optimized)\n   */\n  public deselectAll(): void {\n\n    this._originalRowNodes.forEach(node => {\n\n      node.setSelected(false);\n\n      node.cellStates = { ...node.cellStates };\n    });\n\n    this.selectionService.deselectAll();\n\n    if (this.selectionService.getSelectionMode() === 'multiple') {\n\n      this.eventService.dispatchEvent('selectionChanged', {\n        allNodesNotSelected: true,\n        allNodesSelected: false,\n        selected: false,\n        node: null\n      });\n    }\n  }\n\n  public toggleSelection(rowId: string, selected: boolean): void {\n\n    const node = this.getRowNodeById(rowId);\n\n    if (node) {\n\n      node.setSelected(selected);\n\n      this.selectionService.toggleSelection(rowId, selected);\n\n      this.eventService.dispatchEvent('selectionChanged', { node, data: node.data, selected });\n    }\n  }\n\n  public setSelectedById(rowId: string) {\n\n    const node = this.getRowNodeById(rowId);\n\n    if (node) {\n\n      if (this.selectionService.getSelectionMode() === 'single') {\n\n        this._rowNodes.forEach(rowNode => rowNode.setSelected(rowNode.rowId === node.rowId));\n\n        this._originalRowNodes.forEach(rowNode => rowNode.setSelected(rowNode.rowId === node.rowId));\n\n      } else {\n\n        node.setSelected(true);\n      }\n\n      this.selectionService.toggleSelection(rowId, true);\n\n      this.eventService.dispatchEvent('selectionChanged', { node, selected: true });\n    }\n  }\n\n  public setSelectedByIds(rowIds: string[], selected: boolean = true) {\n\n    rowIds.forEach(rowId => {\n\n      const node = this._originalRowNodes.get(rowId);\n\n      if (node) {\n\n        node.setSelected(selected);\n\n        node.cellStates = { ...node.cellStates };\n\n        this.selectionService.toggleSelection(rowId, selected);\n      }\n    });\n\n    this.eventService.dispatchEvent('selectionChanged', { node: null });\n  }\n\n  /**\n   * Get & Set Functions\n   */\n  public getAllRowNodes(): OneRowNode<T>[] {\n\n    return this._rowNodes?.length > 0 ? [...this._rowNodes] : [];\n  }\n\n  public getRowDataSelected(): T[] {\n\n    return this._rowNodes.filter(node => node.selected).map(node => ({ ...node.data }));\n  }\n\n  public getSelectedRowNodes(): OneRowNode<T>[] {\n\n    const nodes = this._rowNodes.filter(node => node.selected);\n\n    return nodes && nodes.length > 0 ? [...nodes] : [];\n  }\n\n  /**\n   * Column filters\n   */\n  public getFilterModel(): OneFilterModel[] {\n\n    return this._activeFilters;\n  }\n\n  public setFilterModel(model: OneFilterModel[]): void {\n\n    if (this._destroyed) return;\n\n    this._activeFilters = model;\n\n    this.applyFilters();\n  }\n\n  public filterActive(field: string): boolean {\n\n    return this._activeFilters.some(f => f.field === field && f.conditions.length > 0);\n  }\n\n  /**\n   * Quick filter\n   */\n  public setQuickFilter(value: string): void {\n\n    if (this._destroyed) return;\n\n    this._quickFilterValue = (value || '').toLowerCase();\n\n    this.applyFilters();\n  }\n\n  /**\n   * Run the column validators over one row.\n   *\n   * Rules run in order and stop at the first failure, so a field appears at\n   * most once. Fields that passed are absent rather than mapped to `null`.\n   *\n   * The row type comes from the grid's own `T` — this used to declare its own\n   * `<T>`, which shadowed the class parameter and let an `OneGridApi<Employee>`\n   * happily validate an unrelated shape against employee columns.\n   */\n  public validateRow(row: T, columns: OneColumnDef<T>[]): OneRowValidationErrors<T> {\n\n    const errors: OneRowValidationErrors<T> = {};\n\n    for (const column of columns) {\n\n      // A column can only contribute an error if it has both rules and a field\n      // to key them under.\n      if (!column.field || !column.validationRules?.length) continue;\n\n      for (const rule of column.validationRules) {\n\n        const error = rule(row[column.field], row);\n\n        if (error) {\n\n          errors[column.field] = error;\n\n          break; // first failure per column wins\n        }\n      }\n    }\n\n    return errors;\n  }\n\n  /**\n   * Run the column validators over a whole dataset.\n   *\n   * Delegates to `validateRow` so the two can never disagree about what counts\n   * as invalid — they previously carried separate copies of the same loop.\n   */\n  public validateAllRows(rowData: T[], columns: OneColumnDef<T>[]): OneValidationResult<T> {\n\n    const allErrors = rowData.map(row => this.validateRow(row, columns));\n\n    const hasErrors = allErrors.some(errors => Object.keys(errors).length > 0);\n\n    return { errors: allErrors, valid: !hasErrors, invalid: hasErrors };\n  }\n\n  /**\n   * Traverse every node, depth-first, once each.\n   *\n   * `rowNodes` is already the flattened tree — `buildRowNodes` pushes every\n   * node into it as it descends — so walking it is the whole traversal. The\n   * previous implementation walked that flat list *and* recursed into\n   * `children`, visiting every nested node twice and every depth-3 node three\n   * times. `index` is the node's position in the flattened order, matching\n   * `node.rowIndex`, rather than its position among its siblings.\n   */\n  public forEachNode(callback: (node: OneRowNode<T>, index: number) => void) {\n\n    this._rowNodes.forEach((node, index) => callback(node, index));\n  }\n\n  /** Traverse only leaf nodes, once each, in flattened order. */\n  public forEachLeafNode(callback: (node: OneRowNode<T>, index: number) => void) {\n\n    let leafIndex = 0;\n\n    for (const node of this._rowNodes) {\n\n      if (node.leaf) callback(node, leafIndex++);\n    }\n  }\n\n  public getRowNodeById(rowId: string): OneRowNode<T> {\n\n    return this._originalRowNodes.get(rowId);\n  }\n\n  /**\n   * Expand/collapse a node\n   */\n  public setTreeDataChildrenField(field: string) {\n\n    this.treeDataChildrenField = field;\n  }\n\n  public setGroupDefaultExpanded(defaultExpanded: number) {\n\n    this.groupDefaultExpanded = defaultExpanded;\n  }\n\n  /**\n   * Expansion state lives in two places, and they answer different questions.\n   *\n   * `OneGridExpansionService` records only *deliberate* changes — a click, or\n   * one of the methods below. It is an override layer: `buildRowNodes` consults\n   * it first and falls back to `groupDefaultExpanded` for every row the user\n   * has not touched. That is what lets a later `groupDefaultExpanded` change\n   * take effect, and what lets a collapse survive a rebuild.\n   *\n   * `node.expanded` is the resolved truth for a row, defaults included. Public\n   * reads report that; the override sets stay internal.\n   *\n   * The invariant the setters below maintain: `expanded` is only ever true for\n   * a node that can expand.\n   */\n  public toggleExpandAll(expanded: boolean) {\n\n    this.forEachNode(node => {\n\n      if (!node.expandable) return;\n\n      node.setExpanded(expanded);\n\n      this.expansionService.toggleExpanded(node.rowId, expanded)\n    });\n\n    this.refreshVisibleNodes();\n  }\n\n  public setExpandedById(rowId: string, expanded: boolean) {\n\n    const node = this._originalRowNodes.get(rowId);\n\n    if (node?.expandable) {\n\n      node.setExpanded(expanded);\n\n      this.expansionService.toggleExpanded(rowId, expanded);\n    }\n\n    this.refreshVisibleNodes();\n  }\n\n  public setExpandedByIds(rowIds: string[], expanded: boolean) {\n\n    if (rowIds && rowIds.length > 0) {\n\n      for (let rowId of rowIds) {\n\n        const node = this._originalRowNodes.get(rowId);\n\n        if (node?.expandable) {\n\n          node.setExpanded(expanded);\n\n          this.expansionService.toggleExpanded(rowId, expanded);\n        }\n      }\n\n      this.refreshVisibleNodes();\n    }\n  }\n\n  /**\n   * Every currently expanded row, in tree order.\n   *\n   * Derived from the nodes rather than read off the override record, so rows\n   * opened by `groupDefaultExpanded` are included — previously this returned\n   * only rows someone had explicitly toggled, and came back empty on first load\n   * while the first level was visibly open.\n   */\n  public getExpandedByIds(): string[] {\n\n    return this._rowNodes\n\n      .filter(node => node.expandable && node.expanded)\n\n      .map(node => node.rowId);\n  }\n\n  /**\n   * Master Detail Feature\n   */\n  public setDetailRowData(node: OneRowNode<T>, detailData: any[]) {\n\n    if (this._destroyed) return;\n\n    const rowNode = this.getRowNodeById(node.rowId);\n\n    if (rowNode) {\n\n      rowNode.setDetailRowData(detailData);\n    }\n  }\n\n  public setGetDetailRowData(getDetailRowData: (params: OneGetDetailRowDataParams) => void) {\n\n    this._getDetailRowData = getDetailRowData;\n  }\n\n  /**\n   * Columns State\n   */\n  public getColumnState(): ColumnChangedEvent {\n\n    return this.columnService.getColumnState();\n  }\n\n  public setColumnDefs(columnDefs: OneColumnDef<T>[]): void {\n\n    if (this._destroyed) return;\n\n    this.columnService.setColumnDefs(columnDefs);\n\n    const columnState = this.columnService.getColumnState();\n\n    this.cellService.applyColumnDefs(columnState.columns, this._context);\n\n    this.eventService.dispatchEvent('columnChanged', columnState);\n  }\n\n  public updateColumn(id: string, changes: Partial<OneColumnDef<T>>): void {\n\n    this.columnService.updateColumnDef(id, changes);\n\n    const columnState = this.columnService.getColumnState();\n\n    this.cellService.applyColumnDefs(columnState.columns, this._context);\n\n    this.eventService.dispatchEvent('columnChanged', columnState);\n  }\n\n  public reorderColumnDefs(fromIndex: number, toIndex: number): void {\n\n    this.columnService.reorderColumnDefs(fromIndex, toIndex);\n\n    const columnState = this.columnService.getColumnState();\n\n    this.eventService.dispatchEvent('columnChanged', columnState);\n  }\n\n  /**\n   * Update checkbox selection features\n   */\n  public setNodeAndChildrenSelected(node: OneRowNode, selected: boolean) {\n\n    const rowIds = new Set<string>();\n\n    const collect = (n: OneRowNode) => {\n\n      rowIds.add(n.rowId);\n\n      if (n.children && n.children.length) {\n\n        n.children.forEach(child => collect(child));\n      }\n    };\n\n    collect(node);\n\n    this.setSelectedByIds(Array.from(rowIds), selected);\n  }\n\n  /**\n   * @deprecated Identical to `updateCellStates`. Kept as an alias so existing\n   * callers keep working; prefer `updateCellStates`, which says what it does.\n   */\n  public updateNodeStates(node: OneRowNode) {\n\n    this.updateCellStates(node);\n  }\n\n  public updateCellState(node: OneRowNode, column: OneColumnDef): void {\n\n    const rowNode = this.getRowNodeById(node.rowId);\n\n    if (rowNode) {\n\n      rowNode.cellStates[column.field] = this.cellService.generateCellState(rowNode, column);\n    }\n  }\n\n  /**\n   * Recompute every cell of one row and repaint it.\n   *\n   * The repaint is the point: this is what a caller reaches for after mutating\n   * a row in place, and it used to regenerate the state and stop there. The\n   * body renders with OnPush, so nothing marked it dirty and the new state sat\n   * unread until some unrelated event happened to trigger change detection —\n   * which is why callers ended up nudging the grid with a synthetic DOM event.\n   */\n  public updateCellStates(node: OneRowNode): void {\n\n    if (this._destroyed) return;\n\n    const rowNode = this.getRowNodeById(node.rowId);\n\n    if (!rowNode) return;\n\n    rowNode.cellStates = this.cellService.generateCellStates(rowNode);\n\n    this.eventService.dispatchEvent('cellStateChanged', { data: rowNode.data, node: rowNode });\n  }\n\n  /**\n   * Handler that Reacts to Detail Changes\n   */\n  /**\n   * Keep a master row's reserved height in step with its detail rows.\n   *\n   * Two listeners used to be registered here and thrown away: an empty\n   * `rowDataChanged` handler whose unsubscribe was never kept, and an\n   * `expandedChanged` handler whose body was entirely commented out. Both are\n   * gone — a listener with no behaviour is a leak with no upside.\n   */\n  private subscribeToDetailChanges(node: OneRowNode): void {\n\n    const unsubscribeDetail = node.on('detailRowDataChanged', ({ node }) => {\n\n      if (this._apiType === 'master') {\n\n        this.resolveDetailRowHeight(node);\n      }\n    });\n\n    this.registerNodeCleanup(node.rowId, [unsubscribeDetail]);\n  }\n\n  private registerNodeCleanup(rowId: string, unsubs: Array<() => void>): void {\n\n    // Merge with any existing cleanups for this rowId\n    const existing = this._nodeCleanupMap.get(rowId) ?? [];\n\n    this._nodeCleanupMap.set(rowId, [...existing, ...unsubs]);\n  }\n\n  private cleanupNode(rowId: string): void {\n\n    const cleanups = this._nodeCleanupMap.get(rowId);\n\n    cleanups?.forEach(fn => fn());\n\n    this._nodeCleanupMap.delete(rowId);\n  }\n\n  /**\n   * Drop nodes that are no longer in the data, releasing what they hold.\n   *\n   * This existed but was never called: `setRowData` and `updateRowData` each\n   * deleted straight out of `_originalRowNodes`, so a removed node kept its\n   * listeners and its entry in `_nodeCleanupMap` for the lifetime of the grid.\n   * Both now come through here, which unsubscribes and clears the node first.\n   */\n  private pruneRemovedNodes(validRowIds: Set<string>): void {\n\n    for (const [rowId, node] of this._originalRowNodes) {\n\n      if (!validRowIds.has(rowId)) {\n\n        this.cleanupNode(rowId);  // unsubscribe listeners\n\n        node.destroy();           // clear node's own listener map\n\n        this._originalRowNodes.delete(rowId);\n      }\n    }\n  }\n\n  /**\n   * Height a master row must reserve for its detail grid:\n   * rowHeight x clamp(rows, minRows, maxRows) + headerHeight.\n   */\n  private resolveDetailRowHeight(node: OneRowNode): void {\n\n    const heightOptions = this.detailCellRendererParams?.detailGridOptions?.detailRowHeightOptions;\n\n    // Reachable whenever masterDetail is on but detailCellRendererParams is\n    // incomplete; without the guard this threw from inside an event listener.\n    if (!heightOptions) return;\n\n    const minRows = heightOptions.minRows;\n    const maxRows = heightOptions.maxRows;\n\n    const minHeight = (this.rowHeight * minRows) + this.headerRowHeight;\n    const maxHeight = (this.rowHeight * maxRows) + this.headerRowHeight;\n\n    const rows = node.detailRowData && node.detailRowData.length ? node.detailRowData.length : 0;\n\n    node.detailRowHeight = rows <= minRows ? minHeight : rows >= maxRows ? maxHeight : (this.rowHeight * rows) + this.headerRowHeight;\n  }\n\n  /**\n   * Release everything the grid holds. Called by `OneGridComponent.ngOnDestroy`.\n   *\n   * The services are deliberately *not* nulled out any more. They are injected,\n   * Angular owns their lifetime, and nulling them only guaranteed a\n   * `TypeError` for any callback that arrived after teardown — a detail-row\n   * fetch resolving late, or the body's deferred update. `_destroyed` makes\n   * those calls no-ops instead, which is what a torn-down object should do.\n   */\n  public destroy(): void {\n\n    if (this._destroyed) return;\n\n    this._destroyed = true;\n\n    // Unsubscribe every per-node listener before dropping the nodes.\n    for (const rowId of Array.from(this._nodeCleanupMap.keys())) {\n\n      this.cleanupNode(rowId);\n    }\n\n    // `destroy` drops the tree links and the listeners; the API no longer has\n    // to reach in and unpick each node itself.\n    this._originalRowNodes.forEach(node => node.destroy());\n    this._rowNodes.forEach(node => node.destroy());\n\n    for (const side of ['top', 'bottom'] as OnePinnedRowSide[]) {\n\n      this._pinnedRowNodes[side].forEach(node => node.destroy());\n      this._pinnedRowNodes[side] = [];\n    }\n\n    this._rowNodes = [];\n    this._visibleRowNodes = [];\n    this._originalRowNodes.clear();\n    this._nodeCleanupMap.clear();\n    this._currentIndex = 0;\n\n    // Release the back-reference the cell service holds, so a torn-down api is\n    // not kept alive by the service that outlives this call.\n    this.cellService.setGridApi(null);\n\n    this.selectionService.deselectAll();\n    this.expansionService.clear();\n\n    this._activeFilters = [];\n    this._quickFilterValue = null;\n    this._sortModel = [];\n    this._context = null;\n\n    this.masterDetail = false;\n    this.treeData = false;\n    this.treeDataChildrenField = null;\n    this.groupDefaultExpanded = 0;\n    this.detailCellRendererParams = null;\n    this.detailRendererComponent = null;\n    this._getDetailRowData = null;\n  }\n\n  /** Whether `destroy` has run. Late callbacks check this before doing work. */\n  public get destroyed(): boolean {\n\n    return this._destroyed;\n  }\n}\n"]}