balala-revogrid 1.0.0

package/dist/collection/plugins/row-select-plugin-2026228.js

@@ -0,0 +1,1803 @@
+/*!
+ * Built by Revolist OU ❤️
+ */
+/**
+ * RowSelectPlugin - 行选择插件
+ *
+ * 功能说明：
+ * 1. 单选/多选：支持点击复选框选择单行，支持 Shift 键范围多选
+ * 2. 全选/取消全选：列头复选框支持全选当前可见行，半选状态显示
+ * 3. 树形选择：与 TreeDataPlugin 配合，支持选择父节点时自动选择/取消子节点
+ * 4. 选中状态同步：行选中后会在行元素上添加 selected 属性，方便 CSS 样式控制
+ * 5. 事件通知：选中状态变化时触发 rowselected 事件，包含选中数量等信息
+ *
+ * 使用方式：
+ * 1. 在列配置中添加 rowSelect: true 启用该列的复选框
+ * 2. 或使用 columnType 指定自定义的 CheckboxCellType
+ * 3. rowSelect 也可以是函数，根据行数据动态决定是否显示复选框
+ */
+import { BasePlugin } from "./base.plugin";
+// ==================== 常量定义 ====================
+/** 行数据类型数组 */
+const ROW_TYPES = ['rowPinStart', 'rgRow', 'rowPinEnd'];
+/** 视口类型数组 */
+const VIEWPORT_TYPES = ['colPinStart', 'rgCol', 'colPinEnd'];
+/** 选中属性名称 */
+export const SELECTED_ATTRIBUTE = 'selected';
+// ==================== 事件常量 ====================
+/** 行选择点击事件 */
+const ROW_SELECT_CLICK_EVENT = 'rowselectclick';
+/** 全选事件 */
+const ROW_ALL_SELECT_EVENT = 'rowallselect';
+/** 列头渲染前事件 */
+const BEFORE_HEADER_RENDER_EVENT = 'beforeheaderrender';
+/** 单元格渲染前事件 */
+const BEFORE_CELL_RENDER_EVENT = 'beforecellrender';
+/** 行渲染前事件 */
+const BEFORE_ROW_RENDER_EVENT = 'beforerowrender';
+/** 树形行选择事件 */
+const TREE_ROW_SELECT_EVENT = 'treerowselect';
+/** 行选中状态变化事件 */
+const ROW_SELECTED_EVENT = 'rowselected';
+/** 滚动期间 wheel 选中态同步限频，避免每帧都触发属性写入 */
+const WHEEL_SELECTION_SYNC_INTERVAL_ACTIVE = 64;
+/** 视口滚动空闲判定 */
+const VIEWPORT_SCROLL_IDLE_DELAY = 90;
+/** hover 指针对齐限频，减少 mousemove 高频触发 RAF */
+const HOVER_POINTER_SYNC_INTERVAL = 40;
+/** 调试开关：临时停用 RowSelectPlugin 注入的所有样式逻辑 */
+const ENABLE_ROW_SELECT_PLUGIN_STYLES = true;
+const ROW_HOVER_ACTIVE_CLASS = 'row-hover-active';
+const ROW_HOVER_SELECTED_ACTIVE_CLASS = 'row-hover-selected-active';
+const EMPTY_ROW_STYLE_FLAGS = {
+    highlighted: false,
+    background: false,
+    focused: false,
+};
+// ==================== 工具函数 ====================
+/**
+ * 触发自定义事件
+ */
+function dispatchCustomEvent(originalEvent, eventName, detail) {
+    var _a;
+    const customEvent = new CustomEvent(eventName, {
+        detail,
+        bubbles: true,
+        cancelable: true,
+    });
+    (_a = originalEvent.target) === null || _a === void 0 ? void 0 : _a.dispatchEvent(customEvent);
+}
+/**
+ * 获取物理行索引
+ */
+function getPhysicalRowIndex(store, virtualIndex) {
+    const items = store.get('items');
+    return items[virtualIndex];
+}
+/**
+ * 创建单元格模板（包装器模式）
+ */
+function createCellTemplate(wrapper, ...templates) {
+    return (h, props, additionalData) => {
+        var _a;
+        wrapper(h, props, additionalData);
+        for (const template of templates) {
+            if (template) {
+                return template(h, props, additionalData);
+            }
+        }
+        return (_a = props.value) !== null && _a !== void 0 ? _a : '';
+    };
+}
+/**
+ * 获取默认单元格值模板
+ */
+function getDefaultCellValue(template) {
+    return template !== null && template !== void 0 ? template : ((_, props) => { var _a; return (_a = props.value) !== null && _a !== void 0 ? _a : ''; });
+}
+// ==================== CheckboxCellType ====================
+/**
+ * 复选框单元格类型
+ * 提供复选框的单元格和列头模板
+ */
+export class CheckboxCellType {
+    constructor() {
+        this.readonly = true;
+        /**
+         * 单元格模板 - 渲染行复选框
+         */
+        this.cellTemplate = (h, props) => h('input', {
+            type: 'checkbox',
+            checked: !!props.selected,
+            onClick(event) {
+                event.preventDefault();
+                const detail = Object.assign(Object.assign({}, props), { originalEvent: event });
+                dispatchCustomEvent(event, ROW_SELECT_CLICK_EVENT, detail);
+            },
+        });
+        /**
+         * 单元格属性
+         */
+        this.cellProperties = () => ({
+            class: 'cell-checkbox',
+        });
+        /**
+         * 列属性
+         */
+        this.columnProperties = () => ({
+            class: 'cell-checkbox',
+        });
+        /**
+         * 列头模板 - 渲染全选复选框
+         */
+        this.columnTemplate = (h, props) => h('div', {
+            class: 'cell-header-checkbox-container',
+        }, h('input', {
+            ref(element) {
+                if (element) {
+                    element.setAttribute('data-ref', 'ref');
+                }
+            },
+            type: 'checkbox',
+            checked: !!props.allSelected,
+            indeterminate: !props.allSelected && !!props.allIndeterminate,
+            onClick(event) {
+                event.preventDefault();
+                if (!(event.target instanceof HTMLInputElement))
+                    return;
+                const detail = {
+                    type: props.providers.type,
+                    selected: !!event.target.checked,
+                };
+                dispatchCustomEvent(event, ROW_ALL_SELECT_EVENT, detail);
+            },
+        }));
+    }
+}
+// ==================== RowSelectPlugin ====================
+/**
+ * 行选择插件
+ * 实现表格行的单选和多选功能
+ */
+export class RowSelectPlugin extends BasePlugin {
+    constructor(revogrid, providers, config = {}) {
+        var _a;
+        super(revogrid, providers);
+        /** 高亮行的 ID 字段名 */
+        this.highlightIdField = 'id';
+        /** 行样式 ID 集合，按类型分组存储 */
+        this.rowStyleIds = new Map([
+            ['highlight', new Set()],
+            ['background', new Set()],
+            ['focused', new Set()],
+        ]);
+        /** Hover 同步状态 */
+        this.hoverSyncEnabled = false;
+        this.hoverRowType = null;
+        this.hoverPhysicalIndex = null;
+        this.hoverLastPointer = null;
+        this.hoverSyncProcessing = false;
+        this.hoverResyncTimer = null;
+        this.hoverResyncRaf = null;
+        this.hoverRenderBlocked = false;
+        this.hoverResyncPending = false;
+        this.hoverMouseDown = false;
+        this.hoverInteractionSuspended = false;
+        this.viewportScrollIdleTimer = null;
+        this.viewportScrolling = false;
+        this.pendingWheelSelectionSyncAfterScroll = false;
+        this.lastWheelSelectionSyncAt = 0;
+        this.lastHoverPointerSyncAt = 0;
+        this.cleanupHoverSync = null;
+        this.pendingSelectionAttributeSync = false;
+        this.selectionAttributeSyncRaf = null;
+        this.postRefreshSyncRaf = null;
+        this.wheelRowSelectionSyncRaf = null;
+        // 初始化选中集合
+        this.selected = (_a = config.initialSelected) !== null && _a !== void 0 ? _a : new Map();
+        ROW_TYPES.forEach((type) => {
+            if (!this.selected.has(type)) {
+                this.selected.set(type, new Set());
+            }
+        });
+        // 保存自定义模板和类型
+        this.customCheckboxTemplate = config.checkboxTemplate;
+        this.customHeaderCheckboxTemplate = config.headerCheckboxTemplate;
+        this.customCheckboxType = config.customCheckboxType;
+        this.treeConfig = config.tree;
+        this.selectedRowStyle = config.selectedRowStyle;
+        this.hoverRowStyle = config.hoverRowStyle;
+        this.highlightRowStyle = config.highlightRowStyle;
+        this.focusedRowStyle = config.focusedRowStyle;
+        this.highlightIdField = config.highlightIdField || 'id';
+        // 创建复选框单元格类型实例
+        this.checkboxCellType = new CheckboxCellType();
+        // 注入自定义样式
+        if (ENABLE_ROW_SELECT_PLUGIN_STYLES) {
+            this.injectCustomStyles();
+        }
+        // 监听过滤器应用事件，更新选中状态
+        this.addEventListener('afterfilterapply', () => {
+            this.blockHoverRender();
+            this.emitSelectionChange();
+            this.scheduleHoverResync();
+        });
+        // 渲染完成后兜底同步 hover，避免中间态闪烁
+        this.addEventListener('afterrender', () => {
+            const shouldResync = this.hoverResyncPending;
+            if (this.hoverRenderBlocked) {
+                this.hoverRenderBlocked = false;
+            }
+            if (this.pendingSelectionAttributeSync) {
+                this.queueSelectionAttributeSync();
+            }
+            else if (this.hasAnySelectedRows() || this.hasAnyRowStyles()) {
+                // 滚动虚拟渲染过程中，同步 wheel-capture-row 的 selected/行样式，避免“慢一拍”上色
+                this.queueWheelRowSelectionSync(true);
+            }
+            if (shouldResync && this.hoverSyncEnabled) {
+                if (this.hoverInteractionSuspended) {
+                    this.hoverResyncPending = true;
+                }
+                else {
+                    this.hoverResyncPending = false;
+                    this.syncHoverFromPointer();
+                }
+            }
+        });
+        // 记录滚动活跃状态，用于限频 wheel-capture 的 selected 同步
+        this.addEventListener('scrollviewport', () => {
+            this.markViewportScrolling();
+        });
+        // 监听行选择点击事件
+        this.addEventListener(ROW_SELECT_CLICK_EVENT, (event) => {
+            if (event.defaultPrevented)
+                return;
+            const { detail } = event;
+            const selectedSet = this.selected.get(detail.type);
+            if (!selectedSet)
+                return;
+            const dataStore = providers.data.stores[detail.type];
+            const physicalIndex = getPhysicalRowIndex(dataStore.store, detail.rowIndex);
+            const isShiftKey = detail.originalEvent.shiftKey;
+            // 处理 Shift 键多选
+            if (isShiftKey && this.lastSelectedIndex !== undefined) {
+                const startIndex = this.lastSelectedIndex;
+                const minIndex = Math.min(startIndex, physicalIndex);
+                const maxIndex = Math.max(startIndex, physicalIndex);
+                // 选中范围内的所有行
+                for (let i = minIndex; i <= maxIndex; i++) {
+                    selectedSet.add(i);
+                }
+                this.lastSelectedIndex = physicalIndex;
+            }
+            else {
+                // 单击切换选中状态
+                const willSelect = !selectedSet.has(physicalIndex);
+                if (willSelect) {
+                    selectedSet.add(physicalIndex);
+                    this.lastSelectedIndex = physicalIndex;
+                }
+                else {
+                    selectedSet.delete(physicalIndex);
+                    this.lastSelectedIndex = undefined;
+                }
+                // 如果配置了树形数据，处理父子节点联动
+                if (this.treeConfig) {
+                    const source = dataStore.store.get('source');
+                    const currentRow = source[physicalIndex];
+                    if (currentRow) {
+                        // 获取所有子节点
+                        const childIndices = this.getChildrenIndices(source, currentRow);
+                        console.log('🟢 复选框点击 - 树形联动:', {
+                            parentIndex: physicalIndex,
+                            parentRowKey: currentRow[this.treeConfig.idField],
+                            willSelect,
+                            childIndices,
+                            childCount: childIndices.length,
+                        });
+                        // 同步子节点的选中状态
+                        childIndices.forEach((childIndex) => {
+                            if (willSelect) {
+                                selectedSet.add(childIndex);
+                            }
+                            else {
+                                selectedSet.delete(childIndex);
+                            }
+                        });
+                    }
+                }
+            }
+            this.emitSelectionChange();
+            this.refreshViewports();
+        });
+        // 监听全选事件
+        this.addEventListener(ROW_ALL_SELECT_EVENT, (event) => {
+            const { detail } = event;
+            this.lastSelectedIndex = undefined;
+            ROW_TYPES.forEach((rowType) => {
+                const selectedSet = this.selected.get(rowType);
+                if (!selectedSet)
+                    return;
+                const dataStore = providers.data.stores[rowType];
+                const source = dataStore.store.get('source');
+                const proxyItems = dataStore.store.get('proxyItems');
+                if (detail.selected) {
+                    // 全选：批量添加所有非分组行的索引
+                    const indicesToAdd = [];
+                    proxyItems.forEach((itemIndex) => {
+                        const rowData = source[itemIndex];
+                        // 跳过分组行（分组行有 __rvgr-depth 标记）
+                        if (rowData && rowData['__rvgr-depth'] !== undefined) {
+                            return;
+                        }
+                        indicesToAdd.push(itemIndex);
+                    });
+                    // 批量添加到 Set（比逐个 add 快很多）
+                    indicesToAdd.forEach(index => selectedSet.add(index));
+                }
+                else {
+                    // 取消全选：直接清空 Set
+                    selectedSet.clear();
+                }
+            });
+            this.emitSelectionChange();
+            this.refreshViewports();
+        });
+        // 监听列头渲染事件
+        this.addEventListener(BEFORE_HEADER_RENDER_EVENT, (event) => {
+            const columnData = event.detail.data;
+            if (this.isCheckboxColumn(columnData)) {
+                // 如果用户提供了自定义 columnType，使用自定义类型
+                const baseType = this.customCheckboxType || this.checkboxCellType;
+                event.detail.data = Object.assign(Object.assign(Object.assign({}, baseType), columnData), { columnTemplate: this.createHeaderTemplate(columnData) });
+            }
+        });
+        // 监听单元格渲染事件
+        this.addEventListener(BEFORE_CELL_RENDER_EVENT, (event) => {
+            const { detail } = event;
+            let column = detail.model.column;
+            if (this.isCheckboxColumn(column)) {
+                // 检查 rowSelect 是否为函数，如果是则调用判断是否显示
+                if (typeof column.rowSelect === 'function' && !column.rowSelect(detail.model)) {
+                    // 不显示复选框
+                }
+                else {
+                    // 如果用户提供了自定义 columnType，使用自定义类型
+                    const baseType = this.customCheckboxType || this.checkboxCellType;
+                    column = Object.assign(Object.assign(Object.assign({}, baseType), column), { cellTemplate: createCellTemplate(this.cellTemplateWrapper.bind(this), this.createCellCheckboxTemplate(), getDefaultCellValue(column.cellTemplate)) });
+                }
+            }
+            detail.model = Object.assign(Object.assign({}, detail.model), { column });
+        });
+        // 监听行渲染事件 - 设置行的选中属性（包括行号列）
+        this.addEventListener(BEFORE_ROW_RENDER_EVENT, (event) => {
+            var _a, _b, _c, _d, _e, _f;
+            const { detail } = event;
+            // detail.item.itemIndex 已经是物理索引，不需要再转换
+            const physicalIndex = detail.item.itemIndex;
+            const hasActiveHoverRow = this.hoverRowType !== null && this.hoverPhysicalIndex !== null;
+            const shouldProcessHoverClass = this.hoverSyncEnabled &&
+                !this.hoverInteractionSuspended &&
+                !!((_a = this.hoverRowStyle) === null || _a === void 0 ? void 0 : _a.backgroundColor) &&
+                hasActiveHoverRow;
+            const hasAnySelected = !!((_b = this.selected.get('rowPinStart')) === null || _b === void 0 ? void 0 : _b.size) ||
+                !!((_c = this.selected.get('rgRow')) === null || _c === void 0 ? void 0 : _c.size) ||
+                !!((_d = this.selected.get('rowPinEnd')) === null || _d === void 0 ? void 0 : _d.size);
+            const hasAnyRowStyle = this.hasAnyRowStyles();
+            if (!hasAnySelected && !shouldProcessHoverClass && !hasAnyRowStyle) {
+                return;
+            }
+            const rowType = detail.rowType;
+            const styleFlags = hasAnyRowStyle && ROW_TYPES.includes(rowType)
+                ? this.getRowStyleFlags(rowType, physicalIndex)
+                : EMPTY_ROW_STYLE_FLAGS;
+            const hoverType = this.hoverRowType;
+            const hoverPhysical = this.hoverPhysicalIndex;
+            const isSelectedRowForHover = ROW_TYPES.includes(rowType) && this.isRowSelected(rowType, physicalIndex);
+            const isHoverTarget = shouldProcessHoverClass &&
+                hoverType !== null &&
+                hoverPhysical !== null &&
+                hoverType === detail.rowType &&
+                hoverPhysical === physicalIndex;
+            const shouldHover = isHoverTarget && !isSelectedRowForHover;
+            const shouldSelectedHover = isHoverTarget && isSelectedRowForHover;
+            const syncHoverClass = (attrs) => {
+                if (!shouldProcessHoverClass) {
+                    return;
+                }
+                const existingClass = attrs.class;
+                if (typeof existingClass === 'string') {
+                    const hasHover = existingClass.includes(ROW_HOVER_ACTIVE_CLASS);
+                    const hasSelectedHover = existingClass.includes(ROW_HOVER_SELECTED_ACTIVE_CLASS);
+                    if (hasHover === shouldHover && hasSelectedHover === shouldSelectedHover) {
+                        return;
+                    }
+                    let nextClass = existingClass;
+                    nextClass = shouldHover
+                        ? `${nextClass} ${ROW_HOVER_ACTIVE_CLASS}`
+                        : nextClass.replace(/\brow-hover-active\b/g, '');
+                    nextClass = shouldSelectedHover
+                        ? `${nextClass} ${ROW_HOVER_SELECTED_ACTIVE_CLASS}`
+                        : nextClass.replace(/\brow-hover-selected-active\b/g, '');
+                    attrs.class = nextClass.replace(/\s+/g, ' ').trim();
+                    return;
+                }
+                if (existingClass && typeof existingClass === 'object') {
+                    if (existingClass[ROW_HOVER_ACTIVE_CLASS] === shouldHover &&
+                        existingClass[ROW_HOVER_SELECTED_ACTIVE_CLASS] === shouldSelectedHover) {
+                        return;
+                    }
+                    attrs.class = Object.assign(Object.assign({}, existingClass), { [ROW_HOVER_ACTIVE_CLASS]: shouldHover, [ROW_HOVER_SELECTED_ACTIVE_CLASS]: shouldSelectedHover });
+                    return;
+                }
+                if (shouldHover || shouldSelectedHover) {
+                    attrs.class = shouldSelectedHover ? ROW_HOVER_SELECTED_ACTIVE_CLASS : ROW_HOVER_ACTIVE_CLASS;
+                }
+            };
+            // 处理数据行
+            if (ROW_TYPES.includes(detail.rowType) && detail.colType !== 'rowHeaders') {
+                const isSelected = (_e = this.selected.get(detail.rowType)) === null || _e === void 0 ? void 0 : _e.has(physicalIndex);
+                const attrs = Object.assign(Object.assign({}, detail.node.$attrs$), { [SELECTED_ATTRIBUTE]: !!isSelected });
+                this.applyRowStyleFlagsToAttrs(attrs, styleFlags);
+                syncHoverClass(attrs);
+                detail.node.$attrs$ = attrs;
+            }
+            // 处理行号列（rowHeaders）
+            if (detail.colType === 'rowHeaders') {
+                // 行号列的行索引与数据行相同
+                const rowType = detail.rowType;
+                if (ROW_TYPES.includes(rowType)) {
+                    const isSelected = (_f = this.selected.get(rowType)) === null || _f === void 0 ? void 0 : _f.has(physicalIndex);
+                    const attrs = Object.assign(Object.assign({}, detail.node.$attrs$), { [SELECTED_ATTRIBUTE]: !!isSelected });
+                    this.applyRowStyleFlagsToAttrs(attrs, styleFlags);
+                    syncHoverClass(attrs);
+                    detail.node.$attrs$ = attrs;
+                }
+            }
+        });
+        // 监听树形行选择事件
+        this.addEventListener(TREE_ROW_SELECT_EVENT, (event) => {
+            const { detail } = event;
+            const selectedSet = this.selected.get(detail.type);
+            if (!selectedSet)
+                return;
+            // 切换父节点和子节点的选中状态
+            if (!selectedSet.has(detail.parentIndex)) {
+                // 如果父节点未选中，则选中父节点和所有子节点
+                selectedSet.add(detail.parentIndex);
+                detail.childrenIndices.forEach((childIndex) => selectedSet.add(childIndex));
+            }
+            else {
+                // 如果父节点已选中，则取消选中父节点和所有子节点
+                detail.childrenIndices.forEach((childIndex) => selectedSet.delete(childIndex));
+                selectedSet.delete(detail.parentIndex);
+            }
+            this.emitSelectionChange();
+            this.refreshViewports();
+        });
+        // 监听分组展开/折叠事件，更新选中状态显示
+        this.addEventListener('groupexpandclick', () => {
+            this.blockHoverRender();
+            this.pendingSelectionAttributeSync = true;
+        });
+        // 监听树形节点展开/折叠事件，更新选中状态显示
+        this.addEventListener('treenodetoggle', () => {
+            this.blockHoverRender();
+            this.pendingSelectionAttributeSync = true;
+        });
+    }
+    // ==================== 公共方法 ====================
+    /**
+     * 获取所有选中行的索引
+     */
+    getSelectedIndexes() {
+        return this.selected;
+    }
+    /**
+     * 获取选中行的数据
+     */
+    getSelectedRows() {
+        const result = new Map();
+        this.selected.forEach((selectedSet, rowType) => {
+            const dataStore = this.providers.data.stores[rowType];
+            const source = dataStore.store.get('source');
+            const rows = [];
+            selectedSet.forEach((physicalIndex) => {
+                if (source[physicalIndex]) {
+                    rows.push(source[physicalIndex]);
+                }
+            });
+            result.set(rowType, rows);
+        });
+        return result;
+    }
+    /**
+     * 清空所有选中
+     */
+    clearSelection() {
+        this.selected.forEach((selectedSet) => selectedSet.clear());
+        this.lastSelectedIndex = undefined;
+        this.emitSelectionChange();
+        this.refreshViewports();
+    }
+    /**
+     * 全选所有行（触发全选事件）
+     */
+    selectAll() {
+        // 触发全选事件
+        const event = new CustomEvent('rowallselect', {
+            detail: {
+                type: 'rgRow',
+                selected: true,
+            },
+            bubbles: true,
+        });
+        this.revogrid.dispatchEvent(event);
+    }
+    /**
+     * 取消全选（触发取消全选事件）
+     */
+    deselectAll() {
+        // 触发取消全选事件
+        const event = new CustomEvent('rowallselect', {
+            detail: {
+                type: 'rgRow',
+                selected: false,
+            },
+            bubbles: true,
+        });
+        this.revogrid.dispatchEvent(event);
+    }
+    /**
+     * 选中指定行（支持树形联动）
+     */
+    selectRows(rowType, indices) {
+        const selectedSet = this.selected.get(rowType);
+        if (!selectedSet)
+            return;
+        const indicesToSelect = [...indices];
+        // 如果配置了树形数据，处理父子节点联动
+        if (this.treeConfig) {
+            const dataStore = this.providers.data.stores[rowType];
+            const source = dataStore.store.get('source');
+            indices.forEach((index) => {
+                const row = source[index];
+                if (row) {
+                    const { idField, parentIdField } = this.treeConfig;
+                    const parentId = row[idField];
+                    console.log('🔵 selectRows - 父节点信息:', {
+                        parentIndex: index,
+                        idField,
+                        parentIdField,
+                        parentId,
+                        parentRowData: row,
+                    });
+                    // 获取所有子节点
+                    const childIndices = this.getChildrenIndices(source, row);
+                    // 打印找到的子节点
+                    childIndices.forEach(childIdx => {
+                        const childRow = source[childIdx];
+                        console.log('🔵 找到子节点:', {
+                            childIndex: childIdx,
+                            childParentId: childRow === null || childRow === void 0 ? void 0 : childRow[parentIdField],
+                            childRowKey: childRow === null || childRow === void 0 ? void 0 : childRow.rowKey,
+                        });
+                    });
+                    console.log('🔵 selectRows - 树形联动结果:', {
+                        parentIndex: index,
+                        childIndices,
+                        childCount: childIndices.length,
+                    });
+                    indicesToSelect.push(...childIndices);
+                }
+            });
+        }
+        console.log('🔵 selectRows - 最终选中索引:', indicesToSelect);
+        indicesToSelect.forEach((index) => selectedSet.add(index));
+        this.emitSelectionChange();
+        this.refreshViewports();
+    }
+    /**
+     * 取消选中指定行（支持树形联动）
+     */
+    deselectRows(rowType, indices) {
+        const selectedSet = this.selected.get(rowType);
+        if (!selectedSet)
+            return;
+        const indicesToDeselect = [...indices];
+        // 如果配置了树形数据，处理父子节点联动
+        if (this.treeConfig) {
+            const dataStore = this.providers.data.stores[rowType];
+            const source = dataStore.store.get('source');
+            indices.forEach((index) => {
+                const row = source[index];
+                if (row) {
+                    // 获取所有子节点
+                    const childIndices = this.getChildrenIndices(source, row);
+                    indicesToDeselect.push(...childIndices);
+                }
+            });
+        }
+        indicesToDeselect.forEach((index) => selectedSet.delete(index));
+        this.emitSelectionChange();
+        this.refreshViewports();
+    }
+    /**
+     * 获取选中行的指定字段值列表
+     * @param field 字段名，如 'id'、'key' 等
+     * @param rowType 行类型，默认 'rgRow'
+     * @returns 字段值数组
+     */
+    getSelectedFieldValues(field, rowType = 'rgRow') {
+        const selectedSet = this.selected.get(rowType);
+        if (!selectedSet)
+            return [];
+        const dataStore = this.providers.data.stores[rowType];
+        const source = dataStore.store.get('source');
+        const values = [];
+        selectedSet.forEach((physicalIndex) => {
+            const row = source[physicalIndex];
+            if (row && row[field] !== undefined) {
+                values.push(row[field]);
+            }
+        });
+        return values;
+    }
+    /**
+     * 获取所有选中行的数据（扁平数组）
+     * @param rowType 行类型，默认 'rgRow'
+     * @returns 选中行数据数组
+     */
+    getSelectedData(rowType = 'rgRow') {
+        const selectedSet = this.selected.get(rowType);
+        if (!selectedSet)
+            return [];
+        const dataStore = this.providers.data.stores[rowType];
+        const source = dataStore.store.get('source');
+        const rows = [];
+        selectedSet.forEach((physicalIndex) => {
+            if (source[physicalIndex]) {
+                rows.push(source[physicalIndex]);
+            }
+        });
+        return rows;
+    }
+    /**
+     * 获取选中的根节点数据（过滤掉子节点）
+     * 用于树形数据场景，只返回顶层选中的节点
+     * @param rowType 行类型，默认 'rgRow'
+     * @returns 根节点数据数组
+     */
+    getSelectedRootData(rowType = 'rgRow') {
+        if (!this.treeConfig) {
+            // 没有配置树形，返回所有选中数据
+            return this.getSelectedData(rowType);
+        }
+        const { idField, parentIdField, rootParentId } = this.treeConfig;
+        const selectedData = this.getSelectedData(rowType);
+        // 构建选中 ID 集合
+        const selectedIds = new Set(selectedData.map(row => row[idField]));
+        // 过滤：只保留父节点不在选中集合中的行（即根节点）
+        return selectedData.filter(row => {
+            const parentId = row[parentIdField];
+            // 如果父 ID 是根节点值，或者父节点不在选中集合中，则为根节点
+            return parentId === rootParentId || parentId === null || parentId === undefined || !selectedIds.has(parentId);
+        });
+    }
+    /**
+     * 获取选中根节点的指定字段值列表（过滤掉子节点）
+     * @param field 字段名，如 'id'、'key' 等
+     * @param rowType 行类型，默认 'rgRow'
+     * @returns 字段值数组
+     */
+    getSelectedRootFieldValues(field, rowType = 'rgRow') {
+        const rootData = this.getSelectedRootData(rowType);
+        return rootData
+            .filter(row => row[field] !== undefined)
+            .map(row => row[field]);
+    }
+    /**
+     * 根据 ID 高亮某一行
+     * @param id 行的 ID 值
+     * @param idField 可选，ID 字段名，默认使用配置的 highlightIdField
+     * @deprecated 请使用 applyRowStyle('highlight', [id], idField) 代替
+     */
+    highlightRowById(id, idField) {
+        this.applyRowStyle('highlight', [id], idField);
+    }
+    /**
+     * 清除行高亮
+     * @deprecated 请使用 clearRowStyle('highlight') 代替
+     */
+    clearHighlight() {
+        this.clearRowStyle('highlight');
+    }
+    /**
+     * 获取当前高亮的行 ID
+     * @deprecated 请使用 getRowStyleIds('highlight') 代替
+     */
+    getHighlightedRowId() {
+        const ids = this.rowStyleIds.get('highlight');
+        return ids && ids.size > 0 ? Array.from(ids)[0] : null;
+    }
+    /**
+     * 获取当前高亮的行数据
+     * @param rowType 行类型，默认 'rgRow'
+     */
+    getHighlightedRowData(rowType = 'rgRow') {
+        const highlightedId = this.getHighlightedRowId();
+        if (highlightedId === null)
+            return null;
+        const dataStore = this.providers.data.stores[rowType];
+        const source = dataStore.store.get('source');
+        for (const row of source) {
+            if (row && row[this.highlightIdField] === highlightedId) {
+                return row;
+            }
+        }
+        return null;
+    }
+    /**
+     * 为指定行应用样式（高亮或背景色）
+     * @param type 样式类型：'highlight' 使用高亮色，'background' 使用 hover 背景色
+     * @param ids 行的 ID 值数组
+     * @param idField 可选，ID 字段名，默认使用配置的 highlightIdField
+     */
+    applyRowStyle(type, ids, idField) {
+        const styleSet = this.rowStyleIds.get(type);
+        if (!styleSet)
+            return;
+        ids.forEach((id) => styleSet.add(id));
+        this.updateRowStyleAttribute(type, idField || this.highlightIdField);
+    }
+    /**
+     * 移除指定行的样式
+     * @param type 样式类型：'highlight' 或 'background'
+     * @param ids 行的 ID 值数组，如果不传则移除该类型所有行的样式
+     * @param idField 可选，ID 字段名，默认使用配置的 highlightIdField
+     */
+    removeRowStyle(type, ids, idField) {
+        const styleSet = this.rowStyleIds.get(type);
+        if (!styleSet)
+            return;
+        if (ids) {
+            ids.forEach((id) => styleSet.delete(id));
+        }
+        else {
+            styleSet.clear();
+        }
+        this.updateRowStyleAttribute(type, idField || this.highlightIdField);
+    }
+    /**
+     * 清除指定类型的所有行样式
+     * @param type 样式类型：'highlight' 或 'background'
+     */
+    clearRowStyle(type) {
+        const styleSet = this.rowStyleIds.get(type);
+        if (!styleSet)
+            return;
+        styleSet.clear();
+        this.clearRowStyleAttribute(type);
+        this.refreshViewports();
+    }
+    /**
+     * 获取已应用样式的行 ID
+     * @param type 样式类型：'highlight' 或 'background'
+     */
+    getRowStyleIds(type) {
+        return this.rowStyleIds.get(type) || new Set();
+    }
+    /**
+     * 清除所有行样式（高亮和背景色）
+     */
+    clearAllRowStyles() {
+        this.rowStyleIds.forEach((styleSet, type) => {
+            styleSet.clear();
+            this.clearRowStyleAttribute(type);
+        });
+        this.refreshViewports();
+    }
+    // ==================== 私有方法 ====================
+    /**
+     * 注入自定义样式
+     */
+    injectCustomStyles() {
+        var _a, _b, _c, _d, _e, _f, _g, _j, _k, _l, _m;
+        if (!ENABLE_ROW_SELECT_PLUGIN_STYLES) {
+            return;
+        }
+        // 如果没有配置样式，则不注入
+        if (!this.selectedRowStyle && !this.hoverRowStyle && !this.highlightRowStyle && !this.focusedRowStyle) {
+            return;
+        }
+        // 创建 style 元素
+        this.styleElement = document.createElement('style');
+        this.styleElement.setAttribute('data-revogrid-row-select-styles', '');
+        // 设置 CSS 变量到 revo-grid 元素
+        if ((_a = this.selectedRowStyle) === null || _a === void 0 ? void 0 : _a.backgroundColor) {
+            this.revogrid.style.setProperty('--revo-row-selected-bg', this.selectedRowStyle.backgroundColor);
+        }
+        if ((_b = this.highlightRowStyle) === null || _b === void 0 ? void 0 : _b.backgroundColor) {
+            this.revogrid.style.setProperty('--revo-row-highlight-bg', this.highlightRowStyle.backgroundColor);
+        }
+        else if ((_c = this.selectedRowStyle) === null || _c === void 0 ? void 0 : _c.backgroundColor) {
+            // 默认使用选中行的颜色
+            this.revogrid.style.setProperty('--revo-row-highlight-bg', this.selectedRowStyle.backgroundColor);
+        }
+        if ((_d = this.focusedRowStyle) === null || _d === void 0 ? void 0 : _d.backgroundColor) {
+            this.revogrid.style.setProperty('--revo-row-focused-bg', this.focusedRowStyle.backgroundColor);
+        }
+        if ((_e = this.hoverRowStyle) === null || _e === void 0 ? void 0 : _e.backgroundColor) {
+            this.revogrid.style.setProperty('--revo-row-hover-bg', this.hoverRowStyle.backgroundColor);
+        }
+        let css = '';
+        // wheel-capture 行默认透明，避免滚动虚拟渲染时短暂覆盖底层单元格/行背景导致闪烁
+        css += `
+      revo-grid .wheel-capture-row {
+        background-color: transparent !important;
+      }
+    `;
+        // 选中行样式 - 作用在真实数据行，避免 overlay 层覆盖单元格内容导致闪烁
+        if ((_f = this.selectedRowStyle) === null || _f === void 0 ? void 0 : _f.backgroundColor) {
+            css += `
+        revo-grid revogr-data .rgRow:not(.groupingRow)[selected='true'],
+        revo-grid revogr-data .rgRow:not(.groupingRow)[selected=''],
+        revo-grid revogr-data .rgRow:not(.groupingRow)[selected] {
+          background-color: var(--revo-row-selected-bg) !important;
+        }
+        revo-grid .wheel-capture-row[selected] {
+          background-color: var(--revo-row-selected-bg) !important;
+        }
+      `;
+        }
+        // 高亮行样式 - 独立于选中状态
+        if (((_g = this.highlightRowStyle) === null || _g === void 0 ? void 0 : _g.backgroundColor) || ((_j = this.selectedRowStyle) === null || _j === void 0 ? void 0 : _j.backgroundColor)) {
+            css += `
+        revo-grid revogr-data .rgRow:not(.groupingRow)[data-highlighted='true'],
+        revo-grid .wheel-capture-row[data-highlighted='true'] {
+          background-color: var(--revo-row-highlight-bg) !important;
+        }
+      `;
+        }
+        // 聚焦行样式 - 独立样式，优先级最高
+        if ((_k = this.focusedRowStyle) === null || _k === void 0 ? void 0 : _k.backgroundColor) {
+            css += `
+        revo-grid revogr-data .rgRow:not(.groupingRow)[data-focused='true'],
+        revo-grid .wheel-capture-row[data-focused='true'] {
+          background-color: var(--revo-row-focused-bg) !important;
+        }
+      `;
+        }
+        // 未选中行 hover 样式 - 作用在真实数据行；分组行保留 overlay 路径
+        if ((_l = this.hoverRowStyle) === null || _l === void 0 ? void 0 : _l.backgroundColor) {
+            css += `
+        revo-grid revogr-data .rgRow:not(.groupingRow).row-hover-active:not([selected]):not([data-focused='true']) {
+          background-color: var(--revo-row-hover-bg) !important;
+        }
+        revo-grid revogr-grouping-overlay .rgRow.groupingRow.row-hover-active:not([selected]):not([data-focused='true']) {
+          background-color: var(--revo-row-hover-bg) !important;
+        }
+        revo-grid .wheel-capture-row.row-hover-active:not([selected]):not([data-focused='true']) {
+          background-color: var(--revo-row-hover-bg) !important;
+        }
+        /* 程序化应用背景色样式 - 沿用 hover 样式配置 */
+        revo-grid revogr-data .rgRow:not(.groupingRow)[data-row-bg='true']:not([selected]):not([data-focused='true']) {
+          background-color: var(--revo-row-hover-bg) !important;
+        }
+        revo-grid revogr-grouping-overlay .rgRow.groupingRow[data-row-bg='true']:not([selected]):not([data-focused='true']) {
+          background-color: var(--revo-row-hover-bg) !important;
+        }
+        revo-grid .wheel-capture-row[data-row-bg='true']:not([selected]):not([data-focused='true']) {
+          background-color: var(--revo-row-hover-bg) !important;
+        }
+        /* 滚动期间临时禁用行层 pointer events，减少 pointerover 带来的样式重算 */
+        revo-grid.row-hover-suspended revogr-grouping-overlay .rgRow,
+        revo-grid.row-hover-suspended revogr-data .rgRow,
+        revo-grid.row-hover-suspended .wheel-capture-row {
+          pointer-events: none !important;
+        }
+      `;
+        }
+        this.styleElement.textContent = css;
+        document.head.appendChild(this.styleElement);
+        // 仅在启用 hover 样式时添加跨视口 hover 同步监听，避免不必要的滚动计算
+        if ((_m = this.hoverRowStyle) === null || _m === void 0 ? void 0 : _m.backgroundColor) {
+            this.setupHoverSync();
+        }
+    }
+    /**
+     * 设置 hover 同步（跨视口）
+     * 通过添加/移除 row-hover-active 类实现跨视口的 hover 效果
+     */
+    getRowTypeFromElement(row) {
+        if (!row) {
+            return null;
+        }
+        const container = row.closest('revogr-data, revogr-grouping-overlay');
+        if (!container) {
+            return null;
+        }
+        if (container.tagName === 'REVOGR-GROUPING-OVERLAY') {
+            return 'rgRow';
+        }
+        const rawType = container.getAttribute('type') || container.type;
+        if (rawType === 'rowHeaders') {
+            return 'rgRow';
+        }
+        if (rawType && ROW_TYPES.includes(rawType)) {
+            return rawType;
+        }
+        return null;
+    }
+    getPhysicalIndexFromRow(row, rowType) {
+        const rowIndexAttr = row.getAttribute('data-rgRow');
+        if (!rowIndexAttr) {
+            return null;
+        }
+        const virtualIndex = Number(rowIndexAttr);
+        if (Number.isNaN(virtualIndex)) {
+            return null;
+        }
+        const store = this.providers.data.stores[rowType];
+        if (!store) {
+            return null;
+        }
+        const items = store.store.get('items');
+        const physicalIndex = items[virtualIndex];
+        return physicalIndex === undefined ? null : physicalIndex;
+    }
+    getVirtualIndexFromPhysical(rowType, physicalIndex) {
+        const store = this.providers.data.stores[rowType];
+        if (!store) {
+            return null;
+        }
+        const items = store.store.get('items');
+        const virtualIndex = items.indexOf(physicalIndex);
+        return virtualIndex === -1 ? null : virtualIndex;
+    }
+    getRowElementsByVirtualIndex(rowType, virtualIndex) {
+        const selectors = [
+            `revogr-data[type="${rowType}"] .rgRow[data-rgRow="${virtualIndex}"]`,
+        ];
+        if (rowType === 'rgRow') {
+            selectors.push(`revogr-grouping-overlay .rgRow[data-rgRow="${virtualIndex}"]`);
+            selectors.push(`revogr-data[type="rowHeaders"] .rgRow[data-rgRow="${virtualIndex}"]`);
+        }
+        const selector = selectors.join(', ');
+        return this.revogrid.querySelectorAll(selector);
+    }
+    isRowSelected(rowType, physicalIndex) {
+        var _a;
+        return !!((_a = this.selected.get(rowType)) === null || _a === void 0 ? void 0 : _a.has(physicalIndex));
+    }
+    applyHoverClass(rowType, physicalIndex) {
+        const virtualIndex = this.getVirtualIndexFromPhysical(rowType, physicalIndex);
+        if (virtualIndex === null) {
+            return false;
+        }
+        const isSelected = this.isRowSelected(rowType, physicalIndex);
+        const allRowsWithSameIndex = this.getRowElementsByVirtualIndex(rowType, virtualIndex);
+        allRowsWithSameIndex.forEach((row) => {
+            row.classList.remove(isSelected ? ROW_HOVER_ACTIVE_CLASS : ROW_HOVER_SELECTED_ACTIVE_CLASS);
+            row.classList.add(isSelected ? ROW_HOVER_SELECTED_ACTIVE_CLASS : ROW_HOVER_ACTIVE_CLASS);
+        });
+        return true;
+    }
+    clearHoverClass(rowType, physicalIndex) {
+        const allHoverRows = this.revogrid.querySelectorAll(`.rgRow.${ROW_HOVER_ACTIVE_CLASS}, .rgRow.${ROW_HOVER_SELECTED_ACTIVE_CLASS}`);
+        allHoverRows.forEach((row) => {
+            const type = this.getRowTypeFromElement(row);
+            if (!type || type !== rowType) {
+                return;
+            }
+            const rowPhysical = this.getPhysicalIndexFromRow(row, type);
+            if (rowPhysical === physicalIndex) {
+                row.classList.remove(ROW_HOVER_ACTIVE_CLASS);
+                row.classList.remove(ROW_HOVER_SELECTED_ACTIVE_CLASS);
+            }
+        });
+    }
+    clearAllHoverClass() {
+        if (this.hoverRowType === null && this.hoverPhysicalIndex === null) {
+            return;
+        }
+        const allHoverRows = this.revogrid.querySelectorAll(`.rgRow.${ROW_HOVER_ACTIVE_CLASS}, .rgRow.${ROW_HOVER_SELECTED_ACTIVE_CLASS}`);
+        allHoverRows.forEach((row) => {
+            row.classList.remove(ROW_HOVER_ACTIVE_CLASS);
+            row.classList.remove(ROW_HOVER_SELECTED_ACTIVE_CLASS);
+        });
+        this.hoverRowType = null;
+        this.hoverPhysicalIndex = null;
+    }
+    normalizeHoverClasses(expectedType, expectedPhysicalIndex) {
+        const allHoverRows = this.revogrid.querySelectorAll(`.rgRow.${ROW_HOVER_ACTIVE_CLASS}, .rgRow.${ROW_HOVER_SELECTED_ACTIVE_CLASS}`);
+        allHoverRows.forEach((row) => {
+            const type = this.getRowTypeFromElement(row);
+            const physicalIndex = type ? this.getPhysicalIndexFromRow(row, type) : null;
+            if (!expectedType ||
+                expectedPhysicalIndex === null ||
+                type !== expectedType ||
+                physicalIndex !== expectedPhysicalIndex) {
+                row.classList.remove(ROW_HOVER_ACTIVE_CLASS);
+                row.classList.remove(ROW_HOVER_SELECTED_ACTIVE_CLASS);
+            }
+        });
+        if (expectedType && expectedPhysicalIndex !== null) {
+            const applied = this.applyHoverClass(expectedType, expectedPhysicalIndex);
+            if (applied) {
+                this.hoverRowType = expectedType;
+                this.hoverPhysicalIndex = expectedPhysicalIndex;
+            }
+            else {
+                this.hoverRowType = null;
+                this.hoverPhysicalIndex = null;
+            }
+        }
+        else {
+            this.hoverRowType = null;
+            this.hoverPhysicalIndex = null;
+        }
+    }
+    updateHoverFromRow(row) {
+        if (!row) {
+            if (this.hoverRowType && this.hoverPhysicalIndex !== null) {
+                this.clearHoverClass(this.hoverRowType, this.hoverPhysicalIndex);
+            }
+            this.hoverRowType = null;
+            this.hoverPhysicalIndex = null;
+            return;
+        }
+        const rowType = this.getRowTypeFromElement(row);
+        if (!rowType) {
+            return;
+        }
+        const physicalIndex = this.getPhysicalIndexFromRow(row, rowType);
+        if (physicalIndex === null) {
+            return;
+        }
+        if (this.hoverRowType === rowType && this.hoverPhysicalIndex === physicalIndex) {
+            return;
+        }
+        if (this.hoverRowType && this.hoverPhysicalIndex !== null) {
+            this.clearHoverClass(this.hoverRowType, this.hoverPhysicalIndex);
+        }
+        this.hoverRowType = rowType;
+        this.hoverPhysicalIndex = physicalIndex;
+        const applied = this.applyHoverClass(rowType, physicalIndex);
+        if (!applied) {
+            this.hoverRowType = null;
+            this.hoverPhysicalIndex = null;
+        }
+    }
+    syncHoverFromPointer() {
+        if (this.hoverInteractionSuspended) {
+            this.hoverResyncPending = true;
+            return;
+        }
+        if (this.hoverMouseDown && this.hoverRowType && this.hoverPhysicalIndex !== null) {
+            this.normalizeHoverClasses(this.hoverRowType, this.hoverPhysicalIndex);
+            return;
+        }
+        if (!this.hoverLastPointer) {
+            this.normalizeHoverClasses(null, null);
+            return;
+        }
+        const element = document.elementFromPoint(this.hoverLastPointer.x, this.hoverLastPointer.y);
+        if (!element || !this.revogrid.contains(element)) {
+            const rect = this.revogrid.getBoundingClientRect();
+            const isPointerInsideGrid = this.hoverLastPointer.x >= rect.left &&
+                this.hoverLastPointer.x <= rect.right &&
+                this.hoverLastPointer.y >= rect.top &&
+                this.hoverLastPointer.y <= rect.bottom;
+            if (isPointerInsideGrid && this.hoverRowType && this.hoverPhysicalIndex !== null) {
+                this.normalizeHoverClasses(this.hoverRowType, this.hoverPhysicalIndex);
+                return;
+            }
+            this.normalizeHoverClasses(null, null);
+            return;
+        }
+        const row = element.closest('.rgRow');
+        const rowType = this.getRowTypeFromElement(row);
+        const physicalIndex = row && rowType ? this.getPhysicalIndexFromRow(row, rowType) : null;
+        this.normalizeHoverClasses(rowType, physicalIndex);
+    }
+    blockHoverRender() {
+        if (this.hoverRenderBlocked) {
+            this.hoverResyncPending = true;
+            return;
+        }
+        this.hoverRenderBlocked = true;
+        this.hoverResyncPending = true;
+    }
+    queueHoverResync() {
+        if (!this.hoverSyncEnabled) {
+            return;
+        }
+        if (this.hoverInteractionSuspended) {
+            this.hoverResyncPending = true;
+            return;
+        }
+        if (this.hoverResyncRaf !== null) {
+            cancelAnimationFrame(this.hoverResyncRaf);
+        }
+        this.hoverResyncRaf = requestAnimationFrame(() => {
+            this.hoverResyncRaf = null;
+            if (this.hoverRenderBlocked) {
+                this.hoverResyncPending = true;
+                return;
+            }
+            this.hoverResyncPending = false;
+            this.syncHoverFromPointer();
+        });
+    }
+    scheduleHoverResync(delay = 0) {
+        if (!this.hoverSyncEnabled) {
+            return;
+        }
+        if (this.hoverInteractionSuspended) {
+            this.hoverResyncPending = true;
+            return;
+        }
+        if (this.hoverResyncTimer) {
+            clearTimeout(this.hoverResyncTimer);
+        }
+        if (this.hoverRenderBlocked) {
+            this.hoverResyncPending = true;
+            return;
+        }
+        this.hoverResyncTimer = setTimeout(() => {
+            this.queueHoverResync();
+        }, delay);
+    }
+    queueSelectionAttributeSync() {
+        if (this.selectionAttributeSyncRaf !== null) {
+            return;
+        }
+        this.selectionAttributeSyncRaf = requestAnimationFrame(() => {
+            this.selectionAttributeSyncRaf = null;
+            if (!this.pendingSelectionAttributeSync) {
+                return;
+            }
+            this.pendingSelectionAttributeSync = false;
+            this.updateSelectedAttributes();
+            this.scheduleHoverResync();
+        });
+    }
+    setHoverSuspendedClass(active) {
+        this.revogrid.classList.toggle('row-hover-suspended', active);
+    }
+    setupHoverSync() {
+        var _a;
+        (_a = this.cleanupHoverSync) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.hoverSyncEnabled = true;
+        const handleMouseDown = (e) => {
+            if (this.viewportScrolling) {
+                return;
+            }
+            this.hoverMouseDown = true;
+            this.hoverLastPointer = { x: e.clientX, y: e.clientY };
+            const target = e.target;
+            const row = (target === null || target === void 0 ? void 0 : target.closest) ? target.closest('.rgRow') : null;
+            this.updateHoverFromRow(row);
+        };
+        const handleMouseUp = (e) => {
+            if (this.viewportScrolling) {
+                return;
+            }
+            this.hoverMouseDown = false;
+            this.hoverLastPointer = { x: e.clientX, y: e.clientY };
+            if (this.hoverInteractionSuspended) {
+                this.hoverResyncPending = true;
+                return;
+            }
+            this.syncHoverFromPointer();
+        };
+        const handleMouseMove = (e) => {
+            if (this.viewportScrolling) {
+                return;
+            }
+            if (this.hoverInteractionSuspended) {
+                this.hoverLastPointer = { x: e.clientX, y: e.clientY };
+                this.hoverResyncPending = true;
+                return;
+            }
+            const now = performance.now();
+            if (now - this.lastHoverPointerSyncAt < HOVER_POINTER_SYNC_INTERVAL) {
+                this.hoverLastPointer = { x: e.clientX, y: e.clientY };
+                return;
+            }
+            this.lastHoverPointerSyncAt = now;
+            if (this.hoverSyncProcessing)
+                return;
+            this.hoverSyncProcessing = true;
+            this.hoverLastPointer = { x: e.clientX, y: e.clientY };
+            requestAnimationFrame(() => {
+                if (this.hoverRenderBlocked) {
+                    this.hoverSyncProcessing = false;
+                    return;
+                }
+                const target = e.target;
+                const row = (target === null || target === void 0 ? void 0 : target.closest) ? target.closest('.rgRow') : null;
+                this.updateHoverFromRow(row);
+                this.hoverSyncProcessing = false;
+            });
+        };
+        const handleMouseLeave = (e) => {
+            if (this.viewportScrolling) {
+                return;
+            }
+            if (this.hoverInteractionSuspended) {
+                return;
+            }
+            if (this.hoverMouseDown) {
+                return;
+            }
+            const relatedTarget = e.relatedTarget;
+            if (relatedTarget && this.revogrid.contains(relatedTarget)) {
+                return;
+            }
+            const pointer = { x: e.clientX, y: e.clientY };
+            this.hoverLastPointer = pointer;
+            requestAnimationFrame(() => {
+                const element = document.elementFromPoint(pointer.x, pointer.y);
+                if (element && this.revogrid.contains(element)) {
+                    const row = element.closest('.rgRow');
+                    this.updateHoverFromRow(row);
+                    return;
+                }
+                this.clearAllHoverClass();
+                this.hoverLastPointer = null;
+            });
+        };
+        this.revogrid.addEventListener('mousedown', handleMouseDown);
+        document.addEventListener('mouseup', handleMouseUp);
+        this.revogrid.addEventListener('mousemove', handleMouseMove);
+        this.revogrid.addEventListener('mouseleave', handleMouseLeave);
+        this.cleanupHoverSync = () => {
+            this.revogrid.removeEventListener('mousedown', handleMouseDown);
+            document.removeEventListener('mouseup', handleMouseUp);
+            this.revogrid.removeEventListener('mousemove', handleMouseMove);
+            this.revogrid.removeEventListener('mouseleave', handleMouseLeave);
+            this.hoverMouseDown = false;
+            this.hoverSyncProcessing = false;
+            this.hoverInteractionSuspended = false;
+            this.setHoverSuspendedClass(false);
+            this.lastHoverPointerSyncAt = 0;
+        };
+    }
+    /**
+     * 获取所有子节点的索引（递归）
+     */
+    getChildrenIndices(source, parentRow) {
+        if (!this.treeConfig)
+            return [];
+        const { idField, parentIdField } = this.treeConfig;
+        const parentId = parentRow[idField];
+        const childIndices = [];
+        // 遍历所有行，找到子节点
+        source.forEach((row, index) => {
+            if (row[parentIdField] === parentId) {
+                childIndices.push(index);
+                // 递归获取子节点的子节点
+                const grandChildIndices = this.getChildrenIndices(source, row);
+                childIndices.push(...grandChildIndices);
+            }
+        });
+        return childIndices;
+    }
+    /**
+     * 更新行样式属性
+     */
+    updateRowStyleAttribute(type, idField) {
+        // 先清除该类型的所有样式
+        this.clearRowStyleAttribute(type);
+        const styleSet = this.rowStyleIds.get(type);
+        if (!styleSet || styleSet.size === 0)
+            return;
+        const attrName = type === 'highlight' ? 'data-highlighted' : type === 'focused' ? 'data-focused' : 'data-row-bg';
+        // 遍历所有行类型，找到匹配的行并设置样式属性
+        ROW_TYPES.forEach((rowType) => {
+            const dataStore = this.providers.data.stores[rowType];
+            const source = dataStore.store.get('source');
+            const items = dataStore.store.get('items');
+            items.forEach((physicalIndex, virtualIndex) => {
+                const row = source[physicalIndex];
+                if (row && styleSet.has(row[idField])) {
+                    // 找到匹配的行，设置样式属性
+                    const rowElements = this.revogrid.querySelectorAll(`.rgRow[data-rgRow="${virtualIndex}"]`);
+                    rowElements.forEach((el) => {
+                        el.setAttribute(attrName, 'true');
+                    });
+                    // 同时设置 wheel-capture-row
+                    const wheelRows = this.revogrid.querySelectorAll(`.wheel-capture-row[data-rgRow="${virtualIndex}"]`);
+                    wheelRows.forEach((el) => {
+                        el.setAttribute(attrName, 'true');
+                    });
+                }
+            });
+        });
+        // 更新 revo-grid 元素的属性
+        if (type === 'highlight') {
+            this.revogrid.setAttribute('data-highlighted-rows', JSON.stringify(Array.from(styleSet)));
+        }
+        else if (type === 'focused') {
+            this.revogrid.setAttribute('data-focused-rows', JSON.stringify(Array.from(styleSet)));
+        }
+        else {
+            this.revogrid.setAttribute('data-row-bg-ids', JSON.stringify(Array.from(styleSet)));
+        }
+    }
+    /**
+     * 清除行样式属性
+     */
+    clearRowStyleAttribute(type) {
+        const attrName = type === 'highlight' ? 'data-highlighted' : type === 'focused' ? 'data-focused' : 'data-row-bg';
+        // 移除所有行的样式属性
+        const styledRows = this.revogrid.querySelectorAll(`[${attrName}="true"]`);
+        styledRows.forEach((el) => {
+            el.removeAttribute(attrName);
+        });
+        // 移除 revo-grid 元素的属性
+        if (type === 'highlight') {
+            this.revogrid.removeAttribute('data-highlighted-rows');
+        }
+        else if (type === 'focused') {
+            this.revogrid.removeAttribute('data-focused-rows');
+        }
+        else {
+            this.revogrid.removeAttribute('data-row-bg-ids');
+        }
+    }
+    hasAnySelectedRows() {
+        var _a, _b, _c;
+        return (!!((_a = this.selected.get('rowPinStart')) === null || _a === void 0 ? void 0 : _a.size) ||
+            !!((_b = this.selected.get('rgRow')) === null || _b === void 0 ? void 0 : _b.size) ||
+            !!((_c = this.selected.get('rowPinEnd')) === null || _c === void 0 ? void 0 : _c.size));
+    }
+    hasAnyRowStyles() {
+        var _a, _b, _c;
+        return (!!((_a = this.rowStyleIds.get('highlight')) === null || _a === void 0 ? void 0 : _a.size) ||
+            !!((_b = this.rowStyleIds.get('background')) === null || _b === void 0 ? void 0 : _b.size) ||
+            !!((_c = this.rowStyleIds.get('focused')) === null || _c === void 0 ? void 0 : _c.size));
+    }
+    getRowStyleFlags(rowType, physicalIndex) {
+        var _a, _b, _c, _d;
+        const source = (_a = this.providers.data.stores[rowType]) === null || _a === void 0 ? void 0 : _a.store.get('source');
+        const rowData = source === null || source === void 0 ? void 0 : source[physicalIndex];
+        if (!rowData) {
+            return {
+                highlighted: false,
+                background: false,
+                focused: false,
+            };
+        }
+        const id = rowData[this.highlightIdField];
+        if (id === undefined || id === null) {
+            return {
+                highlighted: false,
+                background: false,
+                focused: false,
+            };
+        }
+        return {
+            highlighted: !!((_b = this.rowStyleIds.get('highlight')) === null || _b === void 0 ? void 0 : _b.has(id)),
+            background: !!((_c = this.rowStyleIds.get('background')) === null || _c === void 0 ? void 0 : _c.has(id)),
+            focused: !!((_d = this.rowStyleIds.get('focused')) === null || _d === void 0 ? void 0 : _d.has(id)),
+        };
+    }
+    applyRowStyleFlagsToAttrs(attrs, flags) {
+        const setFlag = (attrName, enabled) => {
+            if (enabled) {
+                attrs[attrName] = 'true';
+                return;
+            }
+            if (attrName in attrs) {
+                delete attrs[attrName];
+            }
+        };
+        setFlag('data-highlighted', flags.highlighted);
+        setFlag('data-row-bg', flags.background);
+        setFlag('data-focused', flags.focused);
+    }
+    /**
+     * 判断是否为复选框列
+     */
+    isCheckboxColumn(column) {
+        var _a;
+        if (column.columnType && ((_a = this.revogrid.columnTypes) === null || _a === void 0 ? void 0 : _a[column.columnType]) instanceof CheckboxCellType) {
+            return true;
+        }
+        return !!column.rowSelect;
+    }
+    /**
+     * 获取选中状态统计
+     */
+    getSelectionStatus() {
+        let isAllSelected = true;
+        let hasAnySelected = false;
+        let visibleSelectedCount = 0;
+        let totalSelectedCount = 0;
+        let totalRowCount = 0;
+        this.selected.forEach((selectedSet, rowType) => {
+            totalSelectedCount += selectedSet.size;
+            const dataStore = this.providers.data.stores[rowType];
+            const source = dataStore.store.get('source');
+            // 使用 proxyItems（所有行，包括折叠的）来计算全选状态
+            const proxyItems = dataStore.store.get('proxyItems');
+            const items = dataStore.store.get('items');
+            // 计算所有数据行（排除分组行）
+            proxyItems.forEach((itemIndex) => {
+                const rowData = source[itemIndex];
+                // 跳过分组行（分组行有 __rvgr-depth 标记）
+                if (rowData && rowData['__rvgr-depth'] !== undefined) {
+                    return;
+                }
+                totalRowCount++;
+                if (selectedSet.has(itemIndex)) {
+                    hasAnySelected = true;
+                }
+                else {
+                    isAllSelected = false;
+                }
+            });
+            // 计算可见的选中行数
+            items.forEach((itemIndex) => {
+                const rowData = source[itemIndex];
+                if (rowData && rowData['__rvgr-depth'] !== undefined) {
+                    return;
+                }
+                if (selectedSet.has(itemIndex)) {
+                    visibleSelectedCount++;
+                }
+            });
+        });
+        // 如果没有数据行，则不应该显示为全选状态
+        if (totalRowCount === 0) {
+            isAllSelected = false;
+        }
+        return {
+            isSelected: isAllSelected,
+            anySelected: hasAnySelected,
+            visibleSelectedItems: visibleSelectedCount,
+            allSelectedItems: totalSelectedCount,
+            hasData: totalRowCount > 0,
+        };
+    }
+    /**
+     * 发出选中状态变化事件
+     */
+    emitSelectionChange() {
+        const status = this.getSelectionStatus();
+        const detail = {
+            selected: this.selected,
+            count: status.allSelectedItems,
+            allRowsCount: ROW_TYPES.reduce((total, type) => total + this.providers.data.stores[type].store.get('proxyItems').length, 0),
+            visibleCount: status.visibleSelectedItems,
+            visibleRowsCount: ROW_TYPES.reduce((total, type) => total + this.providers.data.stores[type].store.get('items').length, 0),
+        };
+        this.emit(ROW_SELECTED_EVENT, detail);
+    }
+    /**
+     * 刷新视口以更新 UI
+     */
+    refreshViewports() {
+        // 更新 revo-grid 元素的 data-selected-rows 属性
+        const selectedIndices = [];
+        this.selected.forEach((selectedSet) => {
+            selectedSet.forEach((index) => selectedIndices.push(index));
+        });
+        this.revogrid.setAttribute('data-selected-rows', JSON.stringify(selectedIndices));
+        // 刷新列视口
+        VIEWPORT_TYPES.forEach((viewportType) => {
+            const { store } = this.providers.viewport.stores[viewportType];
+            store.set('items', [...store.get('items')]);
+        });
+        // 刷新 grouping-overlay 组件
+        const groupingOverlays = this.revogrid.querySelectorAll('revogr-grouping-overlay');
+        groupingOverlays.forEach((overlay) => {
+            if (overlay.refresh) {
+                overlay.refresh();
+            }
+        });
+        // 刷新后在下一帧同步样式和选中状态，避免 setTimeout 带来的“慢一拍”视觉延迟
+        if (this.postRefreshSyncRaf !== null) {
+            cancelAnimationFrame(this.postRefreshSyncRaf);
+        }
+        this.postRefreshSyncRaf = requestAnimationFrame(() => {
+            this.postRefreshSyncRaf = null;
+            // 重新应用行样式
+            this.rowStyleIds.forEach((styleSet, type) => {
+                if (styleSet.size > 0) {
+                    this.updateRowStyleAttribute(type, this.highlightIdField);
+                }
+            });
+            // 重新应用选中状态到DOM元素
+            this.updateSelectedAttributes();
+        });
+    }
+    markViewportScrolling() {
+        this.viewportScrolling = true;
+        this.hoverInteractionSuspended = true;
+        this.setHoverSuspendedClass(true);
+        this.hoverSyncProcessing = false;
+        this.clearAllHoverClass();
+        if (this.hoverResyncTimer) {
+            clearTimeout(this.hoverResyncTimer);
+            this.hoverResyncTimer = null;
+        }
+        if (this.hoverResyncRaf !== null) {
+            cancelAnimationFrame(this.hoverResyncRaf);
+            this.hoverResyncRaf = null;
+        }
+        if (this.viewportScrollIdleTimer) {
+            clearTimeout(this.viewportScrollIdleTimer);
+        }
+        this.viewportScrollIdleTimer = setTimeout(() => {
+            this.viewportScrollIdleTimer = null;
+            this.viewportScrolling = false;
+            this.hoverInteractionSuspended = false;
+            this.setHoverSuspendedClass(false);
+            if (this.pendingWheelSelectionSyncAfterScroll) {
+                this.pendingWheelSelectionSyncAfterScroll = false;
+                this.queueWheelRowSelectionSync(true);
+            }
+            if (this.hoverSyncEnabled && this.hoverLastPointer) {
+                this.queueHoverResync();
+            }
+        }, VIEWPORT_SCROLL_IDLE_DELAY);
+    }
+    queueWheelRowSelectionSync(force = false) {
+        const now = performance.now();
+        if (!force &&
+            this.viewportScrolling &&
+            now - this.lastWheelSelectionSyncAt < WHEEL_SELECTION_SYNC_INTERVAL_ACTIVE) {
+            this.pendingWheelSelectionSyncAfterScroll = true;
+            return;
+        }
+        if (this.wheelRowSelectionSyncRaf !== null) {
+            if (this.viewportScrolling) {
+                this.pendingWheelSelectionSyncAfterScroll = true;
+            }
+            return;
+        }
+        this.wheelRowSelectionSyncRaf = requestAnimationFrame(() => {
+            this.wheelRowSelectionSyncRaf = null;
+            this.lastWheelSelectionSyncAt = performance.now();
+            this.updateWheelCaptureSelectedAttributes();
+        });
+    }
+    updateWheelCaptureSelectedAttributes() {
+        const wheelRows = this.revogrid.querySelectorAll('.wheel-capture-row[data-rgRow]');
+        if (!wheelRows.length) {
+            return;
+        }
+        const hasSelectedRows = this.hasAnySelectedRows();
+        const hasRowStyles = this.hasAnyRowStyles();
+        if (!hasSelectedRows && !hasRowStyles) {
+            wheelRows.forEach((el) => {
+                if (el.hasAttribute(SELECTED_ATTRIBUTE)) {
+                    el.removeAttribute(SELECTED_ATTRIBUTE);
+                }
+                if (el.hasAttribute('data-highlighted')) {
+                    el.removeAttribute('data-highlighted');
+                }
+                if (el.hasAttribute('data-row-bg')) {
+                    el.removeAttribute('data-row-bg');
+                }
+                if (el.hasAttribute('data-focused')) {
+                    el.removeAttribute('data-focused');
+                }
+            });
+            return;
+        }
+        const rgItems = this.providers.data.stores.rgRow.store.get('items');
+        const rgSource = this.providers.data.stores.rgRow.store.get('source');
+        const rgSelected = this.selected.get('rgRow');
+        const highlightStyleSet = this.rowStyleIds.get('highlight');
+        const backgroundStyleSet = this.rowStyleIds.get('background');
+        const focusedStyleSet = this.rowStyleIds.get('focused');
+        const hasHighlightRows = !!(highlightStyleSet === null || highlightStyleSet === void 0 ? void 0 : highlightStyleSet.size);
+        const hasBackgroundRows = !!(backgroundStyleSet === null || backgroundStyleSet === void 0 ? void 0 : backgroundStyleSet.size);
+        const hasFocusedRows = !!(focusedStyleSet === null || focusedStyleSet === void 0 ? void 0 : focusedStyleSet.size);
+        const shouldResolveRowId = hasHighlightRows || hasBackgroundRows || hasFocusedRows;
+        wheelRows.forEach((el) => {
+            const virtualAttr = el.getAttribute('data-rgRow');
+            if (virtualAttr === null) {
+                return;
+            }
+            const virtualIndex = Number(virtualAttr);
+            if (Number.isNaN(virtualIndex)) {
+                return;
+            }
+            const physicalIndex = rgItems[virtualIndex];
+            const isSelected = physicalIndex !== undefined && !!(rgSelected === null || rgSelected === void 0 ? void 0 : rgSelected.has(physicalIndex));
+            const hasSelectedAttr = el.hasAttribute(SELECTED_ATTRIBUTE);
+            let rowId = undefined;
+            if (shouldResolveRowId && physicalIndex !== undefined) {
+                const rowData = rgSource[physicalIndex];
+                rowId = rowData ? rowData[this.highlightIdField] : undefined;
+            }
+            if (isSelected && !hasSelectedAttr) {
+                el.setAttribute(SELECTED_ATTRIBUTE, 'true');
+            }
+            else if (!isSelected && hasSelectedAttr) {
+                el.removeAttribute(SELECTED_ATTRIBUTE);
+            }
+            if (hasHighlightRows) {
+                const highlighted = rowId !== undefined && rowId !== null && !!(highlightStyleSet === null || highlightStyleSet === void 0 ? void 0 : highlightStyleSet.has(rowId));
+                if (highlighted) {
+                    el.setAttribute('data-highlighted', 'true');
+                }
+                else if (el.hasAttribute('data-highlighted')) {
+                    el.removeAttribute('data-highlighted');
+                }
+            }
+            else if (el.hasAttribute('data-highlighted')) {
+                el.removeAttribute('data-highlighted');
+            }
+            if (hasBackgroundRows) {
+                const background = rowId !== undefined && rowId !== null && !!(backgroundStyleSet === null || backgroundStyleSet === void 0 ? void 0 : backgroundStyleSet.has(rowId));
+                if (background) {
+                    el.setAttribute('data-row-bg', 'true');
+                }
+                else if (el.hasAttribute('data-row-bg')) {
+                    el.removeAttribute('data-row-bg');
+                }
+            }
+            else if (el.hasAttribute('data-row-bg')) {
+                el.removeAttribute('data-row-bg');
+            }
+            if (hasFocusedRows) {
+                const focused = rowId !== undefined && rowId !== null && !!(focusedStyleSet === null || focusedStyleSet === void 0 ? void 0 : focusedStyleSet.has(rowId));
+                if (focused) {
+                    el.setAttribute('data-focused', 'true');
+                }
+                else if (el.hasAttribute('data-focused')) {
+                    el.removeAttribute('data-focused');
+                }
+            }
+            else if (el.hasAttribute('data-focused')) {
+                el.removeAttribute('data-focused');
+            }
+        });
+    }
+    /**
+     * 更新所有行的选中属性
+     * 用于确保展开分组后，之前被折叠的行也能正确显示选中状态
+     */
+    updateSelectedAttributes() {
+        const rowElements = this.revogrid.querySelectorAll('.rgRow[data-rgRow]');
+        rowElements.forEach((el) => {
+            var _a;
+            const row = el;
+            const rowType = this.getRowTypeFromElement(row);
+            if (!rowType) {
+                return;
+            }
+            const physicalIndex = this.getPhysicalIndexFromRow(row, rowType);
+            if (physicalIndex === null) {
+                return;
+            }
+            const isSelected = !!((_a = this.selected.get(rowType)) === null || _a === void 0 ? void 0 : _a.has(physicalIndex));
+            if (isSelected) {
+                row.setAttribute(SELECTED_ATTRIBUTE, 'true');
+            }
+            else {
+                row.removeAttribute(SELECTED_ATTRIBUTE);
+            }
+        });
+        this.updateWheelCaptureSelectedAttributes();
+    }
+    /**
+     * 创建列头模板
+     */
+    createHeaderTemplate(columnData) {
+        const originalTemplate = columnData.columnTemplate;
+        const checkboxTemplate = this.checkboxCellType.columnTemplate;
+        const customTemplate = this.customHeaderCheckboxTemplate;
+        return (h, props, additionalData) => {
+            const status = this.getSelectionStatus();
+            // 如果有自定义模板，使用自定义模板
+            if (customTemplate) {
+                return customTemplate(h, {
+                    allSelected: status.isSelected,
+                    indeterminate: status.anySelected && !status.isSelected,
+                    onClick: (event) => {
+                        event.preventDefault();
+                        const detail = {
+                            type: props.providers.type,
+                            selected: !status.isSelected,
+                        };
+                        dispatchCustomEvent(event, ROW_ALL_SELECT_EVENT, detail);
+                    },
+                    // 传递完整的 props 和 additionalData，方便 Vue 组件使用
+                    props,
+                    additionalData,
+                });
+            }
+            const extendedProps = Object.assign(Object.assign({}, props), { allSelected: status.isSelected, allIndeterminate: status.anySelected });
+            if (originalTemplate) {
+                return originalTemplate(h, extendedProps, additionalData);
+            }
+            return checkboxTemplate(h, extendedProps);
+        };
+    }
+    /**
+     * 创建单元格复选框模板
+     */
+    createCellCheckboxTemplate() {
+        const defaultTemplate = this.checkboxCellType.cellTemplate;
+        const customTemplate = this.customCheckboxTemplate;
+        return (h, props, additionalData) => {
+            // 如果有自定义模板，使用自定义模板
+            if (customTemplate) {
+                return customTemplate(h, {
+                    selected: !!props.selected,
+                    onClick: (event) => {
+                        event.preventDefault();
+                        const detail = Object.assign(Object.assign({}, props), { originalEvent: event });
+                        dispatchCustomEvent(event, ROW_SELECT_CLICK_EVENT, detail);
+                    },
+                    // 传递完整的 props 和 additionalData，方便 Vue 组件使用
+                    props,
+                    additionalData,
+                });
+            }
+            return defaultTemplate(h, props, additionalData);
+        };
+    }
+    /**
+     * 单元格模板包装器 - 注入选中状态
+     */
+    cellTemplateWrapper(_h, props) {
+        var _a;
+        const dataStore = this.providers.data.stores[props.providers.type];
+        const physicalIndex = getPhysicalRowIndex(dataStore.store, props.rowIndex);
+        const isSelected = (_a = this.selected.get(props.type)) === null || _a === void 0 ? void 0 : _a.has(physicalIndex);
+        props.selected = !!isSelected;
+        return '';
+    }
+    destroy() {
+        var _a, _b;
+        (_a = this.cleanupHoverSync) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.cleanupHoverSync = null;
+        if (this.hoverResyncTimer) {
+            clearTimeout(this.hoverResyncTimer);
+            this.hoverResyncTimer = null;
+        }
+        if (this.hoverResyncRaf !== null) {
+            cancelAnimationFrame(this.hoverResyncRaf);
+            this.hoverResyncRaf = null;
+        }
+        if (this.viewportScrollIdleTimer) {
+            clearTimeout(this.viewportScrollIdleTimer);
+            this.viewportScrollIdleTimer = null;
+        }
+        this.hoverInteractionSuspended = false;
+        this.setHoverSuspendedClass(false);
+        this.viewportScrolling = false;
+        this.pendingWheelSelectionSyncAfterScroll = false;
+        this.lastHoverPointerSyncAt = 0;
+        if (this.selectionAttributeSyncRaf !== null) {
+            cancelAnimationFrame(this.selectionAttributeSyncRaf);
+            this.selectionAttributeSyncRaf = null;
+        }
+        if (this.postRefreshSyncRaf !== null) {
+            cancelAnimationFrame(this.postRefreshSyncRaf);
+            this.postRefreshSyncRaf = null;
+        }
+        if (this.wheelRowSelectionSyncRaf !== null) {
+            cancelAnimationFrame(this.wheelRowSelectionSyncRaf);
+            this.wheelRowSelectionSyncRaf = null;
+        }
+        this.pendingSelectionAttributeSync = false;
+        if ((_b = this.styleElement) === null || _b === void 0 ? void 0 : _b.parentNode) {
+            this.styleElement.parentNode.removeChild(this.styleElement);
+        }
+        this.styleElement = undefined;
+        this.selected.clear();
+        super.destroy();
+    }
+}
+//# sourceMappingURL=row-select-plugin-2026228.js.map