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

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

@@ -0,0 +1,591 @@
+import { OneRowNode } from "./one-row-node.class";
+import { filterTreeNode } from "../../helpers/one-filter.helper";
+import { getFieldValue } from "../../helpers/one-cell.helper";
+import { v4 as uuidv4 } from 'uuid';
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "../services/og-column.service";
+import * as i2 from "../services/one-grid-row.service";
+import * as i3 from "../services/one-grid-cell.service";
+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 {
+    constructor(columnService, rowService, cellService, eventService, selectionService, expansionService) {
+        this.columnService = columnService;
+        this.rowService = rowService;
+        this.cellService = cellService;
+        this.eventService = eventService;
+        this.selectionService = selectionService;
+        this.expansionService = expansionService;
+        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._originalRowNodes = new Map();
+        this._nodeCleanupMap = new Map(); // Cleanup registry (prevents memory leaks)
+        this._destroyed = false;
+        // Advanced Features
+        this.treeData = false;
+        this.treeDataChildrenField = null;
+        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;
+        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.cellService.applyColumnDefs(columnDefs, context);
+        this.columnService.initColumnDefs(defaultColumnDef, columnDefs, groupColumnDefs);
+        const columnState = this.columnService.getColumnState();
+        setTimeout(() => this.eventService.dispatchEvent('columnChanged', columnState));
+    }
+    /**
+     * Create Row Node & Clear All State IDS
+     */
+    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);
+            }
+        }
+    }
+    /**
+     * Create Row Nodes & Not Clear State IDS
+     */
+    updateRowData(rowData) {
+        const validRowIds = new Set();
+        // 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);
+            }
+        }
+    }
+    /**
+     * 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._currentIndex = 0;
+        }
+        if (!rowData?.length)
+            return [];
+        const nodes = [];
+        for (const data of rowData) {
+            const rowId = this.rowService.generateRowId(data, this._currentIndex);
+            const children = data[this.treeDataChildrenField] || null;
+            let node = this._originalRowNodes.get(rowId);
+            validRowIds.add(rowId);
+            if (node) {
+                node.data = data;
+                node.setRowIndex(this._currentIndex);
+            }
+            else {
+                node = new OneRowNode(rowId, data, this._currentIndex);
+                node.level = level;
+                node.parent = parent;
+                node.detailRendererComponent = this.detailRendererComponent;
+                this._originalRowNodes.set(rowId, node);
+                if (this.masterDetail) {
+                    this.subscribeToDetailChanges(node);
+                }
+            }
+            const childrenExist = children && children.length >= 0;
+            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);
+            const defaultExpanded = node.expandable && (level < this.groupDefaultExpanded || this.groupDefaultExpanded === -1);
+            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) });
+            }
+            this._currentIndex++;
+            this.rowNodes.push(node);
+            nodes.push(node);
+            node.children = this.treeData && childrenExist ? this.buildRowNodes(children || [], node, level + 1, validRowIds, expandedIds, collapsedIds, selectedIds) : [];
+        }
+        return nodes;
+    }
+    /**
+     * Filter Feature
+     */
+    applyFilters() {
+        const filters = this._activeFilters;
+        const quick = this._quickFilterValue?.toLowerCase() ?? '';
+        this.rowNodes.forEach(node => filterTreeNode(node, filters, quick));
+        this.refreshVisibleNodes();
+    }
+    /**
+     * Update Row Nodes Display
+     */
+    refreshVisibleNodes() {
+        if (this._destroyed)
+            return;
+        const visibleNodes = [];
+        let rowNumber = 1;
+        const visibilityCache = new Map();
+        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);
+            if (isVisible) {
+                node.cellStates['_oneRowNumber'] = { type: 'text', value: rowNumber++ };
+                node.cellStates = { ...node.cellStates };
+                visibleNodes.push(node);
+            }
+            else {
+                node.cellStates['_oneRowNumber'] = { type: 'none', value: null };
+            }
+        }
+        this._visibleRowNodes = [...visibleNodes];
+        this.eventService.dispatchEvent('rowDataChanged', { nodes: visibleNodes });
+    }
+    getVisibleRowNodes() {
+        return this._visibleRowNodes;
+    }
+    /**
+     * Sorting Model Feature
+     */
+    onSortChanged(sortModel) {
+        this.sortModel = sortModel;
+        this.applySorting();
+        this.eventService.dispatchEvent('sortChanged', { nodes: this.rowNodes });
+    }
+    applySorting() {
+        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) {
+                const { colId, sort } = sortItem;
+                const valA = getFieldValue(a.data, colId);
+                const valB = getFieldValue(b.data, colId);
+                const comparisonResult = this.compareValues(valA, valB, sort);
+                if (comparisonResult !== 0) {
+                    return comparisonResult;
+                }
+            }
+            return 0;
+        });
+    }
+    compareValues(valA, valB, sortDirection) {
+        if (valA === null && valB === null)
+            return 0;
+        if (valA === null)
+            return sortDirection === 'asc' ? 1 : -1;
+        if (valB === null)
+            return sortDirection === 'asc' ? -1 : 1;
+        if (typeof valA === 'string' && typeof valB === 'string') {
+            const comparison = valA.localeCompare(valB, undefined, { numeric: true });
+            return sortDirection === 'asc' ? comparison : -comparison;
+        }
+        if (valA < valB)
+            return sortDirection === 'asc' ? -1 : 1;
+        if (valA > valB)
+            return sortDirection === 'asc' ? 1 : -1;
+        return 0;
+    }
+    /**
+     * Row Selection Feature (Optimized)
+     */
+    selectAll() {
+        const rowIds = [];
+        this._originalRowNodes.forEach(node => {
+            node.setSelected(true);
+            node.cellStates = { ...node.cellStates };
+            rowIds.push(node.rowId);
+        });
+        this.selectionService.selectAll(rowIds);
+        this.eventService.dispatchEvent('selectionChanged', { allNodesNotSelected: false, allNodesSelected: true, selected: true, node: null });
+    }
+    /**
+     * Deselect all nodes (optimized)
+     */
+    deselectAll() {
+        this._originalRowNodes.forEach(node => {
+            node.setSelected(false);
+            node.cellStates = { ...node.cellStates };
+        });
+        this.selectionService.deselectAll();
+        if (this.selectionService.getSelectionMode() === 'multiple') {
+            this.eventService.dispatchEvent('selectionChanged', {
+                allNodesNotSelected: true,
+                allNodesSelected: false,
+                selected: false,
+                node: null
+            });
+        }
+    }
+    toggleSelection(rowId, selected) {
+        const node = this.getRowNodeById(rowId);
+        if (node) {
+            node.setSelected(selected);
+            this.selectionService.toggleSelection(rowId, selected);
+            this.eventService.dispatchEvent('selectionChanged', { node, data: node.data, selected });
+        }
+    }
+    setSelectedById(rowId) {
+        const node = this.getRowNodeById(rowId);
+        if (node) {
+            if (this.selectionService.getSelectionMode() === 'single') {
+                this.rowNodes.forEach(rowNode => rowNode.setSelected(rowNode.rowId === node.rowId));
+                this._originalRowNodes.forEach(rowNode => rowNode.setSelected(rowNode.rowId === node.rowId));
+            }
+            else {
+                node.setSelected(true);
+            }
+            this.selectionService.toggleSelection(rowId, true);
+            this.eventService.dispatchEvent('selectionChanged', { node, selected: true });
+        }
+    }
+    setSelectedByIds(rowIds, selected = true) {
+        rowIds.forEach(rowId => {
+            const node = this._originalRowNodes.get(rowId);
+            if (node) {
+                node.setSelected(selected);
+                node.cellStates = { ...node.cellStates };
+                this.selectionService.toggleSelection(rowId, selected);
+            }
+        });
+        this.eventService.dispatchEvent('selectionChanged', { node: null });
+    }
+    /**
+     * Get & Set Functions
+     */
+    getAllRowNodes() {
+        return this.rowNodes?.length > 0 ? [...this.rowNodes] : [];
+    }
+    getRowDataSelected() {
+        return this.rowNodes.filter(node => node.selected).map(node => ({ ...node.data }));
+    }
+    getSelectedRowNodes() {
+        const nodes = this.rowNodes.filter(node => node.selected);
+        return nodes && nodes.length > 0 ? [...nodes] : [];
+    }
+    /**
+     * Column filters
+     */
+    getFilterModel() {
+        return this._activeFilters;
+    }
+    setFilterModel(model) {
+        this._activeFilters = model;
+        this.applyFilters();
+    }
+    filterActive(field) {
+        return this._activeFilters.some(f => f.field === field && f.conditions.length > 0);
+    }
+    /**
+     * Quick filter
+     */
+    setQuickFilter(value) {
+        this._quickFilterValue = (value || '').toLowerCase();
+        this.applyFilters();
+    }
+    /**
+     * Validation Feature
+     */
+    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);
+                if (error) {
+                    errors[col.field] = error;
+                    break; // stop at first error for this column
+                }
+            }
+        });
+        return errors;
+    }
+    /**
+     * Validate all rows and return both errors and a flag indicating if there are any errors
+     */
+    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);
+        return { errors: allErrors, valid: !hasErrors, invalid: hasErrors };
+    }
+    /** Traverse all nodes */
+    forEachNode(callback) {
+        const visit = (nodes) => {
+            nodes.forEach((node, index) => {
+                callback(node, index);
+                if (node?.children?.length)
+                    visit(node.children);
+            });
+        };
+        visit(this.rowNodes);
+    }
+    /** Traverse only leaf nodes */
+    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);
+    }
+    getRowNodeById(rowId) {
+        return this._originalRowNodes.get(rowId);
+    }
+    /**
+     * Expand/collapse a node
+     */
+    setTreeDataChildrenField(field) {
+        this.treeDataChildrenField = field;
+    }
+    setGroupDefaultExpanded(defaultExpanded) {
+        this.groupDefaultExpanded = defaultExpanded;
+    }
+    toggleExpandAll(expanded) {
+        this.forEachNode(node => {
+            node.setExpanded(expanded);
+            this.expansionService.toggleExpanded(node.rowId, expanded);
+        });
+        this.refreshVisibleNodes();
+    }
+    setExpandedById(rowId, expanded) {
+        const node = this._originalRowNodes.get(rowId);
+        if (node) {
+            node.setExpanded(expanded);
+            this.expansionService.toggleExpanded(rowId, expanded);
+        }
+        this.refreshVisibleNodes();
+    }
+    setExpandedByIds(rowIds, expanded) {
+        if (rowIds && rowIds.length > 0) {
+            for (let rowId of rowIds) {
+                const node = this._originalRowNodes.get(rowId);
+                if (node) {
+                    node.setExpanded(expanded);
+                    this.expansionService.toggleExpanded(rowId, expanded);
+                }
+            }
+            this.refreshVisibleNodes();
+        }
+    }
+    getExpandedByIds() {
+        return Array.from(this.expansionService.getExpandedIds());
+    }
+    /**
+     * Master Detail Feature
+     */
+    setDetailRowData(node, detailData) {
+        const rowNode = this.getRowNodeById(node.rowId);
+        if (rowNode) {
+            rowNode.setDetailRowData(detailData);
+        }
+    }
+    setGetDetailRowData(getDetailRowData) {
+        this.getDetailRowData = getDetailRowData;
+    }
+    /**
+     * Columns State
+     */
+    getColumnState() {
+        return this.columnService.getColumnState();
+    }
+    setColumnDefs(columnDefs) {
+        this.columnService.setColumnDefs(columnDefs);
+        const columnState = this.columnService.getColumnState();
+        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.eventService.dispatchEvent('columnChanged', columnState);
+    }
+    reorderColumnDefs(fromIndex, toIndex) {
+        this.columnService.reorderColumnDefs(fromIndex, toIndex);
+        const columnState = this.columnService.getColumnState();
+        this.eventService.dispatchEvent('columnChanged', columnState);
+    }
+    /**
+     * Update checkbox selection features
+     */
+    setNodeAndChildrenSelected(node, selected) {
+        const rowIds = new Set();
+        const collect = (n) => {
+            rowIds.add(n.rowId);
+            if (n.children && n.children.length) {
+                n.children.forEach(child => collect(child));
+            }
+        };
+        collect(node);
+        this.setSelectedByIds(Array.from(rowIds), selected);
+    }
+    updateNodeStates(node) {
+        const rowNode = this.getRowNodeById(node.rowId);
+        if (rowNode) {
+            rowNode.cellStates = this.cellService.generateCellStates(rowNode);
+        }
+    }
+    updateCellState(node, column) {
+        const rowNode = this.getRowNodeById(node.rowId);
+        if (rowNode) {
+            rowNode.cellStates[column.field] = this.cellService.generateCellState(rowNode, column);
+        }
+    }
+    updateCellStates(node) {
+        const rowNode = this.getRowNodeById(node.rowId);
+        if (rowNode) {
+            rowNode.cellStates = this.cellService.generateCellStates(rowNode);
+        }
+    }
+    /**
+     * Handler that Reacts to Detail Changes
+     */
+    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);
+            }
+        });
+        // 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]);
+    }
+    registerNodeCleanup(rowId, unsubs) {
+        // Merge with any existing cleanups for this rowId
+        const existing = this._nodeCleanupMap.get(rowId) ?? [];
+        this._nodeCleanupMap.set(rowId, [...existing, ...unsubs]);
+    }
+    cleanupNode(rowId) {
+        const cleanups = this._nodeCleanupMap.get(rowId);
+        cleanups?.forEach(fn => fn());
+        this._nodeCleanupMap.delete(rowId);
+    }
+    // Call this when rows are removed
+    pruneRemovedNodes(validRowIds) {
+        for (const [rowId, node] of this._originalRowNodes) {
+            if (!validRowIds.has(rowId)) {
+                this.cleanupNode(rowId); // unsubscribe listeners
+                node.destroy(); // clear node's own listener map
+                this._originalRowNodes.delete(rowId);
+            }
+        }
+    }
+    /**
+     * Resolve Detail Row Height
+     */
+    _resolvedDetailRowHeight(node) {
+        const minRows = this.detailCellRendererParams.detailGridOptions.detailRowHeightOptions.minRows;
+        const maxRows = this.detailCellRendererParams.detailGridOptions.detailRowHeightOptions.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
+     */
+    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();
+        }
+        this.selectionService = null;
+        if (this.expansionService) {
+            this.expansionService.clear();
+        }
+        this.expansionService = null;
+        this.eventService = null;
+        this.rowService = null;
+        this.cellService = null;
+        // Clear filters, sorting, context
+        this._activeFilters = [];
+        this._quickFilterValue = null;
+        this.sortModel = [];
+        // Clear master/detail/treeData
+        this.masterDetail = false;
+        this.treeData = false;
+        this.treeDataChildrenField = '';
+        this.groupDefaultExpanded = 0;
+    }
+    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 }); }
+}
+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"]}