balala-revogrid 1.0.0

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

@@ -0,0 +1,2096 @@
+/*!
+ * 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 DEBUG_ROW_HIGHLIGHT_TRACE = false;
+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.pendingSelectionRemapByType = new Map();
+        // 初始化选中集合
+        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();
+        });
+        // 在 source 变更前后基于稳定 ID 重建选中索引，避免索引漂移导致选中错位
+        this.addEventListener('beforesourceset', (event) => {
+            var _a;
+            const rowType = (_a = event.detail) === null || _a === void 0 ? void 0 : _a.type;
+            if (!rowType || !ROW_TYPES.includes(rowType)) {
+                return;
+            }
+            this.capturePendingSelectionRemap(rowType);
+            this.clearAllHoverClass();
+            this.clearWheelCaptureVisualState();
+            this.clearRenderedRowStyleAttributes();
+            this.blockHoverRender();
+            this.pendingSelectionAttributeSync = true;
+        });
+        this.addEventListener('aftersourceset', (event) => {
+            var _a, _b;
+            const rowType = (_a = event.detail) === null || _a === void 0 ? void 0 : _a.type;
+            if (!rowType || !ROW_TYPES.includes(rowType)) {
+                return;
+            }
+            const remapped = this.applyPendingSelectionRemap(rowType, (_b = event.detail) === null || _b === void 0 ? void 0 : _b.source);
+            this.updateSelectedRowsAttribute();
+            this.pendingSelectionAttributeSync = true;
+            this.blockHoverRender();
+            this.queueWheelRowSelectionSync(true);
+            if (remapped) {
+                this.emitSelectionChange();
+            }
+        });
+        // 监听行选择点击事件
+        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;
+            const rowType = detail.rowType;
+            const isRowType = ROW_TYPES.includes(rowType);
+            const virtualIndex = detail.item.itemIndex;
+            const rowStore = isRowType ? this.providers.data.stores[rowType] : undefined;
+            const rowItems = rowStore === null || rowStore === void 0 ? void 0 : rowStore.store.get('items');
+            const physicalIndex = isRowType && Array.isArray(rowItems) ? rowItems[virtualIndex] : undefined;
+            const hasValidPhysicalIndex = Number.isInteger(physicalIndex);
+            const rowId = isRowType && hasValidPhysicalIndex
+                ? this.getRowIdByPhysicalIndex(rowType, physicalIndex, this.highlightIdField)
+                : null;
+            const cleanupStaleAttrs = (attrs) => {
+                const nextAttrs = Object.assign({}, attrs);
+                delete nextAttrs[SELECTED_ATTRIBUTE];
+                delete nextAttrs['data-highlighted'];
+                delete nextAttrs['data-row-bg'];
+                delete nextAttrs['data-focused'];
+                const existingClass = nextAttrs.class;
+                if (typeof existingClass === 'string') {
+                    const nextClass = existingClass
+                        .replace(/\brow-hover-active\b/g, '')
+                        .replace(/\brow-hover-selected-active\b/g, '')
+                        .replace(/\s+/g, ' ')
+                        .trim();
+                    if (nextClass) {
+                        nextAttrs.class = nextClass;
+                    }
+                    else if ('class' in nextAttrs) {
+                        delete nextAttrs.class;
+                    }
+                }
+                else if (existingClass && typeof existingClass === 'object') {
+                    nextAttrs.class = Object.assign(Object.assign({}, existingClass), { [ROW_HOVER_ACTIVE_CLASS]: false, [ROW_HOVER_SELECTED_ACTIVE_CLASS]: false });
+                }
+                return nextAttrs;
+            };
+            const setSelectedAttr = (attrs, isSelected) => {
+                if (isSelected) {
+                    attrs[SELECTED_ATTRIBUTE] = 'true';
+                    return;
+                }
+                if (SELECTED_ATTRIBUTE in attrs) {
+                    delete attrs[SELECTED_ATTRIBUTE];
+                }
+            };
+            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 (isRowType && !hasValidPhysicalIndex) {
+                const prevAttrs = (detail.node.$attrs$ || {});
+                const attrs = cleanupStaleAttrs(detail.node.$attrs$ || {});
+                const hadHighlighted = this.isTruthyRowFlag(prevAttrs['data-highlighted']);
+                detail.node.$attrs$ = attrs;
+                if (hadHighlighted) {
+                    this.logHighlightTrace('beforerowrender.cleanup.invalid-physical-index', {
+                        rowType,
+                        colType: detail.colType,
+                        virtualIndex,
+                        physicalIndex,
+                    });
+                }
+                return;
+            }
+            if (!hasAnySelected && !shouldProcessHoverClass && !hasAnyRowStyle) {
+                if (isRowType) {
+                    const prevAttrs = (detail.node.$attrs$ || {});
+                    const attrs = cleanupStaleAttrs(detail.node.$attrs$ || {});
+                    const hadHighlighted = this.isTruthyRowFlag(prevAttrs['data-highlighted']);
+                    detail.node.$attrs$ = attrs;
+                    if (hadHighlighted) {
+                        this.logHighlightTrace('beforerowrender.cleanup.no-style-state', {
+                            rowType,
+                            colType: detail.colType,
+                            virtualIndex,
+                            physicalIndex,
+                            rowId,
+                        });
+                    }
+                }
+                return;
+            }
+            const resolvedPhysicalIndex = physicalIndex;
+            const styleFlags = hasAnyRowStyle && isRowType
+                ? this.getRowStyleFlags(rowType, resolvedPhysicalIndex)
+                : EMPTY_ROW_STYLE_FLAGS;
+            const syncHoverClass = (attrs) => {
+                const existingClass = attrs.class;
+                if (typeof existingClass === 'string') {
+                    const nextClass = existingClass
+                        .replace(/\brow-hover-active\b/g, '')
+                        .replace(/\brow-hover-selected-active\b/g, '')
+                        .replace(/\s+/g, ' ')
+                        .trim();
+                    attrs.class = nextClass || undefined;
+                    return;
+                }
+                if (existingClass && typeof existingClass === 'object') {
+                    attrs.class = Object.assign(Object.assign({}, existingClass), { [ROW_HOVER_ACTIVE_CLASS]: false, [ROW_HOVER_SELECTED_ACTIVE_CLASS]: false });
+                }
+            };
+            // 处理数据行
+            if (isRowType && detail.colType !== 'rowHeaders') {
+                const prevAttrs = (detail.node.$attrs$ || {});
+                const prevHighlighted = this.isTruthyRowFlag(prevAttrs['data-highlighted']);
+                const isSelected = (_e = this.selected.get(detail.rowType)) === null || _e === void 0 ? void 0 : _e.has(resolvedPhysicalIndex);
+                const attrs = Object.assign({}, detail.node.$attrs$);
+                setSelectedAttr(attrs, !!isSelected);
+                this.applyRowStyleFlagsToAttrs(attrs, styleFlags, {
+                    path: 'beforerowrender.dataRow.flags',
+                    rowType,
+                    colType: detail.colType,
+                    virtualIndex,
+                    physicalIndex: resolvedPhysicalIndex,
+                    rowId,
+                });
+                syncHoverClass(attrs);
+                detail.node.$attrs$ = attrs;
+                const nextHighlighted = this.isTruthyRowFlag(attrs['data-highlighted']);
+                if (prevHighlighted !== nextHighlighted || nextHighlighted) {
+                    this.logHighlightTrace('beforerowrender.dataRow.commit', {
+                        rowType,
+                        colType: detail.colType,
+                        virtualIndex,
+                        physicalIndex: resolvedPhysicalIndex,
+                        rowId,
+                        prevHighlighted,
+                        nextHighlighted,
+                        selected: !!isSelected,
+                    });
+                }
+            }
+            // 处理行号列（rowHeaders）
+            if (detail.colType === 'rowHeaders') {
+                // 行号列的行索引与数据行相同
+                const rowType = detail.rowType;
+                if (ROW_TYPES.includes(rowType)) {
+                    const prevAttrs = (detail.node.$attrs$ || {});
+                    const prevHighlighted = this.isTruthyRowFlag(prevAttrs['data-highlighted']);
+                    const rowId = this.getRowIdByPhysicalIndex(rowType, resolvedPhysicalIndex, this.highlightIdField);
+                    const isSelected = (_f = this.selected.get(rowType)) === null || _f === void 0 ? void 0 : _f.has(resolvedPhysicalIndex);
+                    const attrs = Object.assign({}, detail.node.$attrs$);
+                    setSelectedAttr(attrs, !!isSelected);
+                    this.applyRowStyleFlagsToAttrs(attrs, styleFlags, {
+                        path: 'beforerowrender.rowHeaders.flags',
+                        rowType,
+                        colType: detail.colType,
+                        virtualIndex,
+                        physicalIndex: resolvedPhysicalIndex,
+                        rowId,
+                    });
+                    syncHoverClass(attrs);
+                    detail.node.$attrs$ = attrs;
+                    const nextHighlighted = this.isTruthyRowFlag(attrs['data-highlighted']);
+                    if (prevHighlighted !== nextHighlighted || nextHighlighted) {
+                        this.logHighlightTrace('beforerowrender.rowHeaders.commit', {
+                            rowType,
+                            colType: detail.colType,
+                            virtualIndex,
+                            physicalIndex: resolvedPhysicalIndex,
+                            rowId,
+                            prevHighlighted,
+                            nextHighlighted,
+                            selected: !!isSelected,
+                        });
+                    }
+                }
+            }
+        });
+        // 监听树形行选择事件
+        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.clearAllHoverClass();
+            this.clearWheelCaptureVisualState();
+            this.clearRenderedRowStyleAttributes();
+            this.blockHoverRender();
+            this.pendingSelectionAttributeSync = true;
+        });
+        // 监听树形节点展开/折叠事件，更新选中状态显示
+        this.addEventListener('treenodetoggle', () => {
+            this.clearAllHoverClass();
+            this.clearWheelCaptureVisualState();
+            this.clearRenderedRowStyleAttributes();
+            this.blockHoverRender();
+            this.pendingSelectionAttributeSync = true;
+        });
+        // 树形/分组 trimmed 变更期间强制清理 hover，避免频繁展开收起后残留多行 hover
+        this.addEventListener('beforetrimmed', (event) => {
+            var _a, _b;
+            const trimmedType = (_a = event.detail) === null || _a === void 0 ? void 0 : _a.trimmedType;
+            const rowType = (_b = event.detail) === null || _b === void 0 ? void 0 : _b.type;
+            if (rowType && rowType !== 'rgRow') {
+                return;
+            }
+            if (trimmedType !== 'tree-collapsed' && trimmedType !== 'grouping') {
+                return;
+            }
+            this.clearAllHoverClass();
+            this.blockHoverRender();
+        });
+    }
+    // ==================== 公共方法 ====================
+    /**
+     * 获取所有选中行的索引
+     */
+    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;
+        const styleIdField = idField || this.highlightIdField;
+        if (type === 'highlight') {
+            this.logHighlightTrace('applyRowStyle.input', {
+                type,
+                ids,
+                idField: styleIdField,
+                beforeSize: styleSet.size,
+            });
+        }
+        if (type === 'focused') {
+            styleSet.clear();
+            const firstId = ids[0];
+            if (firstId !== undefined && firstId !== null) {
+                styleSet.add(firstId);
+            }
+            this.updateRowStyleAttribute(type, styleIdField);
+            return;
+        }
+        ids.forEach((id) => styleSet.add(id));
+        if (type === 'highlight') {
+            this.logHighlightTrace('applyRowStyle.after-set', {
+                type,
+                ids,
+                idField: styleIdField,
+                afterSize: styleSet.size,
+                highlightedIds: Array.from(styleSet),
+            });
+        }
+        this.updateRowStyleAttribute(type, styleIdField);
+    }
+    /**
+     * 移除指定行的样式
+     * @param type 样式类型：'highlight' 或 'background'
+     * @param ids 行的 ID 值数组，如果不传则移除该类型所有行的样式
+     * @param idField 可选，ID 字段名，默认使用配置的 highlightIdField
+     */
+    removeRowStyle(type, ids, idField) {
+        const styleSet = this.rowStyleIds.get(type);
+        if (!styleSet)
+            return;
+        const styleIdField = idField || this.highlightIdField;
+        if (type === 'highlight') {
+            this.logHighlightTrace('removeRowStyle.input', {
+                type,
+                ids,
+                idField: styleIdField,
+                beforeSize: styleSet.size,
+            });
+        }
+        if (ids) {
+            ids.forEach((id) => styleSet.delete(id));
+        }
+        else {
+            styleSet.clear();
+        }
+        if (type === 'highlight') {
+            this.logHighlightTrace('removeRowStyle.after-set', {
+                type,
+                ids,
+                idField: styleIdField,
+                afterSize: styleSet.size,
+                highlightedIds: Array.from(styleSet),
+            });
+        }
+        this.updateRowStyleAttribute(type, styleIdField);
+    }
+    /**
+     * 清除指定类型的所有行样式
+     * @param type 样式类型：'highlight' 或 'background'
+     */
+    clearRowStyle(type) {
+        const styleSet = this.rowStyleIds.get(type);
+        if (!styleSet)
+            return;
+        if (type === 'highlight') {
+            this.logHighlightTrace('clearRowStyle.input', {
+                type,
+                beforeSize: styleSet.size,
+                highlightedIds: Array.from(styleSet),
+            });
+        }
+        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=''] {
+          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'] {
+          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'] {
+          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='true']):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='true']):not([selected='']):not([data-focused='true']) {
+          background-color: var(--revo-row-hover-bg) !important;
+        }
+        revo-grid .wheel-capture-row.row-hover-active:not([selected='true']):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='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='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='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}"]`,
+            `.wheel-capture-row[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;
+    }
+    clearAllHoverClass() {
+        const allHoverRows = this.revogrid.querySelectorAll(`.rgRow.${ROW_HOVER_ACTIVE_CLASS}, .rgRow.${ROW_HOVER_SELECTED_ACTIVE_CLASS}, .wheel-capture-row.${ROW_HOVER_ACTIVE_CLASS}, .wheel-capture-row.${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;
+    }
+    clearWheelCaptureVisualState() {
+        const wheelRows = this.revogrid.querySelectorAll('.wheel-capture-row');
+        wheelRows.forEach((el) => {
+            el.classList.remove(ROW_HOVER_ACTIVE_CLASS);
+            el.classList.remove(ROW_HOVER_SELECTED_ACTIVE_CLASS);
+            this.clearWheelCaptureSelectionState(el);
+        });
+    }
+    clearWheelCaptureSelectionState(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');
+        }
+    }
+    clearRenderedRowStyleAttributes() {
+        const attrNames = ['data-highlighted', 'data-row-bg', 'data-focused'];
+        attrNames.forEach((attrName) => {
+            const styledRows = this.revogrid.querySelectorAll(`[${attrName}="true"]`);
+            styledRows.forEach((el) => el.removeAttribute(attrName));
+        });
+    }
+    normalizeHoverClasses(expectedType, expectedPhysicalIndex) {
+        this.clearAllHoverClass();
+        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) {
+            this.normalizeHoverClasses(null, 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;
+        }
+        // 收敛为单一路径：先清空全部 hover，再应用当前目标，避免旧节点残留
+        this.normalizeHoverClasses(rowType, physicalIndex);
+    }
+    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();
+            if (this.hasAnyRowStyles()) {
+                this.rowStyleIds.forEach((styleSet, type) => {
+                    if (styleSet.size > 0) {
+                        this.updateRowStyleAttribute(type, this.highlightIdField);
+                    }
+                });
+            }
+            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;
+    }
+    isTruthyRowFlag(value) {
+        return value === '' || value === true || value === 'true';
+    }
+    getRowIdByPhysicalIndex(rowType, physicalIndex, idField) {
+        var _a;
+        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];
+        return rowData ? rowData[idField] : null;
+    }
+    logHighlightTrace(event, payload) {
+        if (!DEBUG_ROW_HIGHLIGHT_TRACE) {
+            return;
+        }
+        console.log('[RowSelectPlugin][highlight]', event, payload);
+    }
+    /**
+     * 更新行样式属性
+     */
+    updateRowStyleAttribute(type, idField) {
+        if (type === 'highlight') {
+            this.logHighlightTrace('updateRowStyleAttribute.start', {
+                type,
+                idField,
+                highlightIds: Array.from(this.rowStyleIds.get(type) || []),
+            });
+        }
+        // 先清除该类型的所有样式
+        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';
+        // 基于当前已渲染行反查 physicalIndex 与 rowData，避免虚拟索引切换窗口期误写导致闪烁
+        const renderedRows = this.revogrid.querySelectorAll('.rgRow[data-rgRow]');
+        renderedRows.forEach((el) => {
+            const rowEl = el;
+            const rowType = this.getRowTypeFromElement(rowEl);
+            if (!rowType) {
+                return;
+            }
+            const dataStore = this.providers.data.stores[rowType];
+            if (!dataStore) {
+                return;
+            }
+            const physicalIndex = this.getPhysicalIndexFromRow(rowEl, rowType);
+            if (physicalIndex === null) {
+                return;
+            }
+            const source = dataStore.store.get('source');
+            const rowData = source === null || source === void 0 ? void 0 : source[physicalIndex];
+            if (!rowData) {
+                return;
+            }
+            const rowId = rowData[idField];
+            if (rowId === undefined || rowId === null) {
+                return;
+            }
+            if (styleSet.has(rowId)) {
+                const prevValue = rowEl.getAttribute(attrName);
+                rowEl.setAttribute(attrName, 'true');
+                if (type === 'highlight') {
+                    this.logHighlightTrace('updateRowStyleAttribute.set-row-attr', {
+                        attrName,
+                        rowType,
+                        virtualIndex: rowEl.getAttribute('data-rgRow'),
+                        physicalIndex,
+                        rowId,
+                        prevValue,
+                        nextValue: 'true',
+                    });
+                }
+            }
+        });
+        // 更新 revo-grid 元素的属性
+        if (type === 'highlight') {
+            this.revogrid.setAttribute('data-highlighted-rows', JSON.stringify(Array.from(styleSet)));
+            this.logHighlightTrace('updateRowStyleAttribute.set-grid-attr', {
+                attrName: 'data-highlighted-rows',
+                highlightIds: 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"]`);
+        if (type === 'highlight') {
+            this.logHighlightTrace('clearRowStyleAttribute.start', {
+                attrName,
+                rowCount: styledRows.length,
+            });
+        }
+        styledRows.forEach((el) => {
+            if (type === 'highlight') {
+                const row = el;
+                const rowType = this.getRowTypeFromElement(row);
+                const physicalIndex = rowType ? this.getPhysicalIndexFromRow(row, rowType) : null;
+                const rowId = rowType && physicalIndex !== null
+                    ? this.getRowIdByPhysicalIndex(rowType, physicalIndex, this.highlightIdField)
+                    : null;
+                this.logHighlightTrace('clearRowStyleAttribute.remove-row-attr', {
+                    attrName,
+                    rowType,
+                    virtualIndex: row.getAttribute('data-rgRow'),
+                    physicalIndex,
+                    rowId,
+                });
+            }
+            el.removeAttribute(attrName);
+        });
+        // 移除 revo-grid 元素的属性
+        if (type === 'highlight') {
+            this.revogrid.removeAttribute('data-highlighted-rows');
+            this.logHighlightTrace('clearRowStyleAttribute.remove-grid-attr', {
+                attrName: '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, context) {
+        const prevHighlighted = this.isTruthyRowFlag(attrs['data-highlighted']);
+        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);
+        const nextHighlighted = this.isTruthyRowFlag(attrs['data-highlighted']);
+        if (prevHighlighted !== nextHighlighted || nextHighlighted) {
+            this.logHighlightTrace('applyRowStyleFlagsToAttrs', Object.assign(Object.assign({}, context), { flags,
+                prevHighlighted,
+                nextHighlighted }));
+        }
+    }
+    /**
+     * 判断是否为复选框列
+     */
+    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
+     */
+    updateSelectedRowsAttribute() {
+        var _a;
+        const selectedIndices = [];
+        const rgSelectedIndices = [];
+        this.selected.forEach((selectedSet) => {
+            selectedSet.forEach((index) => selectedIndices.push(index));
+        });
+        (_a = this.selected.get('rgRow')) === null || _a === void 0 ? void 0 : _a.forEach((index) => rgSelectedIndices.push(index));
+        this.revogrid.setAttribute('data-selected-rows', JSON.stringify(selectedIndices));
+        this.revogrid.setAttribute('data-selected-rg-rows', JSON.stringify(rgSelectedIndices));
+    }
+    getSelectionKeyField(rowType) {
+        var _a;
+        if (rowType === 'rgRow' && ((_a = this.treeConfig) === null || _a === void 0 ? void 0 : _a.idField)) {
+            return this.treeConfig.idField;
+        }
+        return this.highlightIdField;
+    }
+    isGroupingRowData(row) {
+        return !!row && row['__rvgr-depth'] !== undefined;
+    }
+    capturePendingSelectionRemap(rowType) {
+        var _a;
+        const selectedSet = this.selected.get(rowType);
+        if (!selectedSet || selectedSet.size === 0) {
+            this.pendingSelectionRemapByType.delete(rowType);
+            return;
+        }
+        const keyField = this.getSelectionKeyField(rowType);
+        const source = (_a = this.providers.data.stores[rowType]) === null || _a === void 0 ? void 0 : _a.store.get('source');
+        if (!(source === null || source === void 0 ? void 0 : source.length)) {
+            this.pendingSelectionRemapByType.delete(rowType);
+            return;
+        }
+        const keys = [];
+        const rows = [];
+        selectedSet.forEach((physicalIndex) => {
+            const row = source[physicalIndex];
+            if (!row || this.isGroupingRowData(row)) {
+                return;
+            }
+            rows.push(row);
+            const key = row[keyField];
+            if (key === undefined || key === null) {
+                return;
+            }
+            keys.push(key);
+        });
+        if (!keys.length && !rows.length) {
+            this.pendingSelectionRemapByType.delete(rowType);
+            return;
+        }
+        this.pendingSelectionRemapByType.set(rowType, {
+            keyField,
+            keys: Array.from(new Set(keys)),
+            rows,
+        });
+    }
+    applyPendingSelectionRemap(rowType, nextSource) {
+        var _a, _b, _c;
+        const pending = this.pendingSelectionRemapByType.get(rowType);
+        this.pendingSelectionRemapByType.delete(rowType);
+        if (!pending || (!((_a = pending.keys) === null || _a === void 0 ? void 0 : _a.length) && !((_b = pending.rows) === null || _b === void 0 ? void 0 : _b.length))) {
+            return false;
+        }
+        const selectedSet = this.selected.get(rowType);
+        if (!selectedSet) {
+            return false;
+        }
+        const source = nextSource ||
+            ((_c = this.providers.data.stores[rowType]) === null || _c === void 0 ? void 0 : _c.store.get('source')) ||
+            [];
+        if (!source.length) {
+            selectedSet.clear();
+            this.lastSelectedIndex = undefined;
+            return true;
+        }
+        const duplicateKeys = new Set();
+        const keyToPhysicalIndex = new Map();
+        const rowToPhysicalIndex = new Map();
+        source.forEach((row, physicalIndex) => {
+            if (!row || this.isGroupingRowData(row)) {
+                return;
+            }
+            rowToPhysicalIndex.set(row, physicalIndex);
+            const key = row[pending.keyField];
+            if (key === undefined || key === null) {
+                return;
+            }
+            if (keyToPhysicalIndex.has(key)) {
+                duplicateKeys.add(key);
+                keyToPhysicalIndex.delete(key);
+                return;
+            }
+            if (!duplicateKeys.has(key)) {
+                keyToPhysicalIndex.set(key, physicalIndex);
+            }
+        });
+        const nextSelected = new Set();
+        pending.rows.forEach((row) => {
+            const physicalIndex = rowToPhysicalIndex.get(row);
+            if (physicalIndex !== undefined) {
+                nextSelected.add(physicalIndex);
+            }
+        });
+        pending.keys.forEach((key) => {
+            if (duplicateKeys.has(key)) {
+                return;
+            }
+            const physicalIndex = keyToPhysicalIndex.get(key);
+            if (physicalIndex !== undefined) {
+                nextSelected.add(physicalIndex);
+            }
+        });
+        selectedSet.clear();
+        nextSelected.forEach((index) => selectedSet.add(index));
+        if (this.lastSelectedIndex !== undefined && !selectedSet.has(this.lastSelectedIndex)) {
+            this.lastSelectedIndex = undefined;
+        }
+        return true;
+    }
+    refreshViewports() {
+        // 更新 revo-grid 元素的 data-selected-rows 属性
+        this.updateSelectedRowsAttribute();
+        // 刷新列视口
+        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) {
+        if (force && !this.viewportScrolling) {
+            this.updateWheelCaptureSelectedAttributes();
+            return;
+        }
+        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');
+        wheelRows.forEach((el) => this.clearWheelCaptureSelectionState(el));
+    }
+    /**
+     * 更新所有行的选中属性
+     * 用于确保展开分组后，之前被折叠的行也能正确显示选中状态
+     */
+    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;
+        this.pendingSelectionRemapByType.clear();
+        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.js.map