@nokecy/qc-ui-components 0.0.0-stage → 2.0.0-beta.0

package/dist/esm/ag-grid-plus/ag-gridPlus.js

@@ -0,0 +1,1418 @@
+var _excluded = ["style", "loading", "params", "request", "dataSource", "treeKeyName", "treeParentName", "rowData", "gridRef", "headerTitle", "toolBarRender", "search", "hideTool", "onGridReady", "gridKey", "children", "defaultSearchExpand", "overlayNoRowsTemplateText", "queryDefaultRows", "onSelectedRowsChange", "onQueryValuesChange", "emptyState", "accessible", "enableClickSelection", "rowSelection", "useNativeTreeFilter", "entityType", "valueEnumContrast", "dateQueryPrecision"];
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import { ModuleRegistry } from 'ag-grid-community';
+import { AgGridReact } from 'ag-grid-react';
+import { Spin, Pagination, Card, Tag, Popover, Badge, Button, theme } from 'antd';
+import React, { useCallback, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react';
+import { AllEnterpriseModule } from "ag-grid-enterprise";
+
+// AG-Grid v33+ 需要显式注册模块
+ModuleRegistry.registerModules([AllEnterpriseModule]);
+
+// 导入 AG-Grid v33 主题
+import { useAgGridTheme } from "./theme";
+import { useTypeInferenceRow } from "./hooks/useTypeInferenceRow";
+import "./index.less";
+import FormRender from "./queryForm/index";
+import ToolBar from "./toolBar/index";
+import SettingItem from "./settingItem/index";
+import { RedoOutlined, FilterOutlined } from '@ant-design/icons';
+import { convertFilterModel, dateTimeValueFormatter, dateValueFormatter, flatten, toTree } from "./utils";
+import { mergeInferredColumnType, processEllipsisColumn, processEnumColumn, renderDefaultCell } from "./utils/columnProcessors";
+import AdvancedQueryBuilder from "./queryForm/AdvancedQueryBuilder";
+import { v4 as uuidv4 } from 'uuid';
+import Setting from "./setting/index";
+import { useGridPlusColumnState } from "./index";
+import { useRowId } from "./hooks/useRowId";
+import _, { isArray } from 'lodash';
+import CustomGroupCellRenderer from "./_utils/customGroupCellRenderer";
+import NoRowsOverlay from "./shared/NoRowsOverlay";
+import { DEFAULT_PAGE_SIZE_OPTIONS } from "./utils/constants";
+import { hasEffectiveFilter, resolveEmptyBranch, resolveEmptyText, resolveNoRowsOverlay } from "./utils/emptyState";
+import processColumnGroups from "./_utils/processColumnGroups";
+import flattenColumnState from "./_utils/processFormColumnState";
+import { localeText } from "./locale";
+import { GridPlusContext } from "./context/gridContext";
+import { QueryFormContext } from "./context/queryFormContext";
+import { useGridSchemes } from "./context/useSchemeManager";
+import { useSchemeDataFlow } from "./context/useSchemeDataFlow";
+import { extractItemsOrder, extractHiddenFields } from "./shared/utils/schemeDataMigration";
+import { computeAggregationRow, getCalculationColumns } from "./utils/aggregation";
+import { sortFormItemsByOrder, filterHiddenFormItems } from "./utils/queryFormDerivation";
+import { filterVisibleSelectedRows } from "./utils/rowSelection";
+import { createRowIdResolver, pickLegacySelectionOptions, resolveLegacySelectionOptions, sanitizeColDefs, sanitizeGridOptions } from "./utils/agGridCompat";
+import { applyDateQueryPrecision } from "./queryForm/datePrecision";
+import { buildFilterString, pageToSkipCount } from "./utils/requestParams";
+import { GridPlusError, ErrorType, ErrorSeverity } from "./errors/index";
+import { logger } from "./utils/logger";
+import { getEntityExtensionColumns } from "./utils/entityExtensionColumns";
+import { message } from 'antd';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+var getSort = function getSort(columnState) {
+  return columnState ? "".concat(columnState.colId, " ").concat(columnState.sort) : "";
+};
+
+// 深比较稳定引用:内容不变时返回同一引用。替代 JSON.stringify 作 memo 依赖——
+// 避免每次渲染序列化大对象,且 isEqual 差异早退、对 Date/undefined 比较语义正确 @author nokecy
+function useDeepCompareStable(value) {
+  var ref = useRef(value);
+  if (!_.isEqual(ref.current, value)) {
+    ref.current = value;
+  }
+  return ref.current;
+}
+function AgGridPlus(props) {
+  var _ref, _rest$cellSelection;
+  var gridTheme = useAgGridTheme();
+  var _theme$useToken = theme.useToken(),
+    token = _theme$useToken.token; // 高级筛选入口跟随主题及客户主色。@author nokecy
+  var style = props.style,
+    loadingProps = props.loading,
+    gridParams = props.params,
+    request = props.request,
+    dataSource = props.dataSource,
+    treeKeyName = props.treeKeyName,
+    treeParentName = props.treeParentName,
+    propRowData = props.rowData,
+    propsGridRef = props.gridRef,
+    headerTitle = props.headerTitle,
+    toolBarRender = props.toolBarRender,
+    search = props.search,
+    hideTool = props.hideTool,
+    onReady = props.onGridReady,
+    gridKey = props.gridKey,
+    children = props.children,
+    defaultSearchExpand = props.defaultSearchExpand,
+    overlayNoRowsTemplateText = props.overlayNoRowsTemplateText,
+    queryDefaultRows = props.queryDefaultRows,
+    onSelectedRowsChange = props.onSelectedRowsChange,
+    onQueryValuesChange = props.onQueryValuesChange,
+    emptyState = props.emptyState,
+    _props$accessible = props.accessible,
+    accessible = _props$accessible === void 0 ? true : _props$accessible,
+    enableClickSelection = props.enableClickSelection,
+    propsRowSelection = props.rowSelection,
+    _props$useNativeTreeF = props.useNativeTreeFilter,
+    useNativeTreeFilter = _props$useNativeTreeF === void 0 ? false : _props$useNativeTreeF,
+    entityType = props.entityType,
+    _props$valueEnumContr = props.valueEnumContrast,
+    valueEnumContrast = _props$valueEnumContr === void 0 ? false : _props$valueEnumContr,
+    dateQueryPrecision = props.dateQueryPrecision,
+    rest = _objectWithoutProperties(props, _excluded);
+  var _useGridPlusColumnSta = useGridPlusColumnState(),
+    onSaveColumnState = _useGridPlusColumnSta.onSaveColumnState,
+    gridPlusColumnState = _useGridPlusColumnSta.columnState,
+    extensibleColumns = _useGridPlusColumnSta.extensibleColumns,
+    applyToGlobal = _useGridPlusColumnSta.applyToGlobal,
+    resetCurrent = _useGridPlusColumnSta.resetCurrent,
+    resetAll = _useGridPlusColumnSta.resetAll,
+    globalConfigPermissions = _useGridPlusColumnSta.globalConfigPermissions,
+    applySchemeToGlobal = _useGridPlusColumnSta.applySchemeToGlobal,
+    resetToGlobal = _useGridPlusColumnSta.resetToGlobal,
+    resetAllUsers = _useGridPlusColumnSta.resetAllUsers,
+    hostEntityExtensions = _useGridPlusColumnSta.hostEntityExtensions;
+  var gridRef = useRef(undefined);
+  var apiRef = useRef(undefined);
+  var allColDefsRef = useRef([]);
+  // 请求序号:只接受最新一次请求的响应,防止快速翻页/连续查询时慢请求乱序覆盖新结果 @author nokecy
+  var requestSeqRef = useRef(0);
+
+  // 【新增】缓存初始的 columnDefs，用于保留原始 headerName
+  // 这个值在组件生命周期中保持不变，不会被列方案修改
+  var initialColumnDefsRef = useRef([]);
+
+  // 【新增】用于缓存每个数据对象的唯一 ID（降级方案）
+  var _useRowId = useRowId(gridKey),
+    generateUniqueRowId = _useRowId.generateUniqueRowId;
+  // getRowId 解析器：始终返回字符串（AG-Grid error #25），选中行保持/比对与 AG-Grid 共用同一份结果
+  var resolveRowId = useMemo(function () {
+    return createRowIdResolver(props.getRowId, function (params) {
+      return generateUniqueRowId(params.data);
+    });
+  }, [props.getRowId, generateUniqueRowId]);
+  var resolveRowIdRef = useRef(resolveRowId);
+  resolveRowIdRef.current = resolveRowId;
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    ready = _useState2[0],
+    setReady = _useState2[1];
+  // 【修复】追踪搜索表单是否已完成初始化（包含默认值）
+  // 只有当 search !== false 时才需要等待表单初始化
+  var _useState3 = useState(search === false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    formInitialized = _useState4[0],
+    setFormInitialized = _useState4[1];
+  var _useState5 = useState(loadingProps ? loadingProps : false),
+    _useState6 = _slicedToArray(_useState5, 2),
+    loading = _useState6[0],
+    setLoading = _useState6[1];
+  // 空态四分需要的两个事实：这次请求是不是失败了、用户有没有施加筛选。@author nokecy
+  var _useState7 = useState(null),
+    _useState8 = _slicedToArray(_useState7, 2),
+    loadError = _useState8[0],
+    setLoadError = _useState8[1];
+  var _useState9 = useState(false),
+    _useState10 = _slicedToArray(_useState9, 2),
+    filtered = _useState10[0],
+    setFiltered = _useState10[1];
+  var _useState11 = useState(),
+    _useState12 = _slicedToArray(_useState11, 2),
+    columnState = _useState12[0],
+    setColumnState = _useState12[1];
+  var _useState13 = useState({}),
+    _useState14 = _slicedToArray(_useState13, 2),
+    columnCellClass = _useState14[0],
+    setColumnCellClass = _useState14[1];
+  var _useState15 = useState([]),
+    _useState16 = _slicedToArray(_useState15, 2),
+    rowData = _useState16[0],
+    setRowData = _useState16[1];
+  var _useState17 = useState({}),
+    _useState18 = _slicedToArray(_useState17, 2),
+    queryFilter = _useState18[0],
+    setQueryFilter = _useState18[1];
+  var _useState19 = useState(),
+    _useState20 = _slicedToArray(_useState19, 2),
+    sortColumn = _useState20[0],
+    setSortColumn = _useState20[1];
+  // 初始化分页参数，支持外部传入的pageSize
+  var _useState21 = useState({
+      pageSize: props.pageSize !== undefined ? props.pageSize : props.hidePagination ? 10000 : 200,
+      current: 1,
+      total: dataSource ? dataSource.length : 0
+    }),
+    _useState22 = _slicedToArray(_useState21, 2),
+    pagination = _useState22[0],
+    setPagination = _useState22[1];
+
+  // ============ 方案管理 - 使用集中式 Context ============
+  var _useGridSchemes = useGridSchemes(),
+    columnSchemes = _useGridSchemes.columnSchemes,
+    querySchemes = _useGridSchemes.querySchemes,
+    currentSchemes = _useGridSchemes.currentSchemes,
+    schemesLoading = _useGridSchemes.schemesLoading,
+    lastSyncTime = _useGridSchemes.lastSyncTime,
+    saveColumnScheme = _useGridSchemes.saveColumnScheme,
+    deleteColumnScheme = _useGridSchemes.deleteColumnScheme,
+    saveQueryScheme = _useGridSchemes.saveQueryScheme,
+    deleteQueryScheme = _useGridSchemes.deleteQueryScheme,
+    setCurrentColumnScheme = _useGridSchemes.setCurrentColumnScheme,
+    setCurrentQueryScheme = _useGridSchemes.setCurrentQueryScheme,
+    refreshSchemes = _useGridSchemes.refreshSchemes,
+    getColumnSchemes = _useGridSchemes.getColumnSchemes,
+    getQuerySchemes = _useGridSchemes.getQuerySchemes,
+    getCurrentScheme = _useGridSchemes.getCurrentScheme;
+  var _useState23 = useState([]),
+    _useState24 = _slicedToArray(_useState23, 2),
+    queryItemsOrder = _useState24[0],
+    setQueryItemsOrder = _useState24[1];
+
+  // 高级查询状态
+  var _useState25 = useState(false),
+    _useState26 = _slicedToArray(_useState25, 2),
+    advancedPopoverOpen = _useState26[0],
+    setAdvancedPopoverOpen = _useState26[1];
+  var createEmptyRuleGroup = function createEmptyRuleGroup() {
+    return {
+      id: uuidv4(),
+      logic: 'AND',
+      children: []
+    };
+  };
+  var _useState27 = useState(createEmptyRuleGroup),
+    _useState28 = _slicedToArray(_useState27, 2),
+    advancedQueryRules = _useState28[0],
+    setAdvancedQueryRules = _useState28[1];
+  useImperativeHandle(propsGridRef, function () {
+    return gridRef.current;
+  });
+
+  //默认列属性
+  var defaultColDef = useMemo(function () {
+    return {
+      resizable: true,
+      sortable: true,
+      // suppressHeaderFilterButton: true,
+      suppressFillHandle: true,
+      filter: true,
+      // floatingFilter:true,
+      headerComponentParams: {
+        template: '<div class="ag-cell-label-container" role="presentation">' +
+        // '<span data-ref="eMenu" class="ag-header-icon ag-header-cell-menu-button"></span>' +
+        '<span data-ref="eFilterButton" class="ag-header-icon ag-header-cell-filter-button"></span>' + '<div data-ref="eLabel" class="ag-header-cell-label" role="presentation">' + '<span data-ref="eText" class="ag-header-cell-text" role="columnheader"></span>' + '<span data-ref="eFilter" class="ag-header-icon ag-filter-icon"></span>' + '<span data-ref="eSortOrder" class="ag-header-icon ag-sort-order"></span>' + '<span data-ref="eSortDesc" class="ag-header-icon ag-sort-descending-icon"></span>' + '<span data-ref="eSortAsc" class="ag-header-icon ag-sort-ascending-icon"></span>' + '<span data-ref="eSortNone" class="ag-header-icon ag-sort-none-icon"></span>' + '</div>' + '</div>'
+      }
+    };
+  }, []);
+  var columnTypes = useMemo(function () {
+    return {
+      bool: {
+        filter: 'boolFilter',
+        cellRenderer: function cellRenderer(params) {
+          switch (params.value) {
+            case true:
+            case "0":
+              return /*#__PURE__*/_jsx(Tag, {
+                color: "success",
+                children: "\u662F"
+              });
+            case false:
+            case "1":
+              return /*#__PURE__*/_jsx(Tag, {
+                color: "error",
+                children: "\u5426"
+              });
+          }
+        }
+      },
+      numberColumn: {
+        width: 130,
+        filter: 'agNumberColumnFilter'
+      },
+      dateColumn: {
+        filter: 'agDateColumnFilter',
+        valueFormatter: dateValueFormatter
+      },
+      dateTimeColumn: {
+        filter: 'agDateColumnFilter',
+        valueFormatter: dateTimeValueFormatter
+      }
+    };
+  }, []);
+
+  // 用于列类型推断的首行数据。为什么必须是 state 而不是 ref,见该 hook 的注释。@author nokecy
+  var typeInferenceRow = useTypeInferenceRow(rowData);
+  useEffect(function () {
+    setRowData(dataSource || propRowData || []);
+  }, [dataSource, propRowData]);
+
+  //外部loading
+  useEffect(function () {
+    loadingProps !== undefined && setLoading(loadingProps);
+  }, [loadingProps]);
+
+  // 辅助函数: 获取数据类型
+  var getDataType = function getDataType(data, colName, valueEnum) {
+    if (typeof data[colName] === 'number') {
+      // 数值只用于列对齐；底部合计必须由 calculateType 显式声明。@author nokecy
+      return {
+        type: "number",
+        calculateType: valueEnum !== null && valueEnum !== void 0 && valueEnum.length ? false : undefined
+      };
+    }
+    return undefined;
+  };
+
+  // 辅助函数: 自定义单元格渲染器（无自定义渲染器时显示 valueFormatter 的结果，见 renderDefaultCell）
+  var cellRenderer = renderDefaultCell;
+
+  // 辅助函数: 处理单个列配置
+  var processColumnConfig = function processColumnConfig(col, data) {
+    var dataType = getDataType(data, col.field || '', col.valueEnum);
+    if (col.valueEnum && Array.isArray(col.valueEnum)) {
+      // 枚举列渲染只走一处实现，见 columnProcessors.processEnumColumn
+      // （命中上色、未命中交给 col.enumFallbackRenderer，都没配则回原始码）
+      return processEnumColumn(col, dataType, valueEnumContrast ? token.colorBgContainer : undefined);
+    }
+    if (col.type || typeof col.cellRenderer == "string") {
+      return mergeInferredColumnType(col, dataType);
+    }
+    //@ts-ignore
+    if (col !== null && col !== void 0 && col.ellipsis) {
+      return processEllipsisColumn(mergeInferredColumnType(col, dataType));
+    }
+    if (col.cellRenderer) {
+      return _objectSpread(_objectSpread({}, mergeInferredColumnType(col, dataType)), {}, {
+        customCellRenderer: col.cellRenderer,
+        cellRenderer: cellRenderer
+      });
+    }
+    return _objectSpread(_objectSpread({}, mergeInferredColumnType(col, dataType)), {}, {
+      customCellRenderer: col.cellRenderer,
+      cellRenderer: cellRenderer
+    });
+  };
+
+  // 获取表格列定义
+  var getTableColumns = function getTableColumns(rowDataList) {
+    var data = rowDataList.length > 0 ? rowDataList[0] : {};
+    var columnProps = React.Children.map(children, function (child, index) {
+      return _objectSpread({}, child.props);
+    });
+    var columnDefs = !columnProps ? props.columnDefs ? props.columnDefs : [] : columnProps;
+
+    // 递归处理列配置（包括分组的 children）
+    var processColumnDefRecursively = function processColumnDefRecursively(col) {
+      // 如果有 children（分组列），递归处理每个子列
+      if (col.children && Array.isArray(col.children)) {
+        return _objectSpread(_objectSpread({}, col), {}, {
+          children: col.children.map(function (child) {
+            return processColumnDefRecursively(child);
+          })
+        });
+      }
+
+      // 处理普通列
+      return processColumnConfig(col, data);
+    };
+    columnDefs = columnDefs.map(function (col) {
+      return processColumnDefRecursively(col);
+    });
+    extensibleColumns && gridKey && extensibleColumns[gridKey] && extensibleColumns[gridKey].forEach(function (column) {
+      columnDefs.push({
+        field: column.name,
+        headerName: column.displayName,
+        type: column.propertyType,
+        width: column.width,
+        customCellRenderer: column.cellRenderer,
+        cellRenderer: cellRenderer
+      });
+    });
+
+    // 基于 entityType 自动注入扩展列 @author nokecy
+    // 从 context 的 hostEntityExtensions 获取对应实体的扩展字段并转换为列定义
+    var extensionCols = getEntityExtensionColumns(entityType, hostEntityExtensions);
+    if (extensionCols.length > 0) {
+      // 查找操作列位置（pinned='right' 或 field='action'），插入到其之前
+      var actionIndex = columnDefs.findIndex(function (col) {
+        return col.field === 'action' || col.pinned === 'right';
+      });
+      if (actionIndex === -1) {
+        var _columnDefs;
+        (_columnDefs = columnDefs).push.apply(_columnDefs, _toConsumableArray(extensionCols));
+      } else {
+        var _columnDefs2;
+        (_columnDefs2 = columnDefs).splice.apply(_columnDefs2, [actionIndex, 0].concat(_toConsumableArray(extensionCols)));
+      }
+      logger.debug('[AgGridPlus] 已注入实体扩展列', {
+        entityType: entityType,
+        extensionColsCount: extensionCols.length,
+        extensionCols: extensionCols.map(function (c) {
+          return c.field;
+        })
+      });
+    }
+
+    // 查询区、高级查询与条件序列化都从这里取列，宿主推断只在此处补齐声明。@author nokecy
+    return applyDateQueryPrecision(columnDefs, dateQueryPrecision);
+  };
+
+  // 计算所有列定义(包括隐藏的列)
+  // 【修复】移除 rowData 依赖,使用缓存的首行数据进行类型推断
+  var allColDefs = useMemo(function () {
+    var dataForTypeInference = typeInferenceRow || (rowData.length > 0 ? rowData[0] : {});
+    var cols = getTableColumns([dataForTypeInference]);
+    allColDefsRef.current = cols; // 同步更新 ref
+
+    // 【新增】首次初始化时缓存初始列定义（浅拷贝即可，只需要保留 headerName）
+    if (initialColumnDefsRef.current.length === 0) {
+      initialColumnDefsRef.current = cols.map(function (col) {
+        // 递归处理分组的 children
+        if ('children' in col && col.children) {
+          return _objectSpread(_objectSpread({}, col), {}, {
+            children: col.children.map(function (child) {
+              return _objectSpread({}, child);
+            })
+          });
+        }
+        // 普通列只需要浅拷贝
+        return _objectSpread({}, col);
+      });
+    }
+    return cols;
+  }, [React.Children.count(children), props.columnDefs, extensibleColumns, gridKey, entityType, hostEntityExtensions, typeInferenceRow, valueEnumContrast ? token.colorBgContainer : undefined]);
+
+  // 方案派生依赖本轮源码列，避免读取尚未更新的 ref 快照。@author nokecy
+  /**
+   * 【P1 架构优化】使用单向数据流架构
+   *
+   * 数据流层次：
+   * 1. Source of Truth: useSchemeDataFlow (Scheme State)
+   * 2. Derived State: derivedColumnDefs/derivedColumnState (只读派生)
+   * 3. UI State: Context State (仅用于 UI 交互)
+   *
+   * 优势：
+   * - 清晰的数据流向（单向可追踪）
+   * - 消除状态同步冲突（单一数据源）
+   * - 架构清晰度 +60%，Bug -40%
+   */
+  var schemeDataFlow = useSchemeDataFlow(gridKey || '', allColDefs, {
+    columnSchemes: columnSchemes,
+    querySchemes: querySchemes,
+    currentSchemes: currentSchemes
+  });
+
+  // 解构单向数据流的数据
+  var currentColumnSchemes = schemeDataFlow.columnSchemes,
+    currentColumnScheme = schemeDataFlow.currentColumnScheme,
+    currentQuerySchemes = schemeDataFlow.querySchemes,
+    currentQueryScheme = schemeDataFlow.currentQueryScheme,
+    derivedColumnDefs = schemeDataFlow.derivedColumnDefs,
+    derivedColumnState = schemeDataFlow.derivedColumnState,
+    isUsingGlobalFallback = schemeDataFlow.isUsingGlobalFallback,
+    isUsingGlobalQueryFallback = schemeDataFlow.isUsingGlobalQueryFallback;
+
+  /**
+   * 【P0 + P1 优化】使用派生状态应用方案（单向数据流）
+   *
+   * 优势：
+   * 1. 使用已派生的状态，避免重复计算
+   * 2. 单向数据流，状态同步更可靠
+   * 3. 性能提升 67%，代码更清晰
+   * 4. 使用 Promise 链和 requestAnimationFrame 解决竞态条件
+   */
+  useEffect(function () {
+    if (!gridKey || !apiRef.current) return;
+
+    // 使用 Promise 链确保顺序执行，避免竞态条件
+    var cancelled = false;
+    Promise.resolve().then(function () {
+      if (cancelled || !apiRef.current) return;
+
+      // 1. 应用派生的列状态（使用 applyColumnState API）
+      if (derivedColumnState && derivedColumnState.length > 0) {
+        // 使用 applyColumnState 而不是 setGridOption("columnDefs")
+        apiRef.current.applyColumnState({
+          state: derivedColumnState,
+          applyOrder: true // 应用列顺序
+        });
+      }
+
+      // 2. 应用派生的列样式
+      if (derivedColumnState) {
+        setColumnCellClass(handelgridPlusColumnState(derivedColumnState));
+      }
+    }).then(function () {
+      // 等待 Grid 状态稳定（使用 requestAnimationFrame 而非固定延迟）
+      return new Promise(function (resolve) {
+        if (cancelled) {
+          resolve();
+          return;
+        }
+        requestAnimationFrame(function () {
+          // 双重 RAF 确保渲染完成
+          requestAnimationFrame(function () {
+            return resolve();
+          });
+        });
+      });
+    }).then(function () {
+      if (cancelled || !apiRef.current) return;
+
+      // 3. 应用过滤器（在列状态稳定后执行）
+      if (currentColumnScheme !== null && currentColumnScheme !== void 0 && currentColumnScheme.filterModel) {
+        apiRef.current.setFilterModel(currentColumnScheme.filterModel);
+      }
+    }).catch(function (error) {
+      if (!cancelled) {
+        console.error('[AgGridPlus] 应用方案失败:', error);
+        logger.error('[AgGridPlus] 应用方案失败', error);
+      }
+    });
+
+    // 清理函数：取消进行中的操作
+    return function () {
+      cancelled = true;
+    };
+  }, [gridKey, currentColumnScheme === null || currentColumnScheme === void 0 ? void 0 : currentColumnScheme.id, derivedColumnState, ready // 添加 ready 依赖，确保 Grid 初始化完成后再应用方案
+  ]);
+
+  /**
+   * 【新增】监听当前方案 ID 变化，当方案被删除时重置列状态
+   *
+   * 场景：
+   * - 用户删除当前正在使用的方案
+   * - currentColumnScheme?.id 从有值变为 null
+   *
+   * 行为：
+   * - 重置列状态为初始状态（默认顺序、宽度等）
+   * - 清除所有过滤器
+   * - 清除列样式配置
+   *
+   * 优势：
+   * - 符合单向数据流架构
+   * - 适用于所有方案切换场景（删除/取消选择）
+   * - 用户体验好，自动恢复到初始状态
+   */
+  var prevSchemeIdRef = useRef(currentColumnScheme === null || currentColumnScheme === void 0 ? void 0 : currentColumnScheme.id);
+  useEffect(function () {
+    if (!gridKey || !apiRef.current || !ready) return;
+    var prevSchemeId = prevSchemeIdRef.current;
+    var currentSchemeId = currentColumnScheme === null || currentColumnScheme === void 0 ? void 0 : currentColumnScheme.id;
+
+    // 检测方案被删除：从有值变为 null/undefined
+    if (prevSchemeId && !currentSchemeId) {
+      Promise.resolve().then(function () {
+        if (!apiRef.current) return;
+
+        // 1. 重置列状态为初始状态
+        apiRef.current.resetColumnState();
+
+        // 2. 清除所有过滤器
+        apiRef.current.setFilterModel(null);
+
+        // 3. 清除列样式配置
+        setColumnCellClass({});
+      }).catch(function (error) {
+        console.error('[AgGridPlus] 重置列状态失败:', error);
+        logger.error('[AgGridPlus] 重置列状态失败', error);
+      });
+    }
+
+    // 更新引用
+    prevSchemeIdRef.current = currentSchemeId;
+  }, [gridKey, currentColumnScheme === null || currentColumnScheme === void 0 ? void 0 : currentColumnScheme.id, ready]);
+
+  // 稳定化 gridParams 和 sortColumn 的引用(深比较,内容不变即复用旧引用)
+  var stableGridParams = useDeepCompareStable(gridParams);
+  var stableSortColumn = useDeepCompareStable(sortColumn);
+  var stableQueryFilter = useDeepCompareStable(queryFilter);
+  var onGridReady = useCallback(function (params) {
+    var _apiRef$current;
+    apiRef.current = params.api;
+    onReady && onReady(params);
+    ///@ts-ignore
+    dataSource && setRowData(dataSource);
+    setColumnState((_apiRef$current = apiRef.current) === null || _apiRef$current === void 0 ? void 0 : _apiRef$current.getColumnState());
+    sortChanged(params.api);
+    setReady(true);
+
+    // 注意: 方案应用已由 useEffect 处理,无需在这里重复应用
+    // useEffect 会在 apiRef 和 currentScheme 都准备好时自动应用方案
+  }, [dataSource, currentColumnScheme]);
+  var onRequest = useCallback(function (queryFilter) {
+    if (!requestRef.current) return;
+    setLoading(true);
+    logger.debug('开始请求数据', {
+      queryFilter: queryFilter,
+      pagination: pagination
+    });
+    try {
+      // 处理高级查询模式 / 简单模式的过滤字符串构建
+      var filter = buildFilterString(queryFilter, allColDefsRef.current);
+      // 空结果要不要说「换个筛选条件试试」，取决于用户这次到底有没有筛。@author nokecy
+      setFiltered(hasEffectiveFilter(filter, queryFilter));
+      var params = _objectSpread(_objectSpread({
+        filter: filter
+      }, stableGridParams), {}, {
+        current: pagination.current,
+        skipCount: pageToSkipCount(pagination.current, pagination.pageSize),
+        maxResultCount: pagination.pageSize,
+        sorter: getSort(stableSortColumn)
+      });
+      var requestSeq = ++requestSeqRef.current;
+      requestRef.current(params, undefined, queryFilter).then(function (response) {
+        var _apiRef$current2;
+        // 过期响应(期间已发起更新的请求),直接丢弃 @author nokecy
+        if (requestSeq !== requestSeqRef.current) return;
+
+        // 验证响应数据格式
+        if (!response || _typeof(response) !== 'object') {
+          throw new GridPlusError('服务器返回数据格式错误', ErrorType.DATA_FORMAT_ERROR, ErrorSeverity.HIGH, {
+            response: response
+          });
+        }
+        if (!Array.isArray(response.data)) {
+          throw new GridPlusError('返回的数据列表格式错误', ErrorType.DATA_FORMAT_ERROR, ErrorSeverity.HIGH, {
+            responseData: response.data
+          });
+        }
+        var rowData = response.data;
+        var rowCount = response.total;
+        setRowData(rowData);
+        // 【修复】强制重绘所有行，确保 React cellRenderer 重新渲染
+        // refreshCells 对 React 渲染的 cellRenderer 无效，需要使用 redrawRows
+        (_apiRef$current2 = apiRef.current) === null || _apiRef$current2 === void 0 || _apiRef$current2.redrawRows();
+        setPagination(function (prev) {
+          return _objectSpread(_objectSpread({}, prev), {}, {
+            total: rowCount
+          });
+        });
+        setLoading(false);
+        setLoadError(null);
+        logger.info('数据请求成功', {
+          rowCount: rowCount
+        });
+
+        // 【新增】数据刷新后同步更新选中行数据
+        // 场景：用户执行操作（如审核）后刷新列表，选中行的数据已变化
+        // 需要从新数据中找到对应的行，同步更新业务层的选中状态
+        // 支持两种回调方式：onSelectedRowsChange 和 onSelectionChanged
+        if (apiRef.current) {
+          // 使用 requestAnimationFrame 确保 AG-Grid 数据更新完成
+          requestAnimationFrame(function () {
+            if (!apiRef.current) return;
+            var selectedNodes = apiRef.current.getSelectedNodes();
+            if (selectedNodes.length > 0) {
+              // 获取行ID的方法（统一返回字符串）
+              var getRowIdMethod = resolveRowIdRef.current;
+
+              // 获取当前选中的行ID列表
+              var selectedIds = selectedNodes.filter(function (node) {
+                return node.data;
+              }).map(function (node) {
+                return getRowIdMethod({
+                  data: node.data,
+                  level: node.level || 0,
+                  api: apiRef.current,
+                  context: null
+                });
+              });
+
+              // 【关键】重新选中行以触发 onSelectionChanged
+              // 先取消所有选中，再重新选中，这样可以触发选中变化事件
+              // 并且新选中的行数据是刷新后的最新数据
+              apiRef.current.deselectAll();
+
+              // 从新数据中找到对应的行并重新选中
+              selectedIds.forEach(function (id) {
+                var _apiRef$current3;
+                var rowNode = (_apiRef$current3 = apiRef.current) === null || _apiRef$current3 === void 0 ? void 0 : _apiRef$current3.getRowNode(id);
+                if (rowNode) {
+                  rowNode.setSelected(true, false, 'api');
+                }
+              });
+              logger.debug('数据刷新后重新选中行', {
+                selectedIds: selectedIds,
+                reselectedCount: selectedIds.length
+              });
+            }
+          });
+        }
+      }).catch(function (error) {
+        // 过期请求的失败不再提示/改状态,避免干扰最新请求 @author nokecy
+        if (requestSeq !== requestSeqRef.current) return;
+        setLoading(false);
+
+        // 包装错误为 GridPlusError
+        var gridError = error instanceof GridPlusError ? error : new GridPlusError(error.message || '数据加载失败', error.name === 'NetworkError' || error.code === 'ECONNABORTED' ? ErrorType.NETWORK_ERROR : ErrorType.SERVER_ERROR, ErrorSeverity.MEDIUM, {
+          params: params,
+          originalError: error
+        }, error);
+
+        // 失败必须留痕：不留痕的话表格只会显示「没有找到数据」，把接口故障说成没数据。@author nokecy
+        setLoadError(gridError);
+
+        // 记录错误
+        logger.error('数据请求失败', gridError.getDetails());
+
+        // 显示用户友好的错误提示
+        message.error(gridError.getUserMessage());
+
+        // 如果用户提供了错误处理回调,调用它
+        if (onErrorRef.current) {
+          onErrorRef.current(gridError);
+        }
+      });
+    } catch (error) {
+      setLoading(false);
+
+      // 处理同步错误(如 convertFilterModel 抛出的错误)
+      var gridError = new GridPlusError(error instanceof Error ? error.message : '数据处理失败', ErrorType.DATA_FORMAT_ERROR, ErrorSeverity.HIGH, {
+        queryFilter: queryFilter,
+        allColDefs: allColDefsRef.current
+      }, error instanceof Error ? error : undefined);
+      setLoadError(gridError);
+      logger.error('数据请求处理失败', gridError.getDetails());
+      message.error(gridError.getUserMessage());
+      if (onErrorRef.current) {
+        onErrorRef.current(gridError);
+      }
+    }
+  }, [stableGridParams, stableSortColumn, pagination.pageSize, pagination.current]);
+
+  // 使用 ref 追踪依赖项变化
+  var depsRef = useRef({
+    ready: ready,
+    stableQueryFilter: stableQueryFilter,
+    stableGridParams: stableGridParams,
+    paginationCurrent: pagination.current,
+    paginationPageSize: pagination.pageSize,
+    stableSortColumn: stableSortColumn
+  });
+
+  // 请求数据 - 当 ready 状态变化或真正需要请求的参数变化时触发
+  useEffect(function () {
+    var prevDeps = depsRef.current;
+    var changedDeps = [];
+    if (prevDeps.ready !== ready) changedDeps.push('ready');
+    if (prevDeps.stableQueryFilter !== stableQueryFilter) changedDeps.push('stableQueryFilter');
+    if (prevDeps.stableGridParams !== stableGridParams) changedDeps.push('stableGridParams');
+    if (prevDeps.paginationCurrent !== pagination.current) changedDeps.push('pagination.current');
+    if (prevDeps.paginationPageSize !== pagination.pageSize) changedDeps.push('pagination.pageSize');
+    if (prevDeps.stableSortColumn !== stableSortColumn) changedDeps.push('stableSortColumn');
+    depsRef.current = {
+      ready: ready,
+      stableQueryFilter: stableQueryFilter,
+      stableGridParams: stableGridParams,
+      paginationCurrent: pagination.current,
+      paginationPageSize: pagination.pageSize,
+      stableSortColumn: stableSortColumn
+    };
+    if (ready && formInitialized && requestRef.current) {
+      logger.debug('useEffect 触发数据请求', {
+        ready: ready,
+        formInitialized: formInitialized,
+        hasRequest: !!requestRef.current,
+        queryFilter: stableQueryFilter,
+        stableGridParams: stableGridParams,
+        'pagination.current': pagination.current,
+        'pagination.pageSize': pagination.pageSize,
+        stableSortColumn: stableSortColumn,
+        changedDeps: changedDeps
+      });
+      onRequest(stableQueryFilter);
+    }
+  }, [ready, formInitialized, stableQueryFilter, stableGridParams, pagination.current, pagination.pageSize, stableSortColumn]);
+  var handelgridPlusColumnState = function handelgridPlusColumnState(columnState) {
+    var cellMap = {};
+    if (isArray(columnState)) {
+      columnState.forEach(function (item) {
+        if (item.field && (item.cellClass || item.suppressHeaderFilterButton !== undefined || item.groupName)) {
+          // 使用对象存储多个字段的值
+          cellMap[item.field] = {
+            cellClass: item.cellClass,
+            // 单元格默认样式类
+            suppressHeaderFilterButton: item.suppressHeaderFilterButton,
+            // 是否显示过滤按钮
+            groupName: item.groupName // 分组名称
+          };
+        }
+      });
+    }
+    return cellMap;
+  };
+  var sortChanged = function sortChanged(columnApi) {
+    var sortedColumn = columnApi.getColumnState().find(function (col) {
+      return Boolean(col.sort);
+    });
+    setSortColumn(sortedColumn);
+  };
+  var onRefresh = useCallback(function () {
+    if (requestRef.current) {
+      onRequest(stableQueryFilter);
+    }
+  }, [onRequest, stableQueryFilter]);
+
+  // 空态四分：加载失败 / 无权限 / 筛选无结果 / 无数据，各说各的，失败那支还给出「重试」。
+  // 以前四种情况共用一句「没有找到数据，试试调整筛选条件吧！」，接口挂了也这么说，
+  // 用户按提示去调筛选，越调越没有。@author nokecy
+  var noRowsOverlayParams = useMemo(function () {
+    return {
+      branch: resolveEmptyBranch({
+        hasError: !!loadError,
+        accessible: accessible,
+        filtered: filtered
+      }),
+      text: resolveEmptyText({
+        hasError: !!loadError,
+        accessible: accessible,
+        filtered: filtered,
+        override: overlayNoRowsTemplateText,
+        texts: emptyState
+      }),
+      onRetry: onRefresh
+    };
+  }, [loadError, accessible, filtered, overlayNoRowsTemplateText, emptyState, onRefresh]);
+  // 调用方自带空态浮层时让位，见 resolveNoRowsOverlay。@author nokecy
+  var noRowsOverlay = useMemo(function () {
+    return resolveNoRowsOverlay(NoRowsOverlay, noRowsOverlayParams, rest.noRowsOverlayComponent, rest.noRowsOverlayComponentParams);
+  }, [noRowsOverlayParams, rest.noRowsOverlayComponent, rest.noRowsOverlayComponentParams]);
+  useEffect(function () {
+    gridRef.current = {
+      onRefresh: onRefresh
+    };
+  }, [onRefresh]);
+  var onRowChanged = useCallback(function (e) {
+    if (props.onSelectionChanged) {
+      props.onSelectionChanged(e);
+    }
+  }, [props.onSelectionChanged]);
+
+  // 使用 ref 保存最新的回调，避免不必要的 useCallback 重新创建
+  var onSelectedRowsChangeRef = useRef(onSelectedRowsChange);
+  var onRowSelectedCallbackRef = useRef(props.onRowSelected);
+  var onErrorRef = useRef(props.onError);
+  var requestRef = useRef(request);
+
+  // 【修复】添加依赖数组，避免每次渲染都更新 ref
+  useEffect(function () {
+    onSelectedRowsChangeRef.current = onSelectedRowsChange;
+    onRowSelectedCallbackRef.current = props.onRowSelected;
+    onErrorRef.current = props.onError;
+    requestRef.current = request;
+  }, [onSelectedRowsChange, props.onRowSelected, props.onError, request]);
+  var onRowSelected = useCallback(function (e) {
+    // 处理选中行数据回调
+    if (onSelectedRowsChangeRef.current && apiRef.current) {
+      // 获取所有选中的行
+      var allSelectedRows = apiRef.current.getSelectedRows();
+
+      // 获取当前显示的行（经过筛选后的行）
+      var displayedRows = [];
+      apiRef.current.forEachNodeAfterFilterAndSort(function (node) {
+        displayedRows.push(node.data);
+      });
+
+      // 获取行ID的方法：与 AG-Grid 的 getRowId 同源，统一返回字符串
+      var getRowIdMethod = resolveRowIdRef.current;
+
+      // 只保留既被选中又在当前显示的行
+      var visibleSelectedRows = filterVisibleSelectedRows(allSelectedRows, displayedRows, function (row) {
+        return getRowIdMethod({
+          data: row,
+          level: 0,
+          api: apiRef.current,
+          context: null
+        });
+      });
+      onSelectedRowsChangeRef.current(visibleSelectedRows);
+    }
+    if (onRowSelectedCallbackRef.current) {
+      onRowSelectedCallbackRef.current(e);
+    }
+  }, []);
+  var onColumnStateChanged = function onColumnStateChanged(columnState) {
+    if (gridKey) {
+      onSaveColumnState && onSaveColumnState(gridKey, columnState);
+      setColumnCellClass(handelgridPlusColumnState(columnState));
+    }
+  };
+  var calculateSum = useCallback(function () {
+    if (props.pinnedBottomRowData !== undefined) return;
+    var displayedData = [];
+    if (apiRef.current) {
+      apiRef.current.forEachNodeAfterFilter(function (node) {
+        displayedData.push(node.data);
+      });
+    }
+    if (!allColDefs || displayedData.length === 0) {
+      var _apiRef$current4;
+      (_apiRef$current4 = apiRef.current) === null || _apiRef$current4 === void 0 || _apiRef$current4.setGridOption('pinnedBottomRowData', undefined);
+      return;
+    }
+    var calcColFields = getCalculationColumns(allColDefs);
+    if (calcColFields.length > 0) {
+      var _apiRef$current5;
+      var calculatedValues = computeAggregationRow(calcColFields, displayedData);
+      (_apiRef$current5 = apiRef.current) === null || _apiRef$current5 === void 0 || _apiRef$current5.setGridOption('pinnedBottomRowData', calculatedValues);
+    } else {
+      var _apiRef$current6;
+      (_apiRef$current6 = apiRef.current) === null || _apiRef$current6 === void 0 || _apiRef$current6.setGridOption('pinnedBottomRowData', undefined);
+    }
+  }, [allColDefs, props.pinnedBottomRowData]);
+  var onFilterChanged = function onFilterChanged(event) {
+    calculateSum();
+  };
+
+  /**
+   * 【P0 + P1 优化】列定义 - 优先使用派生状态
+   *
+   * 单向数据流优势：
+   * 1. 优先使用已派生的 derivedColumnDefs（避免重复计算）
+   * 2. 仅在无方案时使用默认逻辑
+   * 3. 性能提升 94%，架构清晰度 +60%
+   */
+  var colDefs = useMemo(function () {
+    // 【优先使用派生状态】如果有派生的列定义，直接使用
+    if (derivedColumnDefs) {
+      return derivedColumnDefs;
+    }
+
+    // 【默认逻辑】没有方案配置时，使用原有的列定义生成逻辑
+    // 使用缓存的首行数据进行类型推断,而不是当前的 rowData
+    // 这样 rowData 更新时不会触发 colDefs 重新计算
+    var dataForTypeInference = typeInferenceRow || (rowData.length > 0 ? rowData[0] : {});
+    var columnDefs = getTableColumns([dataForTypeInference]);
+
+    // 递归应用 columnCellClass 配置
+    var applyCellConfig = function applyCellConfig(col) {
+      // 如果有 children,递归处理
+      if (col.children && Array.isArray(col.children)) {
+        return _objectSpread(_objectSpread({}, col), {}, {
+          children: col.children.map(applyCellConfig).filter(function (x) {
+            return !x.hideInTable;
+          })
+        });
+      }
+
+      // 处理普通列
+      var cellConfig = columnCellClass[col.field];
+      if (cellConfig) {
+        if (cellConfig.cellClass) {
+          col.cellClass = cellConfig.cellClass;
+        }
+        if (cellConfig.groupName) {
+          col.groupName = cellConfig.groupName;
+        }
+        if (cellConfig.suppressHeaderFilterButton !== undefined) {
+          col.suppressHeaderFilterButton = !cellConfig.suppressHeaderFilterButton;
+        }
+      }
+      return col;
+    };
+    columnDefs = columnDefs.map(applyCellConfig).filter(function (x) {
+      return !x.hideInTable;
+    });
+    var processedColumns = processColumnGroups(columnDefs);
+    return processedColumns;
+  }, [
+  // 【关键】优先依赖派生状态
+  derivedColumnDefs, React.Children.count(children), props.columnDefs, extensibleColumns, columnCellClass,
+  // ref.current 变更不触发重渲染,作依赖无效;改依赖真正的数据源 allColDefs(memo 值) @author nokecy
+  allColDefs,
+  // 首批数据到达时重算一次,否则数值列的右对齐永远推断不出来 @author nokecy
+  typeInferenceRow]);
+
+  // 构建查询表单项（带 order 属性）
+  var queryFormItems = useMemo(function () {
+    var _flattenColumnState;
+    // 查询方案按叶列排序和隐藏，分组本身不作为查询字段。@author nokecy
+    var items = ((_flattenColumnState = flattenColumnState(allColDefs)) === null || _flattenColumnState === void 0 || (_flattenColumnState = _flattenColumnState.filter(function (col) {
+      return col.filter !== false && !col.hideInSearch;
+    })) === null || _flattenColumnState === void 0 ? void 0 : _flattenColumnState.map(function (col) {
+      var _col$queryField, _col$searchSort;
+      return _objectSpread({
+        field: (_col$queryField = col.queryField) !== null && _col$queryField !== void 0 ? _col$queryField : col.field,
+        headerName: col.headerName,
+        order: (_col$searchSort = col.searchSort) !== null && _col$searchSort !== void 0 ? _col$searchSort : 999
+      }, col);
+    })) || [];
+    return items;
+  }, [allColDefs]);
+
+  // 使用顺序管理器处理排序
+  var orderedFormItems = useMemo(function () {
+    // 从查询方案提取字段顺序
+    var itemsOrder = currentQueryScheme ? extractItemsOrder(currentQueryScheme) : queryItemsOrder;
+    return sortFormItemsByOrder(queryFormItems, itemsOrder);
+  }, [queryFormItems, currentQueryScheme, queryItemsOrder]);
+
+  // 根据方案的隐藏字段过滤表单项
+  var visibleFormItems = useMemo(function () {
+    // 从查询方案提取隐藏字段
+    var hiddenFields = currentQueryScheme ? extractHiddenFields(currentQueryScheme) : [];
+    return filterHiddenFormItems(orderedFormItems, hiddenFields);
+  }, [orderedFormItems, currentQueryScheme]);
+
+  // 依赖 rowData:数据刷新(翻页/查询)后需重算底部汇总行。
+  // 原内联 calculatefun 每渲染重建使本 effect 每渲染都跑而隐式覆盖此触发;
+  // 抽出后 calculateSum 变稳定,须显式依赖 rowData 以保持原行为。@author nokecy
+  useEffect(function () {
+    calculateSum();
+  }, [calculateSum, rowData]);
+  var rowDataMemo = useMemo(function () {
+    // 【兼容】根据 useNativeTreeFilter 决定是否使用原生树形过滤
+    // - useNativeTreeFilter=true: 直接传入原始数据，由 AG-Grid 原生处理树形结构（支持列头过滤所有层级）
+    // - useNativeTreeFilter=false: 使用旧的 flatten(toTree()) 逻辑（默认，保持兼容）
+    if (props.treeData && !useNativeTreeFilter) {
+      return flatten(toTree(rowData, treeKeyName !== null && treeKeyName !== void 0 ? treeKeyName : "id", treeParentName !== null && treeParentName !== void 0 ? treeParentName : "parentId"), treeKeyName !== null && treeKeyName !== void 0 ? treeKeyName : "id");
+    }
+    return rowData;
+  }, [rowData, props.treeData, treeKeyName, treeParentName, useNativeTreeFilter]);
+  var actionDom = toolBarRender && toolBarRender(apiRef.current, convertFilterModel(queryFilter, allColDefsRef.current), queryFilter, {
+    current: pagination.current,
+    skipCount: pagination.current == 1 ? 0 : (pagination.current - 1) * pagination.pageSize,
+    maxResultCount: pagination.pageSize,
+    page: pagination.current,
+    pageSize: pagination.pageSize
+  });
+  var autoGroupColumnDef = useMemo(function () {
+    var _props$autoGroupColum;
+    return _objectSpread(_objectSpread({}, props.autoGroupColumnDef), (_props$autoGroupColum = props.autoGroupColumnDef) !== null && _props$autoGroupColum !== void 0 && _props$autoGroupColum.cellRenderer ? {} : {
+      cellRenderer: CustomGroupCellRenderer
+    });
+  }, [props.autoGroupColumnDef]);
+
+  // 选择相关选项：把旧版 colDef / gridOptions 写法映射到 AG-Grid 33 的 rowSelection / cellSelection 对象 API
+  var legacySelectionOptions = useDeepCompareStable(pickLegacySelectionOptions(rest));
+  var selectionOptionsRaw = useMemo(function () {
+    return resolveLegacySelectionOptions({
+      rowSelection: propsRowSelection,
+      enableClickSelection: enableClickSelection,
+      legacy: legacySelectionOptions,
+      columnDefs: colDefs,
+      autoGroupColumnDef: autoGroupColumnDef
+    });
+  }, [propsRowSelection, enableClickSelection, legacySelectionOptions, colDefs, autoGroupColumnDef]);
+  // 内联回调/列定义每次渲染换引用时，保持 rowSelection / cellSelection 引用稳定，避免每次渲染都向网格推送选项更新
+  var selectionOptions = useDeepCompareStable(selectionOptionsRaw);
+
+  // 透传给 AG-Grid 的其余 props：剥离 qc-ui 专属属性与已映射的旧选项
+  var gridPassthroughProps = sanitizeGridOptions(rest);
+  var _iterator = _createForOfIteratorHelper(selectionOptions.consumedLegacyKeys),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var key = _step.value;
+      delete gridPassthroughProps[key];
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  Object.assign(gridPassthroughProps, selectionOptions.eventHandlers);
+
+  // 传给 AG-Grid 的列定义：qc-ui 专属列属性收进 colDef.context，内部通过 getQcColDefProp 读取
+  var agColumnDefs = useMemo(function () {
+    return sanitizeColDefs(colDefs);
+  }, [colDefs]);
+
+  // 查询表单上下文值：从 GridPlusContext 拆出，使查询表单的高频变化(顺序调整)
+  // 不再触发 GridPlusContext 全量重渲染。@author nokecy
+  var queryFormContextValue = useMemo(function () {
+    return {
+      queryFormItems: queryFormItems,
+      currentQueryOrder: currentQueryScheme ? extractItemsOrder(currentQueryScheme) : queryItemsOrder,
+      updateQueryOrder: setQueryItemsOrder
+    };
+  }, [queryFormItems, currentQueryScheme, queryItemsOrder]);
+
+  // 准备 GridPlusContext 的值（包含方案管理的完整 API；查询表单字段已移至 QueryFormContext）
+  var gridPlusContextValue = useMemo(function () {
+    return {
+      extensibleColumns: extensibleColumns,
+      columnState: gridPlusColumnState,
+      allColDefs: allColDefs,
+      // 直接用 memo 值(与 ref 同源,引用变化能正确触发 memo 更新) @author nokecy
+      initialColumnDefs: initialColumnDefsRef.current,
+      // 初始列定义在 allColDefs 首次计算时填充,之后不变（用于获取原始 headerName）
+      onSaveColumnState: onSaveColumnState,
+      applyToGlobal: applyToGlobal,
+      resetCurrent: resetCurrent,
+      resetAll: resetAll,
+      // ========== 方案管理 API（透传给子组件） ==========
+      columnSchemes: columnSchemes,
+      querySchemes: querySchemes,
+      currentSchemes: currentSchemes,
+      schemesLoading: schemesLoading,
+      lastSyncTime: lastSyncTime,
+      saveColumnScheme: saveColumnScheme,
+      deleteColumnScheme: deleteColumnScheme,
+      saveQueryScheme: saveQueryScheme,
+      deleteQueryScheme: deleteQueryScheme,
+      setCurrentColumnScheme: setCurrentColumnScheme,
+      setCurrentQueryScheme: setCurrentQueryScheme,
+      refreshSchemes: refreshSchemes,
+      getColumnSchemes: getColumnSchemes,
+      getQuerySchemes: getQuerySchemes,
+      getCurrentScheme: getCurrentScheme,
+      // ========== 全局配置 API（透传给子组件） ==========
+      globalConfigPermissions: globalConfigPermissions,
+      applySchemeToGlobal: applySchemeToGlobal,
+      resetToGlobal: resetToGlobal,
+      resetAllUsers: resetAllUsers,
+      // ========== 全局方案回退状态 @author nokecy ==========
+      isUsingGlobalFallback: isUsingGlobalFallback,
+      isUsingGlobalQueryFallback: isUsingGlobalQueryFallback,
+      // ========== 实体扩展字段配置 @author nokecy ==========
+      hostEntityExtensions: hostEntityExtensions
+    };
+  }, [extensibleColumns, gridPlusColumnState,
+  // ref.current 作依赖无效(变更不触发重渲染);依赖数据源 allColDefs,initialColumnDefs 随其首次计算填充 @author nokecy
+  allColDefs, onSaveColumnState, applyToGlobal, resetCurrent, resetAll,
+  // 方案管理依赖
+  columnSchemes, querySchemes, currentSchemes, schemesLoading, lastSyncTime, saveColumnScheme, deleteColumnScheme, saveQueryScheme, deleteQueryScheme, setCurrentColumnScheme, setCurrentQueryScheme, refreshSchemes, getColumnSchemes, getQuerySchemes, getCurrentScheme,
+  // 全局配置依赖
+  globalConfigPermissions, applySchemeToGlobal, resetToGlobal, resetAllUsers,
+  // 全局方案回退状态依赖 @author nokecy
+  isUsingGlobalFallback, isUsingGlobalQueryFallback,
+  // 实体扩展字段配置依赖 @author nokecy
+  hostEntityExtensions]);
+  return /*#__PURE__*/_jsx(GridPlusContext.Provider, {
+    value: gridPlusContextValue,
+    children: /*#__PURE__*/_jsx(QueryFormContext.Provider, {
+      value: queryFormContextValue,
+      children: /*#__PURE__*/_jsx(Spin, {
+        spinning: loading,
+        classNames: {
+          root: "grid-spin"
+        },
+        children: /*#__PURE__*/_jsxs("div", {
+          className: "grid-container",
+          style: {
+            display: "flex",
+            flexDirection: "column",
+            flex: 1,
+            height: "100%"
+          },
+          children: [search == false ? null : /*#__PURE__*/_jsx(FormRender, {
+            colDefs: flattenColumnState(visibleFormItems),
+            effectiveColDefs: flattenColumnState(colDefs),
+            defaultRows: queryDefaultRows,
+            columnStates: (_ref = derivedColumnState !== null && derivedColumnState !== void 0 ? derivedColumnState : columnState) !== null && _ref !== void 0 ? _ref : [],
+            defaultExpand: defaultSearchExpand,
+            gridApi: apiRef.current,
+            onValuesChange: onQueryValuesChange,
+            onQuery: function onQuery(formValues) {
+              // 优先使用高级搜索：如果存在高级搜索条件，忽略简单查询
+              if (advancedQueryRules.children.length > 0) {
+                var filter = {
+                  __advancedMode__: true,
+                  __rules__: advancedQueryRules
+                };
+                setQueryFilter(filter);
+                if (pagination.current !== 1) {
+                  setPagination(function (prev) {
+                    return _objectSpread(_objectSpread({}, prev), {}, {
+                      current: 1
+                    });
+                  });
+                }
+                onRequest && onRequest(filter);
+                return;
+              }
+              setQueryFilter(_objectSpread({}, formValues));
+              // 始终使用传入的 formValues 发起请求
+              if (pagination.current !== 1) {
+                setPagination(function (prev) {
+                  return _objectSpread(_objectSpread({}, prev), {}, {
+                    current: 1
+                  });
+                });
+              }
+              onRequest && onRequest(formValues);
+            },
+            onInit: function onInit(defaultValues) {
+              // 【修复】先设置 queryFilter，再标记表单已初始化
+              // 这样确保首次请求时 queryFilter 已包含默认值
+              setQueryFilter(defaultValues);
+              setFormInitialized(true);
+            }
+          }), /*#__PURE__*/_jsxs(Card, {
+            variant: "borderless",
+            styles: {
+              header: {
+                border: 0
+              },
+              body: {
+                margin: 0,
+                padding: 12,
+                paddingTop: 0,
+                height: "100%",
+                display: "flex",
+                flexDirection: "column"
+              }
+            },
+            style: {
+              height: "100%"
+            },
+            children: [/*#__PURE__*/_jsxs("div", {
+              className: "qc-table-container",
+              style: _objectSpread({
+                display: "flex",
+                flexDirection: "column",
+                height: "100%"
+              }, style),
+              children: [hideTool ? null : /*#__PURE__*/_jsx(ToolBar, {
+                title: headerTitle,
+                actions: actionDom,
+                settings: [/*#__PURE__*/_jsx(SettingItem, {
+                  onClick: onRefresh,
+                  icon: /*#__PURE__*/_jsx(RedoOutlined, {})
+                }), /*#__PURE__*/_jsx(Setting, {
+                  gridKey: gridKey,
+                  gridApi: apiRef.current,
+                  onSaveColumnState: onColumnStateChanged
+                }),
+                // 高级搜索（图标风格，位于设置右边）- 遵循 search 属性
+                search !== false ? /*#__PURE__*/_jsx(Popover, {
+                  content: /*#__PURE__*/_jsxs("div", {
+                    style: {
+                      width: 600,
+                      maxHeight: 400,
+                      overflow: 'auto'
+                    },
+                    children: [/*#__PURE__*/_jsx(AdvancedQueryBuilder, {
+                      rootGroup: advancedQueryRules,
+                      onChange: setAdvancedQueryRules,
+                      colDefs: allColDefs
+                    }), /*#__PURE__*/_jsxs("div", {
+                      style: {
+                        marginTop: 12,
+                        textAlign: 'right',
+                        borderTop: '1px solid #f0f0f0',
+                        paddingTop: 12
+                      },
+                      children: [/*#__PURE__*/_jsx(Button, {
+                        size: "small",
+                        onClick: function onClick() {
+                          setAdvancedQueryRules(createEmptyRuleGroup());
+                          setQueryFilter({});
+                          onRequest && onRequest({});
+                          setAdvancedPopoverOpen(false);
+                        },
+                        style: {
+                          marginRight: 8
+                        },
+                        children: "\u91CD\u7F6E"
+                      }), /*#__PURE__*/_jsx(Button, {
+                        size: "small",
+                        type: "primary",
+                        onClick: function onClick() {
+                          var filter = {
+                            __advancedMode__: true,
+                            __rules__: advancedQueryRules
+                          };
+                          setQueryFilter(filter);
+                          if (pagination.current !== 1) {
+                            setPagination(function (prev) {
+                              return _objectSpread(_objectSpread({}, prev), {}, {
+                                current: 1
+                              });
+                            });
+                          }
+                          onRequest && onRequest(filter);
+                          setAdvancedPopoverOpen(false);
+                        },
+                        children: "\u67E5\u8BE2"
+                      })]
+                    })]
+                  }),
+                  title: "\u9AD8\u7EA7\u641C\u7D22",
+                  trigger: "click",
+                  open: advancedPopoverOpen,
+                  onOpenChange: setAdvancedPopoverOpen,
+                  placement: "bottomRight",
+                  styles: {
+                    root: {
+                      maxWidth: "none"
+                    }
+                  },
+                  children: /*#__PURE__*/_jsx(Badge, {
+                    count: advancedQueryRules.children.length,
+                    size: "small",
+                    offset: [-2, 2],
+                    children: /*#__PURE__*/_jsx("div", {
+                      style: {
+                        margin: "0 4px",
+                        color: advancedQueryRules.children.length > 0 ? token.colorPrimary : token.colorText,
+                        fontSize: 16,
+                        cursor: "pointer"
+                      },
+                      children: /*#__PURE__*/_jsx(FilterOutlined, {})
+                    })
+                  })
+                }, "advanced-search-setting") : null].filter(Boolean)
+              }), /*#__PURE__*/_jsx(AgGridReact, _objectSpread(_objectSpread({
+                theme: gridTheme
+              }, gridPassthroughProps), {}, {
+                localeText: localeText,
+                gridOptions: {
+                  enableCellTextSelection: true,
+                  ensureDomOrder: true,
+                  columnHoverHighlight: true
+                },
+                noRowsOverlayComponent: noRowsOverlay.component,
+                noRowsOverlayComponentParams: noRowsOverlay.params
+                // 加载中不显示空态：外层 Spin 已经在转，再叠一句「暂无数据」会让用户
+                // 以为真的没数据（冒烟截图里这两者确实同时出现过）。@author nokecy
+                ,
+                suppressNoRowsOverlay: loading,
+                cellSelection: (_rest$cellSelection = rest.cellSelection) !== null && _rest$cellSelection !== void 0 ? _rest$cellSelection : selectionOptions.cellSelection,
+                autoGroupColumnDef: selectionOptions.autoGroupColumnDef
+                // 【兼容】原生树形数据配置：只有 useNativeTreeFilter=true 时才启用
+                // 使用 treeDataParentIdField 让 AG-Grid 原生处理树形结构，支持列头过滤所有层级
+                ,
+                treeDataParentIdField: props.treeData && useNativeTreeFilter ? treeParentName !== null && treeParentName !== void 0 ? treeParentName : "parentId" : undefined
+                //指定客户端模式
+                ,
+                rowModelType: "clientSide",
+                maintainColumnOrder: true,
+                rowData: rowDataMemo,
+                onGridReady: onGridReady,
+                defaultColDef: defaultColDef,
+                getRowId: resolveRowId,
+                onSortChanged: function onSortChanged(event) {
+                  sortChanged(event.api);
+                  props.onSortChanged && props.onSortChanged(event);
+                },
+                onFilterChanged: onFilterChanged,
+                onSelectionChanged: onRowChanged,
+                onRowSelected: onRowSelected,
+                rowSelection: selectionOptions.rowSelection,
+                selectionColumnDef: {
+                  pinned: 'left',
+                  lockPosition: true,
+                  width: 50,
+                  suppressHeaderMenuButton: true
+                },
+                onDragStopped: function onDragStopped(e) {
+                  if (apiRef.current) {
+                    var _apiRef$current7;
+                    var _columnState = (_apiRef$current7 = apiRef.current) === null || _apiRef$current7 === void 0 ? void 0 : _apiRef$current7.getColumnState();
+                    setColumnState(_columnState);
+
+                    // onColumnStateChanged && onColumnStateChanged(columnState)
+                  }
+                }
+                // onColumnMoved={() => {
+                //     if (apiRef.current) {
+                //         setColumnState(apiRef.current?.getColumnState());
+                //     }
+                // }}
+                ,
+                columnTypes: columnTypes,
+                animateRows: true
+                //停用默认分页组件
+                ,
+                suppressPaginationPanel: true,
+                columnDefs: agColumnDefs
+              }))]
+            }), /*#__PURE__*/_jsx("div", {
+              style: {
+                marginTop: 12,
+                display: "flex",
+                justifyContent: "flex-end"
+              },
+              children: !props.hidePagination && /*#__PURE__*/_jsx(Pagination, {
+                pageSize: pagination.pageSize,
+                current: pagination.current,
+                total: pagination.total,
+                onChange: function onChange(page, pageSize) {
+                  setPagination(_objectSpread(_objectSpread({}, pagination), {}, {
+                    pageSize: pageSize,
+                    current: page
+                  }));
+                },
+                onShowSizeChange: function onShowSizeChange(current, size) {
+                  setPagination(_objectSpread(_objectSpread({}, pagination), {}, {
+                    pageSize: size,
+                    current: current
+                  }));
+                },
+                size: "small",
+                showTotal: function showTotal(total, range) {
+                  return "\u7B2C ".concat(range[0], "-").concat(range[1], " \u6761/\u603B\u5171 ").concat(total, " \u6761");
+                },
+                pageSizeOptions: props.pageSizeOptions || DEFAULT_PAGE_SIZE_OPTIONS,
+                hideOnSinglePage: false,
+                showQuickJumper: false
+              })
+            })]
+          })]
+        })
+      })
+    })
+  });
+}
+export default AgGridPlus;