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

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

@@ -0,0 +1,1691 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _agGridCommunity = require("ag-grid-community");
+var _agGridReact = require("ag-grid-react");
+var _antd = require("antd");
+var _react = _interopRequireWildcard(require("react"));
+var _agGridEnterprise = require("ag-grid-enterprise");
+var _theme = require("./theme");
+var _density = require("./density");
+var _rowColors = require("./rowColors");
+var _listKeyboard = require("./utils/listKeyboard");
+var _crossPageSelection = require("./utils/crossPageSelection");
+var _valueFormat = require("./utils/valueFormat");
+var _useTypeInferenceRow = require("./hooks/useTypeInferenceRow");
+require("./index.less");
+var _index2 = _interopRequireDefault(require("./queryForm/index"));
+var _index3 = _interopRequireDefault(require("./toolBar/index"));
+var _index4 = _interopRequireDefault(require("./settingItem/index"));
+var _autoColumnMemory = require("./setting/autoColumnMemory");
+var _queryDispatch = require("./utils/queryDispatch");
+var _icons = require("@ant-design/icons");
+var _utils = require("./utils");
+var _columnProcessors = require("./utils/columnProcessors");
+var _AdvancedQueryBuilder = _interopRequireDefault(require("./queryForm/AdvancedQueryBuilder"));
+var _uuid = require("uuid");
+var _index5 = _interopRequireDefault(require("./setting/index"));
+var _index6 = require("./index");
+var _useRowId2 = require("./hooks/useRowId");
+var _lodash = _interopRequireWildcard(require("lodash"));
+var _customGroupCellRenderer = _interopRequireDefault(require("./_utils/customGroupCellRenderer"));
+var _NoRowsOverlay = _interopRequireDefault(require("./shared/NoRowsOverlay"));
+var _SkeletonOverlay = _interopRequireDefault(require("./shared/SkeletonOverlay"));
+var _pagination = require("./utils/pagination");
+var _constants = require("./utils/constants");
+var _emptyState = require("./utils/emptyState");
+var _processColumnGroups = _interopRequireDefault(require("./_utils/processColumnGroups"));
+var _processFormColumnState = _interopRequireDefault(require("./_utils/processFormColumnState"));
+var _locale = require("./locale");
+var _gridContext = require("./context/gridContext");
+var _queryFormContext = require("./context/queryFormContext");
+var _useSchemeManager = require("./context/useSchemeManager");
+var _useSchemeDataFlow = require("./context/useSchemeDataFlow");
+var _schemeDataMigration = require("./shared/utils/schemeDataMigration");
+var _aggregation = require("./utils/aggregation");
+var _queryFormDerivation = require("./utils/queryFormDerivation");
+var _rowSelection = require("./utils/rowSelection");
+var _agGridCompat = require("./utils/agGridCompat");
+var _datePrecision = require("./queryForm/datePrecision");
+var _requestParams = require("./utils/requestParams");
+var _index7 = require("./errors/index");
+var _logger = require("./utils/logger");
+var _entityExtensionColumns = require("./utils/entityExtensionColumns");
+var _jsxRuntime = require("react/jsx-runtime");
+var _excluded = ["style", "loading", "params", "request", "dataSource", "treeKeyName", "treeParentName", "rowData", "gridRef", "headerTitle", "toolBarRender", "search", "hideTool", "onGridReady", "gridKey", "children", "defaultSearchExpand", "overlayNoRowsTemplateText", "queryDefaultRows", "onSelectedRowsChange", "onQueryValuesChange", "autoRememberColumns", "emptyState", "accessible", "enableClickSelection", "rowSelection", "crossPageSelection", "onCrossPageSelectionChange", "defaultValueFormat", "useNativeTreeFilter", "entityType", "valueEnumContrast", "dateQueryPrecision", "headerFilter", "showQuickJumper", "showSizeChanger"];
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+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 _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 _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 _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; }
+// AG-Grid v33+ 需要显式注册模块
+_agGridCommunity.ModuleRegistry.registerModules([_agGridEnterprise.AllEnterpriseModule]);
+
+// 导入 AG-Grid v33 主题
+
+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 = (0, _react.useRef)(value);
+  if (!_lodash.default.isEqual(ref.current, value)) {
+    ref.current = value;
+  }
+  return ref.current;
+}
+function AgGridPlus(props) {
+  var _currentSchemes, _ref, _currentQueryScheme$q, _rest$cellSelection;
+  var _theme$useToken = _antd.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,
+    _props$autoRememberCo = props.autoRememberColumns,
+    autoRememberColumns = _props$autoRememberCo === void 0 ? true : _props$autoRememberCo,
+    emptyState = props.emptyState,
+    _props$accessible = props.accessible,
+    accessible = _props$accessible === void 0 ? true : _props$accessible,
+    enableClickSelection = props.enableClickSelection,
+    propsRowSelection = props.rowSelection,
+    _props$crossPageSelec = props.crossPageSelection,
+    crossPageSelection = _props$crossPageSelec === void 0 ? false : _props$crossPageSelec,
+    onCrossPageSelectionChange = props.onCrossPageSelectionChange,
+    _props$defaultValueFo = props.defaultValueFormat,
+    defaultValueFormat = _props$defaultValueFo === void 0 ? true : _props$defaultValueFo,
+    _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,
+    headerFilter = props.headerFilter,
+    showQuickJumper = props.showQuickJumper,
+    showSizeChanger = props.showSizeChanger,
+    rest = _objectWithoutProperties(props, _excluded);
+  var _useGridPlusColumnSta = (0, _index6.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,
+    density = _useGridPlusColumnSta.density,
+    densityOverrides = _useGridPlusColumnSta.densityValues,
+    onDensityChange = _useGridPlusColumnSta.onDensityChange;
+
+  // 密度由 Provider 注入；没注入时保持出厂外观。页面 `theme` 传普通对象时叠加在 token 与密度之上，
+  // 传 AG Grid Theme 实例或字符串时仍整体替换（兼容旧用法）。@author nokecy
+  var densitySpec = (0, _react.useMemo)(function () {
+    return (0, _density.resolveGridDensity)(density, densityOverrides);
+  }, [density, densityOverrides]);
+  var pageThemeParams = (0, _react.useMemo)(function () {
+    var t = rest.theme;
+    return t && _typeof(t) === 'object' && typeof t.withParams !== 'function' ? t : undefined;
+  }, [rest.theme]);
+  var gridTheme = (0, _theme.useAgGridTheme)({
+    density: densitySpec,
+    themeParams: pageThemeParams
+  });
+  var rowColors = (0, _react.useMemo)(function () {
+    return (0, _rowColors.deriveRowColors)(token.colorPrimary, token.colorLink);
+  }, [token.colorPrimary, token.colorLink]);
+  var gridRef = (0, _react.useRef)(undefined);
+  var apiRef = (0, _react.useRef)(undefined);
+  var allColDefsRef = (0, _react.useRef)([]);
+  // 请求序号:只接受最新一次请求的响应,防止快速翻页/连续查询时慢请求乱序覆盖新结果 @author nokecy
+  var requestSeqRef = (0, _react.useRef)(0);
+
+  // 【新增】缓存初始的 columnDefs，用于保留原始 headerName
+  // 这个值在组件生命周期中保持不变，不会被列方案修改
+  var initialColumnDefsRef = (0, _react.useRef)([]);
+
+  // 【新增】用于缓存每个数据对象的唯一 ID（降级方案）
+  var _useRowId = (0, _useRowId2.useRowId)(gridKey),
+    generateUniqueRowId = _useRowId.generateUniqueRowId;
+  // getRowId 解析器：始终返回字符串（AG-Grid error #25），选中行保持/比对与 AG-Grid 共用同一份结果
+  var resolveRowId = (0, _react.useMemo)(function () {
+    return (0, _agGridCompat.createRowIdResolver)(props.getRowId, function (params) {
+      return generateUniqueRowId(params.data);
+    });
+  }, [props.getRowId, generateUniqueRowId]);
+  var resolveRowIdRef = (0, _react.useRef)(resolveRowId);
+  resolveRowIdRef.current = resolveRowId;
+
+  // 跨页勾选：按行 ID 记住所有已勾选的行，翻页后把当前页命中的行重新勾上 @author nokecy
+  var crossPageRef = (0, _react.useRef)(crossPageSelection);
+  crossPageRef.current = crossPageSelection;
+  var crossPage = (0, _react.useMemo)(function () {
+    return (0, _crossPageSelection.createCrossPageSelection)(function (row) {
+      return resolveRowIdRef.current({
+        data: row,
+        level: 0,
+        api: apiRef.current,
+        context: null
+      });
+    });
+  }, []);
+  var onCrossPageChangeRef = (0, _react.useRef)(onCrossPageSelectionChange);
+  onCrossPageChangeRef.current = onCrossPageSelectionChange;
+  var _useState = (0, _react.useState)(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    ready = _useState2[0],
+    setReady = _useState2[1];
+  // 【修复】追踪搜索表单是否已完成初始化（包含默认值）
+  // 只有当 search !== false 时才需要等待表单初始化
+  var _useState3 = (0, _react.useState)(search === false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    formInitialized = _useState4[0],
+    setFormInitialized = _useState4[1];
+  var _useState5 = (0, _react.useState)(loadingProps ? loadingProps : false),
+    _useState6 = _slicedToArray(_useState5, 2),
+    loading = _useState6[0],
+    setLoading = _useState6[1];
+  // 首次请求发出前表里本来就是空的，此时不能显示空态文案，要显示骨架。
+  // 用「请求已发出且已结束」反推，而不是只看 loading：loading 在首个请求发出前一直是 false。@author nokecy
+  var _useState7 = (0, _react.useState)(!!request),
+    _useState8 = _slicedToArray(_useState7, 2),
+    firstLoadPending = _useState8[0],
+    setFirstLoadPending = _useState8[1];
+  var requestStartedRef = (0, _react.useRef)(false);
+  // 空态四分需要的两个事实：这次请求是不是失败了、用户有没有施加筛选。@author nokecy
+  var _useState9 = (0, _react.useState)(null),
+    _useState10 = _slicedToArray(_useState9, 2),
+    loadError = _useState10[0],
+    setLoadError = _useState10[1];
+  var _useState11 = (0, _react.useState)(false),
+    _useState12 = _slicedToArray(_useState11, 2),
+    filtered = _useState12[0],
+    setFiltered = _useState12[1];
+  var _useState13 = (0, _react.useState)(),
+    _useState14 = _slicedToArray(_useState13, 2),
+    columnState = _useState14[0],
+    setColumnState = _useState14[1];
+  var _useState15 = (0, _react.useState)({}),
+    _useState16 = _slicedToArray(_useState15, 2),
+    columnCellClass = _useState16[0],
+    setColumnCellClass = _useState16[1];
+  var _useState17 = (0, _react.useState)([]),
+    _useState18 = _slicedToArray(_useState17, 2),
+    rowData = _useState18[0],
+    setRowData = _useState18[1];
+  var _useState19 = (0, _react.useState)({}),
+    _useState20 = _slicedToArray(_useState19, 2),
+    queryFilter = _useState20[0],
+    setQueryFilter = _useState20[1];
+  var _useState21 = (0, _react.useState)(),
+    _useState22 = _slicedToArray(_useState21, 2),
+    sortColumn = _useState22[0],
+    setSortColumn = _useState22[1];
+  // 初始化分页参数，支持外部传入的pageSize
+  var _useState23 = (0, _react.useState)({
+      pageSize: (0, _pagination.resolveInitialPageSize)(props.pageSize, props.hidePagination),
+      current: 1,
+      total: dataSource ? dataSource.length : 0
+    }),
+    _useState24 = _slicedToArray(_useState23, 2),
+    pagination = _useState24[0],
+    setPagination = _useState24[1];
+
+  // dataSource 本地数据模式：分页器要真正切片，而不是只显示页码。
+  // 总数与页码按 dataSource 当场推导，数据增删后页码自动收回末页，无需再同步 state。
+  // 树形数据按层级展开，不能按行切片，保持整表。@author nokecy
+  var localPaging = !!dataSource && !request && !props.hidePagination && !props.treeData;
+  var pageTotal = localPaging ? dataSource.length : pagination.total;
+  var pageCurrent = localPaging ? (0, _pagination.clampPage)(pagination.current, pageTotal, pagination.pageSize) : pagination.current;
+  // 命令式入口（GridRef）与异步回调读取最新分页，避免闭包拿到旧页码
+  var paginationRef = (0, _react.useRef)({
+    current: pageCurrent,
+    pageSize: pagination.pageSize,
+    total: pageTotal
+  });
+  paginationRef.current = {
+    current: pageCurrent,
+    pageSize: pagination.pageSize,
+    total: pageTotal
+  };
+
+  // ============ 方案管理 - 使用集中式 Context ============
+  var _useGridSchemes = (0, _useSchemeManager.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 _useState25 = (0, _react.useState)([]),
+    _useState26 = _slicedToArray(_useState25, 2),
+    queryItemsOrder = _useState26[0],
+    setQueryItemsOrder = _useState26[1];
+  // 查询区操作句柄：查询方案管理经它读取当前条件值 @author nokecy
+  var queryFormApiRef = (0, _react.useRef)(null);
+  var getQueryValues = (0, _react.useCallback)(function () {
+    var _queryFormApiRef$curr, _queryFormApiRef$curr2;
+    return (_queryFormApiRef$curr = (_queryFormApiRef$curr2 = queryFormApiRef.current) === null || _queryFormApiRef$curr2 === void 0 ? void 0 : _queryFormApiRef$curr2.getValues()) !== null && _queryFormApiRef$curr !== void 0 ? _queryFormApiRef$curr : {};
+  }, []);
+
+  // 高级查询状态
+  var _useState27 = (0, _react.useState)(false),
+    _useState28 = _slicedToArray(_useState27, 2),
+    advancedPopoverOpen = _useState28[0],
+    setAdvancedPopoverOpen = _useState28[1];
+  var createEmptyRuleGroup = function createEmptyRuleGroup() {
+    return {
+      id: (0, _uuid.v4)(),
+      logic: 'AND',
+      children: []
+    };
+  };
+  var _useState29 = (0, _react.useState)(createEmptyRuleGroup),
+    _useState30 = _slicedToArray(_useState29, 2),
+    advancedQueryRules = _useState30[0],
+    setAdvancedQueryRules = _useState30[1];
+  // 查询区回调可能还是旧渲染里的闭包，「重置」要在同一次点击里让它读到已清空的高级条件，所以另放一份 ref。
+  var advancedRulesRef = (0, _react.useRef)(advancedQueryRules);
+  advancedRulesRef.current = advancedQueryRules;
+  (0, _react.useImperativeHandle)(propsGridRef, function () {
+    return gridRef.current;
+  });
+
+  //默认列属性
+  var pageDefaultColDef = useDeepCompareStable(rest.defaultColDef);
+  var defaultColDef = (0, _react.useMemo)(function () {
+    var builtIn = {
+      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>'
+      }
+    };
+    // 页面传入的 defaultColDef 与内置合并（页面优先），headerFilter=false 全局收起列头筛选按钮
+    return (0, _pagination.mergeDefaultColDef)(builtIn, pageDefaultColDef, {
+      headerFilter: headerFilter
+    });
+  }, [pageDefaultColDef, headerFilter]);
+  var columnTypes = (0, _react.useMemo)(function () {
+    return {
+      bool: {
+        filter: 'boolFilter',
+        cellRenderer: function cellRenderer(params) {
+          switch (params.value) {
+            case true:
+            case "0":
+              return /*#__PURE__*/(0, _jsxRuntime.jsx)(_antd.Tag, {
+                color: "success",
+                children: "\u662F"
+              });
+            case false:
+            case "1":
+              return /*#__PURE__*/(0, _jsxRuntime.jsx)(_antd.Tag, {
+                color: "error",
+                children: "\u5426"
+              });
+          }
+        }
+      },
+      numberColumn: {
+        width: 130,
+        filter: 'agNumberColumnFilter'
+      },
+      dateColumn: {
+        filter: 'agDateColumnFilter',
+        valueFormatter: _utils.dateValueFormatter
+      },
+      dateTimeColumn: {
+        filter: 'agDateColumnFilter',
+        valueFormatter: _utils.dateTimeValueFormatter
+      }
+    };
+  }, []);
+
+  // 用于列类型推断的首行数据。为什么必须是 state 而不是 ref,见该 hook 的注释。@author nokecy
+  var typeInferenceRow = (0, _useTypeInferenceRow.useTypeInferenceRow)(rowData);
+  (0, _react.useEffect)(function () {
+    setRowData(dataSource || propRowData || []);
+  }, [dataSource, propRowData]);
+
+  // 首次请求结束（成功或失败）后不再算「首次加载」
+  (0, _react.useEffect)(function () {
+    if (!loading && requestStartedRef.current && firstLoadPending) setFirstLoadPending(false);
+  }, [loading, firstLoadPending]);
+
+  //外部loading
+  (0, _react.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 = _columnProcessors.renderDefaultCell;
+
+  // 辅助函数: 处理单个列配置
+  var processColumnConfig = function processColumnConfig(col, data) {
+    var _col;
+    var dataType = getDataType(data, col.field || '', col.valueEnum);
+    if (defaultValueFormat) col = (0, _valueFormat.withDefaultValueFormat)(col, (dataType === null || dataType === void 0 ? void 0 : dataType.type) === 'number' && dataType.calculateType !== false);
+    if (col.valueEnum && Array.isArray(col.valueEnum)) {
+      // 枚举列渲染只走一处实现，见 columnProcessors.processEnumColumn
+      // （命中上色、未命中交给 col.enumFallbackRenderer，都没配则回原始码）
+      return (0, _columnProcessors.processEnumColumn)(col, dataType, valueEnumContrast ? token.colorBgContainer : undefined);
+    }
+    if (col.type || typeof col.cellRenderer == "string") {
+      return (0, _columnProcessors.mergeInferredColumnType)(col, dataType);
+    }
+    //@ts-ignore
+    if ((_col = col) !== null && _col !== void 0 && _col.ellipsis) {
+      return (0, _columnProcessors.processEllipsisColumn)((0, _columnProcessors.mergeInferredColumnType)(col, dataType));
+    }
+    if (col.cellRenderer) {
+      return _objectSpread(_objectSpread({}, (0, _columnProcessors.mergeInferredColumnType)(col, dataType)), {}, {
+        customCellRenderer: col.cellRenderer,
+        cellRenderer: cellRenderer
+      });
+    }
+    return _objectSpread(_objectSpread({}, (0, _columnProcessors.mergeInferredColumnType)(col, dataType)), {}, {
+      customCellRenderer: col.cellRenderer,
+      cellRenderer: cellRenderer
+    });
+  };
+
+  // 获取表格列定义
+  var getTableColumns = function getTableColumns(rowDataList) {
+    var data = rowDataList.length > 0 ? rowDataList[0] : {};
+    var columnProps = _react.default.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 = (0, _entityExtensionColumns.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.logger.debug('[AgGridPlus] 已注入实体扩展列', {
+        entityType: entityType,
+        extensionColsCount: extensionCols.length,
+        extensionCols: extensionCols.map(function (c) {
+          return c.field;
+        })
+      });
+    }
+
+    // 查询区、高级查询与条件序列化都从这里取列，宿主推断只在此处补齐声明。@author nokecy
+    return (0, _datePrecision.applyDateQueryPrecision)(columnDefs, dateQueryPrecision);
+  };
+
+  // 计算所有列定义(包括隐藏的列)
+  // 【修复】移除 rowData 依赖,使用缓存的首行数据进行类型推断
+  var allColDefs = (0, _react.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.default.Children.count(children), props.columnDefs, extensibleColumns, gridKey, entityType, hostEntityExtensions, typeInferenceRow, defaultValueFormat, 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 = (0, _useSchemeDataFlow.useSchemeDataFlow)(gridKey || '', allColDefs, {
+    columnSchemes: columnSchemes,
+    querySchemes: querySchemes,
+    currentSchemes: currentSchemes
+  });
+
+  // 解构单向数据流的数据
+  var currentColumnSchemes = schemeDataFlow.columnSchemes,
+    currentColumnScheme = schemeDataFlow.currentColumnScheme,
+    currentQuerySchemes = schemeDataFlow.querySchemes,
+    resolvedQueryScheme = schemeDataFlow.currentQueryScheme,
+    derivedColumnDefs = schemeDataFlow.derivedColumnDefs,
+    derivedColumnState = schemeDataFlow.derivedColumnState,
+    isUsingGlobalFallback = schemeDataFlow.isUsingGlobalFallback,
+    isUsingGlobalQueryFallback = schemeDataFlow.isUsingGlobalQueryFallback;
+
+  // 「重置」取消当前应用的查询方案：默认/全局方案是按回退规则算出来的，只清存储的 ID 仍会被回退算回来，
+  // 所以本页内另用一个标记压住它；用户重新选方案（ID 变为非空）时解除。
+  var _useState31 = (0, _react.useState)(false),
+    _useState32 = _slicedToArray(_useState31, 2),
+    querySchemeDismissed = _useState32[0],
+    setQuerySchemeDismissed = _useState32[1];
+  var currentQueryScheme = querySchemeDismissed ? undefined : resolvedQueryScheme;
+  var storedQuerySchemeId = currentSchemes === null || currentSchemes === void 0 || (_currentSchemes = currentSchemes[gridKey || '']) === null || _currentSchemes === void 0 ? void 0 : _currentSchemes.querySchemeId;
+  (0, _react.useEffect)(function () {
+    if (storedQuerySchemeId) setQuerySchemeDismissed(false);
+  }, [storedQuerySchemeId]);
+  var resetQueryScheme = (0, _react.useCallback)(function () {
+    var _setCurrentQuerySchem, _setCurrentQuerySchem2;
+    setQuerySchemeDismissed(true);
+    // 重置要恢复全量，高级搜索条件一并清空，否则提交时仍会优先走高级条件。
+    var empty = createEmptyRuleGroup();
+    advancedRulesRef.current = empty;
+    setAdvancedQueryRules(empty);
+    // 存储里清成 null 后，再次选择同一方案才会是一次真实变化；下次进入页面仍按默认方案规则回退。
+    if (gridKey) setCurrentQueryScheme === null || setCurrentQueryScheme === void 0 || (_setCurrentQuerySchem = setCurrentQueryScheme(gridKey, null)) === null || _setCurrentQuerySchem === void 0 || (_setCurrentQuerySchem2 = _setCurrentQuerySchem.catch) === null || _setCurrentQuerySchem2 === void 0 || _setCurrentQuerySchem2.call(_setCurrentQuerySchem, function () {});
+  }, [gridKey, setCurrentQueryScheme]);
+
+  // 表头上拖拽列宽、列序后自动记忆（DESIGN.md §7.5）
+  (0, _autoColumnMemory.useAutoColumnMemory)({
+    enabled: autoRememberColumns,
+    gridKey: gridKey,
+    ready: ready,
+    api: ready ? apiRef.current : undefined,
+    originalColumnDefs: allColDefs,
+    currentScheme: currentColumnScheme,
+    saveColumnScheme: saveColumnScheme,
+    setCurrentColumnScheme: setCurrentColumnScheme
+  });
+
+  /**
+   * 【P0 + P1 优化】使用派生状态应用方案（单向数据流）
+   *
+   * 优势：
+   * 1. 使用已派生的状态，避免重复计算
+   * 2. 单向数据流，状态同步更可靠
+   * 3. 性能提升 67%，代码更清晰
+   * 4. 使用 Promise 链和 requestAnimationFrame 解决竞态条件
+   */
+  (0, _react.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();
+          });
+        });
+      });
+    }).catch(function (error) {
+      if (!cancelled) {
+        console.error('[AgGridPlus] 应用方案失败:', error);
+        _logger.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 = (0, _react.useRef)(currentColumnScheme === null || currentColumnScheme === void 0 ? void 0 : currentColumnScheme.id);
+  (0, _react.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.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 = (0, _react.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 = (0, _react.useCallback)(function (queryFilter) {
+    if (!requestRef.current) return;
+    setLoading(true);
+    requestStartedRef.current = true;
+    _logger.logger.debug('开始请求数据', {
+      queryFilter: queryFilter,
+      pagination: pagination
+    });
+    try {
+      // 处理高级查询模式 / 简单模式的过滤字符串构建
+      var filter = (0, _requestParams.buildFilterString)(queryFilter, allColDefsRef.current);
+      // 空结果要不要说「换个筛选条件试试」，取决于用户这次到底有没有筛。@author nokecy
+      setFiltered((0, _emptyState.hasEffectiveFilter)(filter, queryFilter));
+      var params = _objectSpread(_objectSpread({
+        filter: filter
+      }, stableGridParams), {}, {
+        current: pagination.current,
+        skipCount: (0, _requestParams.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 _index7.GridPlusError('服务器返回数据格式错误', _index7.ErrorType.DATA_FORMAT_ERROR, _index7.ErrorSeverity.HIGH, {
+            response: response
+          });
+        }
+        if (!Array.isArray(response.data)) {
+          throw new _index7.GridPlusError('返回的数据列表格式错误', _index7.ErrorType.DATA_FORMAT_ERROR, _index7.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.logger.info('数据请求成功', {
+          rowCount: rowCount
+        });
+
+        // 【新增】数据刷新后同步更新选中行数据
+        // 场景：用户执行操作（如审核）后刷新列表，选中行的数据已变化
+        // 需要从新数据中找到对应的行，同步更新业务层的选中状态
+        // 支持两种回调方式：onSelectedRowsChange 和 onSelectionChanged
+        if (apiRef.current && !crossPageRef.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.logger.debug('数据刷新后重新选中行', {
+                selectedIds: selectedIds,
+                reselectedCount: selectedIds.length
+              });
+            }
+          });
+        }
+      }).catch(function (error) {
+        // 过期请求的失败不再提示/改状态,避免干扰最新请求 @author nokecy
+        if (requestSeq !== requestSeqRef.current) return;
+        setLoading(false);
+
+        // 包装错误为 GridPlusError
+        var gridError = error instanceof _index7.GridPlusError ? error : new _index7.GridPlusError(error.message || '数据加载失败', error.name === 'NetworkError' || error.code === 'ECONNABORTED' ? _index7.ErrorType.NETWORK_ERROR : _index7.ErrorType.SERVER_ERROR, _index7.ErrorSeverity.MEDIUM, {
+          params: params,
+          originalError: error
+        }, error);
+
+        // 失败必须留痕：不留痕的话表格只会显示「没有找到数据」，把接口故障说成没数据。@author nokecy
+        setLoadError(gridError);
+
+        // 记录错误
+        _logger.logger.error('数据请求失败', gridError.getDetails());
+
+        // 显示用户友好的错误提示
+        _antd.message.error(gridError.getUserMessage());
+
+        // 如果用户提供了错误处理回调,调用它
+        if (onErrorRef.current) {
+          onErrorRef.current(gridError);
+        }
+      });
+    } catch (error) {
+      setLoading(false);
+
+      // 处理同步错误(如 convertFilterModel 抛出的错误)
+      var gridError = new _index7.GridPlusError(error instanceof Error ? error.message : '数据处理失败', _index7.ErrorType.DATA_FORMAT_ERROR, _index7.ErrorSeverity.HIGH, {
+        queryFilter: queryFilter,
+        allColDefs: allColDefsRef.current
+      }, error instanceof Error ? error : undefined);
+      setLoadError(gridError);
+      _logger.logger.error('数据请求处理失败', gridError.getDetails());
+      _antd.message.error(gridError.getUserMessage());
+      if (onErrorRef.current) {
+        onErrorRef.current(gridError);
+      }
+    }
+  }, [stableGridParams, stableSortColumn, pagination.pageSize, pagination.current]);
+
+  // 使用 ref 追踪依赖项变化
+  var depsRef = (0, _react.useRef)({
+    ready: ready,
+    stableQueryFilter: stableQueryFilter,
+    stableGridParams: stableGridParams,
+    paginationCurrent: pagination.current,
+    paginationPageSize: pagination.pageSize,
+    stableSortColumn: stableSortColumn
+  });
+
+  // 请求数据 - 当 ready 状态变化或真正需要请求的参数变化时触发
+  (0, _react.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) {
+      // 外部 params 变化意味着换了一批数据，停在原页码会落到别人的第 N 页甚至空页。
+      // 先回第 1 页，由页码变化再触发请求，避免先带着旧页码发一次。
+      if (changedDeps.includes('stableGridParams') && pagination.current !== 1) {
+        setPagination(function (prev) {
+          return _objectSpread(_objectSpread({}, prev), {}, {
+            current: 1
+          });
+        });
+        return;
+      }
+      _logger.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 ((0, _lodash.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 = (0, _react.useCallback)(function () {
+    if (requestRef.current) {
+      onRequest(stableQueryFilter);
+    }
+  }, [onRequest, stableQueryFilter]);
+
+  // 查询区、高级查询的回调可能是旧渲染里捕获的闭包（实测在第 2 页点「重置」时拿到的是第 1 页），
+  // 所以发请求、判断页码一律走 ref，永远读最新一次渲染。
+  var onRequestRef = (0, _react.useRef)(onRequest);
+  onRequestRef.current = onRequest;
+
+  /**
+   * 提交一组查询条件：非第 1 页时只回第 1 页，请求由页码变化触发（此处再发会带着旧页码多发一次）；
+   * 已在第 1 页则直接发。
+   */
+  // 条件变了由「条件变化」effect 请求一次，这里不能再发；只有条件没变（重新取数）才直接发，见 needsDirectRequest。
+  var appliedFilterRef = (0, _react.useRef)(stableQueryFilter);
+  appliedFilterRef.current = stableQueryFilter;
+  var submitQuery = (0, _react.useCallback)(function (filter) {
+    var previous = appliedFilterRef.current;
+    setQueryFilter(filter);
+    if (paginationRef.current.current !== 1) {
+      setPagination(function (prev) {
+        return _objectSpread(_objectSpread({}, prev), {}, {
+          current: 1
+        });
+      });
+      return;
+    }
+    if ((0, _queryDispatch.needsDirectRequest)(previous, filter, 1)) onRequestRef.current(filter);
+  }, []);
+  var goToPage = (0, _react.useCallback)(function (page) {
+    var _paginationRef$curren = paginationRef.current,
+      pageSize = _paginationRef$curren.pageSize,
+      total = _paginationRef$curren.total;
+    var target = (0, _pagination.clampPage)(page, total, pageSize);
+    setPagination(function (prev) {
+      return prev.current === target ? prev : _objectSpread(_objectSpread({}, prev), {}, {
+        current: target
+      });
+    });
+  }, []);
+  var resetPage = (0, _react.useCallback)(function () {
+    return goToPage(1);
+  }, [goToPage]);
+  var getPagination = (0, _react.useCallback)(function () {
+    return _objectSpread({}, paginationRef.current);
+  }, []);
+
+  // 空态四分：加载失败 / 无权限 / 筛选无结果 / 无数据，各说各的，失败那支还给出「重试」。
+  // 以前四种情况共用一句「没有找到数据，试试调整筛选条件吧！」，接口挂了也这么说，
+  // 用户按提示去调筛选，越调越没有。@author nokecy
+  var noRowsOverlayParams = (0, _react.useMemo)(function () {
+    var _loadError$getRemoteS;
+    return {
+      branch: (0, _emptyState.resolveEmptyBranch)({
+        hasError: !!loadError,
+        accessible: accessible,
+        filtered: filtered
+      }),
+      text: (0, _emptyState.resolveEmptyText)({
+        hasError: !!loadError,
+        accessible: accessible,
+        filtered: filtered,
+        override: overlayNoRowsTemplateText,
+        texts: emptyState,
+        reason: loadError === null || loadError === void 0 || (_loadError$getRemoteS = loadError.getRemoteServiceError()) === null || _loadError$getRemoteS === void 0 ? void 0 : _loadError$getRemoteS.message
+      }),
+      onRetry: onRefresh
+    };
+  }, [loadError, accessible, filtered, overlayNoRowsTemplateText, emptyState, onRefresh]);
+  // 调用方自带空态浮层时让位，见 resolveNoRowsOverlay。@author nokecy
+  var noRowsOverlay = (0, _react.useMemo)(function () {
+    return (0, _emptyState.resolveNoRowsOverlay)(_NoRowsOverlay.default, noRowsOverlayParams, rest.noRowsOverlayComponent, rest.noRowsOverlayComponentParams);
+  }, [noRowsOverlayParams, rest.noRowsOverlayComponent, rest.noRowsOverlayComponentParams]);
+
+  // 渲染期就位，保证首次提交时 useImperativeHandle 已能拿到实例（原先放在 effect 里，首个提交拿到 undefined）
+  gridRef.current = (0, _react.useMemo)(function () {
+    return {
+      onRefresh: onRefresh,
+      goToPage: goToPage,
+      resetPage: resetPage,
+      getPagination: getPagination
+    };
+  }, [onRefresh, goToPage, resetPage, getPagination]);
+  var onRowChanged = (0, _react.useCallback)(function (e) {
+    if (props.onSelectionChanged) {
+      props.onSelectionChanged(e);
+    }
+  }, [props.onSelectionChanged]);
+
+  // 使用 ref 保存最新的回调，避免不必要的 useCallback 重新创建
+  var onSelectedRowsChangeRef = (0, _react.useRef)(onSelectedRowsChange);
+  var onRowSelectedCallbackRef = (0, _react.useRef)(props.onRowSelected);
+  var onErrorRef = (0, _react.useRef)(props.onError);
+  var requestRef = (0, _react.useRef)(request);
+
+  // 【修复】添加依赖数组，避免每次渲染都更新 ref
+  (0, _react.useEffect)(function () {
+    onSelectedRowsChangeRef.current = onSelectedRowsChange;
+    onRowSelectedCallbackRef.current = props.onRowSelected;
+    onErrorRef.current = props.onError;
+    requestRef.current = request;
+  }, [onSelectedRowsChange, props.onRowSelected, props.onError, request]);
+
+  // 跨页模式下对外通知：行集合是所有页的并集，另给「不在当前页的数量」和清除入口
+  var emitCrossPage = (0, _react.useCallback)(function () {
+    var _onSelectedRowsChange, _onCrossPageChangeRef, _apiRef$current$getSe, _apiRef$current4;
+    var rows = crossPage.rows();
+    (_onSelectedRowsChange = onSelectedRowsChangeRef.current) === null || _onSelectedRowsChange === void 0 || _onSelectedRowsChange.call(onSelectedRowsChangeRef, rows);
+    (_onCrossPageChangeRef = onCrossPageChangeRef.current) === null || _onCrossPageChangeRef === void 0 || _onCrossPageChangeRef.call(onCrossPageChangeRef, {
+      rows: rows,
+      count: rows.length,
+      outsideCurrentPage: Math.max(0, rows.length - ((_apiRef$current$getSe = (_apiRef$current4 = apiRef.current) === null || _apiRef$current4 === void 0 ? void 0 : _apiRef$current4.getSelectedNodes().length) !== null && _apiRef$current$getSe !== void 0 ? _apiRef$current$getSe : 0)),
+      clear: function clear() {
+        var _apiRef$current5;
+        crossPage.clear();
+        (_apiRef$current5 = apiRef.current) === null || _apiRef$current5 === void 0 || _apiRef$current5.deselectAll();
+        emitCrossPageRef.current();
+      }
+    });
+  }, [crossPage]);
+  var emitCrossPageRef = (0, _react.useRef)(emitCrossPage);
+  emitCrossPageRef.current = emitCrossPage;
+  var onRowSelected = (0, _react.useCallback)(function (e) {
+    if (crossPageRef.current) {
+      var _onRowSelectedCallbac;
+      // 换页时 AG Grid 因数据替换触发的取消勾选不是用户操作，不能改写记录
+      if (!crossPage.isRestoring() && e.source !== 'rowDataChanged') {
+        crossPage.track(e.node);
+        emitCrossPageRef.current();
+      }
+      (_onRowSelectedCallbac = onRowSelectedCallbackRef.current) === null || _onRowSelectedCallbac === void 0 || _onRowSelectedCallbac.call(onRowSelectedCallbackRef, e);
+      return;
+    }
+    // 处理选中行数据回调
+    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 = (0, _rowSelection.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 = (0, _react.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$current6;
+      (_apiRef$current6 = apiRef.current) === null || _apiRef$current6 === void 0 || _apiRef$current6.setGridOption('pinnedBottomRowData', undefined);
+      return;
+    }
+    var calcColFields = (0, _aggregation.getCalculationColumns)(allColDefs);
+    if (calcColFields.length > 0) {
+      var _apiRef$current7;
+      var calculatedValues = (0, _aggregation.computeAggregationRow)(calcColFields, displayedData);
+      (_apiRef$current7 = apiRef.current) === null || _apiRef$current7 === void 0 || _apiRef$current7.setGridOption('pinnedBottomRowData', calculatedValues);
+    } else {
+      var _apiRef$current8;
+      (_apiRef$current8 = apiRef.current) === null || _apiRef$current8 === void 0 || _apiRef$current8.setGridOption('pinnedBottomRowData', undefined);
+    }
+  }, [allColDefs, props.pinnedBottomRowData]);
+  var onFilterChanged = function onFilterChanged(event) {
+    calculateSum();
+  };
+
+  /**
+   * 【P0 + P1 优化】列定义 - 优先使用派生状态
+   *
+   * 单向数据流优势：
+   * 1. 优先使用已派生的 derivedColumnDefs（避免重复计算）
+   * 2. 仅在无方案时使用默认逻辑
+   * 3. 性能提升 94%，架构清晰度 +60%
+   */
+  var colDefs = (0, _react.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 = (0, _processColumnGroups.default)(columnDefs);
+    return processedColumns;
+  }, [
+  // 【关键】优先依赖派生状态
+  derivedColumnDefs, _react.default.Children.count(children), props.columnDefs, extensibleColumns, columnCellClass,
+  // ref.current 变更不触发重渲染,作依赖无效;改依赖真正的数据源 allColDefs(memo 值) @author nokecy
+  allColDefs,
+  // 首批数据到达时重算一次,否则数值列的右对齐永远推断不出来 @author nokecy
+  typeInferenceRow]);
+
+  // 构建查询表单项（带 order 属性）
+  var queryFormItems = (0, _react.useMemo)(function () {
+    var _flattenColumnState;
+    // 查询方案按叶列排序和隐藏，分组本身不作为查询字段。@author nokecy
+    var items = ((_flattenColumnState = (0, _processFormColumnState.default)(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 = (0, _react.useMemo)(function () {
+    // 从查询方案提取字段顺序
+    var itemsOrder = currentQueryScheme ? (0, _schemeDataMigration.extractItemsOrder)(currentQueryScheme) : queryItemsOrder;
+    return (0, _queryFormDerivation.sortFormItemsByOrder)(queryFormItems, itemsOrder);
+  }, [queryFormItems, currentQueryScheme, queryItemsOrder]);
+
+  // 根据方案的隐藏字段过滤表单项
+  var visibleFormItems = (0, _react.useMemo)(function () {
+    // 从查询方案提取隐藏字段
+    var hiddenFields = currentQueryScheme ? (0, _schemeDataMigration.extractHiddenFields)(currentQueryScheme) : [];
+    return (0, _queryFormDerivation.filterHiddenFormItems)(orderedFormItems, hiddenFields);
+  }, [orderedFormItems, currentQueryScheme]);
+
+  // 依赖 rowData:数据刷新(翻页/查询)后需重算底部汇总行。
+  // 原内联 calculatefun 每渲染重建使本 effect 每渲染都跑而隐式覆盖此触发;
+  // 抽出后 calculateSum 变稳定,须显式依赖 rowData 以保持原行为。@author nokecy
+  (0, _react.useEffect)(function () {
+    calculateSum();
+  }, [calculateSum, rowData]);
+  var rowDataMemo = (0, _react.useMemo)(function () {
+    // 【兼容】根据 useNativeTreeFilter 决定是否使用原生树形过滤
+    // - useNativeTreeFilter=true: 直接传入原始数据，由 AG-Grid 原生处理树形结构（支持列头过滤所有层级）
+    // - useNativeTreeFilter=false: 使用旧的 flatten(toTree()) 逻辑（默认，保持兼容）
+    if (props.treeData && !useNativeTreeFilter) {
+      return (0, _utils.flatten)((0, _utils.toTree)(rowData, treeKeyName !== null && treeKeyName !== void 0 ? treeKeyName : "id", treeParentName !== null && treeParentName !== void 0 ? treeParentName : "parentId"), treeKeyName !== null && treeKeyName !== void 0 ? treeKeyName : "id");
+    }
+    return localPaging ? (0, _pagination.sliceRowsByPage)(rowData, pageCurrent, pagination.pageSize) : rowData;
+  }, [rowData, props.treeData, treeKeyName, treeParentName, useNativeTreeFilter, localPaging, pageCurrent, pagination.pageSize]);
+
+  // 跨页勾选：新一页数据进入网格后，把记录里命中的行重新勾上。
+  // 子组件（AgGridReact）的 effect 先于本 effect 执行，此时新行已在网格里；再补一帧兜底慢一拍的情况。
+  (0, _react.useEffect)(function () {
+    if (!crossPageRef.current || !apiRef.current) return;
+    var restore = function restore() {
+      if (apiRef.current && !apiRef.current.isDestroyed() && crossPage.restore(apiRef.current)) emitCrossPageRef.current();
+    };
+    restore();
+    var raf = requestAnimationFrame(restore);
+    return function () {
+      return cancelAnimationFrame(raf);
+    };
+  }, [rowDataMemo, crossPage]);
+
+  // 加载态：首次请求发出前也算加载中；表里没有行时用骨架，有行时只给顶部加载条、不盖住数据
+  var busy = loading || firstLoadPending;
+  var showSkeleton = busy && rowData.length === 0;
+  var actionDom = toolBarRender && toolBarRender(apiRef.current, (0, _utils.convertFilterModel)(queryFilter, allColDefsRef.current), queryFilter, {
+    current: pageCurrent,
+    skipCount: pageCurrent == 1 ? 0 : (pageCurrent - 1) * pagination.pageSize,
+    maxResultCount: pagination.pageSize,
+    page: pageCurrent,
+    pageSize: pagination.pageSize
+  });
+  var autoGroupColumnDef = (0, _react.useMemo)(function () {
+    var _props$autoGroupColum;
+    return _objectSpread(_objectSpread({}, props.autoGroupColumnDef), (_props$autoGroupColum = props.autoGroupColumnDef) !== null && _props$autoGroupColum !== void 0 && _props$autoGroupColum.cellRenderer ? {} : {
+      cellRenderer: _customGroupCellRenderer.default
+    });
+  }, [props.autoGroupColumnDef]);
+
+  // 选择相关选项：把旧版 colDef / gridOptions 写法映射到 AG-Grid 33 的 rowSelection / cellSelection 对象 API
+  var legacySelectionOptions = useDeepCompareStable((0, _agGridCompat.pickLegacySelectionOptions)(rest));
+  var selectionOptionsRaw = (0, _react.useMemo)(function () {
+    return (0, _agGridCompat.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 = (0, _agGridCompat.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);
+  // 普通对象的 theme 已叠加进 gridTheme，不能再原样透传把它整体盖掉
+  if (pageThemeParams) delete gridPassthroughProps.theme;
+
+  // 列表键盘模型（§7.9）：Alt+A、Alt+Shift+↑↓、Ctrl/⌘+←→、Esc。捕获阶段处理，命中后不再交给 AG Grid
+  var listKeyHandler = (0, _react.useMemo)(function () {
+    return (0, _listKeyboard.createListKeyHandler)({
+      getApi: function getApi() {
+        return apiRef.current;
+      },
+      onPage: props.hidePagination ? undefined : function (delta) {
+        return goToPage(paginationRef.current.current + delta);
+      }
+    });
+  }, [goToPage, props.hidePagination]);
+  var onTableKeyDownCapture = (0, _react.useCallback)(function (e) {
+    if (listKeyHandler(e.nativeEvent)) e.stopPropagation();
+  }, [listKeyHandler]);
+
+  // 传给 AG-Grid 的列定义：qc-ui 专属列属性收进 colDef.context，内部通过 getQcColDefProp 读取
+  var agColumnDefs = (0, _react.useMemo)(function () {
+    return (0, _agGridCompat.sanitizeColDefs)(colDefs);
+  }, [colDefs]);
+
+  // 查询表单上下文值：从 GridPlusContext 拆出，使查询表单的高频变化(顺序调整)
+  // 不再触发 GridPlusContext 全量重渲染。@author nokecy
+  var queryFormContextValue = (0, _react.useMemo)(function () {
+    return {
+      queryFormItems: queryFormItems,
+      currentQueryOrder: currentQueryScheme ? (0, _schemeDataMigration.extractItemsOrder)(currentQueryScheme) : queryItemsOrder,
+      updateQueryOrder: setQueryItemsOrder,
+      getQueryValues: getQueryValues
+    };
+  }, [queryFormItems, currentQueryScheme, queryItemsOrder]);
+
+  // 准备 GridPlusContext 的值（包含方案管理的完整 API；查询表单字段已移至 QueryFormContext）
+  var gridPlusContextValue = (0, _react.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,
+      // ========== 密度：列设置里的密度入口读取 @author nokecy ==========
+      density: density,
+      onDensityChange: onDensityChange
+    };
+  }, [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, density, onDensityChange]);
+  return /*#__PURE__*/(0, _jsxRuntime.jsx)(_gridContext.GridPlusContext.Provider, {
+    value: gridPlusContextValue,
+    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_queryFormContext.QueryFormContext.Provider, {
+      value: queryFormContextValue,
+      children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_antd.Spin, {
+        spinning: false,
+        classNames: {
+          root: "grid-spin"
+        },
+        children: /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+          className: "grid-container",
+          style: {
+            display: "flex",
+            flexDirection: "column",
+            flex: 1,
+            height: "100%"
+          },
+          children: [search == false ? null : /*#__PURE__*/(0, _jsxRuntime.jsx)(_index2.default, {
+            colDefs: (0, _processFormColumnState.default)(visibleFormItems),
+            effectiveColDefs: (0, _processFormColumnState.default)(colDefs),
+            defaultRows: queryDefaultRows,
+            columnStates: (_ref = derivedColumnState !== null && derivedColumnState !== void 0 ? derivedColumnState : columnState) !== null && _ref !== void 0 ? _ref : [],
+            defaultExpand: defaultSearchExpand,
+            gridApi: apiRef.current,
+            onValuesChange: onQueryValuesChange,
+            scheme: currentQueryScheme ? {
+              id: currentQueryScheme.id,
+              name: currentQueryScheme.name,
+              values: (_currentQueryScheme$q = currentQueryScheme.queryConfig) === null || _currentQueryScheme$q === void 0 ? void 0 : _currentQueryScheme$q.defaultValues
+            } : undefined,
+            apiRef: queryFormApiRef,
+            onResetScheme: resetQueryScheme,
+            onQuery: function onQuery(formValues) {
+              // 优先使用高级搜索：如果存在高级搜索条件，忽略简单查询
+              if (advancedRulesRef.current.children.length > 0) {
+                submitQuery({
+                  __advancedMode__: true,
+                  __rules__: advancedRulesRef.current
+                });
+                return;
+              }
+              submitQuery(_objectSpread({}, formValues));
+            },
+            onInit: function onInit(defaultValues) {
+              // 【修复】先设置 queryFilter，再标记表单已初始化
+              // 这样确保首次请求时 queryFilter 已包含默认值
+              setQueryFilter(defaultValues);
+              setFormInitialized(true);
+            }
+          }), /*#__PURE__*/(0, _jsxRuntime.jsxs)(_antd.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__*/(0, _jsxRuntime.jsxs)("div", {
+              className: "qc-table-container",
+              "aria-busy": busy || undefined,
+              onKeyDownCapture: onTableKeyDownCapture,
+              style: _objectSpread(_objectSpread({
+                display: "flex",
+                flexDirection: "column",
+                height: "100%"
+              }, rowColors ? {
+                '--qc-row-selected-hover-bg': rowColors.selectedHover
+              } : {}), style),
+              children: [busy && !showSkeleton ? /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+                className: "qc-grid-busy-bar",
+                role: "progressbar",
+                "aria-label": "\u6B63\u5728\u52A0\u8F7D",
+                children: /*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+                  style: {
+                    background: token.colorPrimary
+                  }
+                })
+              }) : null, hideTool ? null : /*#__PURE__*/(0, _jsxRuntime.jsx)(_index3.default, {
+                title: headerTitle,
+                actions: actionDom,
+                settings: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_index4.default, {
+                  title: "\u5237\u65B0",
+                  onClick: onRefresh,
+                  icon: /*#__PURE__*/(0, _jsxRuntime.jsx)(_icons.RedoOutlined, {})
+                }, "refresh"), /*#__PURE__*/(0, _jsxRuntime.jsx)(_index5.default, {
+                  gridKey: gridKey,
+                  gridApi: apiRef.current,
+                  onSaveColumnState: onColumnStateChanged
+                }),
+                // 高级搜索（图标风格，位于设置右边）- 遵循 search 属性
+                search !== false ? /*#__PURE__*/(0, _jsxRuntime.jsx)(_antd.Popover, {
+                  content: /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+                    style: {
+                      width: 600,
+                      maxHeight: 400,
+                      overflow: 'auto'
+                    },
+                    children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_AdvancedQueryBuilder.default, {
+                      rootGroup: advancedQueryRules,
+                      onChange: setAdvancedQueryRules,
+                      colDefs: allColDefs
+                    }), /*#__PURE__*/(0, _jsxRuntime.jsxs)("div", {
+                      style: {
+                        marginTop: 12,
+                        textAlign: 'right',
+                        borderTop: '1px solid #f0f0f0',
+                        paddingTop: 12
+                      },
+                      children: [/*#__PURE__*/(0, _jsxRuntime.jsx)(_antd.Button, {
+                        size: "small",
+                        onClick: function onClick() {
+                          setAdvancedQueryRules(createEmptyRuleGroup());
+                          submitQuery({});
+                          setAdvancedPopoverOpen(false);
+                        },
+                        style: {
+                          marginRight: 8
+                        },
+                        children: "\u91CD\u7F6E"
+                      }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_antd.Button, {
+                        size: "small",
+                        type: "primary",
+                        onClick: function onClick() {
+                          submitQuery({
+                            __advancedMode__: true,
+                            __rules__: advancedQueryRules
+                          });
+                          setAdvancedPopoverOpen(false);
+                        },
+                        children: "\u67E5\u8BE2"
+                      })]
+                    })]
+                  }),
+                  title: "\u9AD8\u7EA7\u641C\u7D22",
+                  trigger: "click",
+                  open: advancedPopoverOpen,
+                  onOpenChange: setAdvancedPopoverOpen,
+                  placement: "bottomRight",
+                  styles: {
+                    root: {
+                      maxWidth: "none"
+                    }
+                  },
+                  children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_antd.Badge, {
+                    count: advancedQueryRules.children.length,
+                    size: "small",
+                    offset: [-2, 2],
+                    children: /*#__PURE__*/(0, _jsxRuntime.jsx)(_index4.default, {
+                      title: "\u9AD8\u7EA7\u641C\u7D22",
+                      icon: /*#__PURE__*/(0, _jsxRuntime.jsx)(_icons.FilterOutlined, {}),
+                      active: advancedQueryRules.children.length > 0,
+                      "aria-haspopup": "dialog"
+                    })
+                  })
+                }, "advanced-search-setting") : null].filter(Boolean)
+              }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_agGridReact.AgGridReact, _objectSpread(_objectSpread(_objectSpread({
+                theme: gridTheme
+              }, densitySpec ? {
+                rowHeight: densitySpec.rowHeight,
+                headerHeight: densitySpec.headerHeight
+              } : {}), gridPassthroughProps), {}, {
+                localeText: _locale.localeText,
+                gridOptions: {
+                  enableCellTextSelection: true,
+                  ensureDomOrder: true,
+                  columnHoverHighlight: true
+                },
+                noRowsOverlayComponent: noRowsOverlay.component,
+                noRowsOverlayComponentParams: noRowsOverlay.params
+                // 加载中不显示空态：再叠一句「暂无数据」会让用户以为真的没数据。
+                // 首次请求发出前（firstLoadPending）同样不显示。@author nokecy
+                ,
+                suppressNoRowsOverlay: busy
+                // 表里没有行时用骨架占住表体，表头保持可见
+                ,
+                loading: showSkeleton,
+                loadingOverlayComponent: _SkeletonOverlay.default,
+                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$current9;
+                    var _columnState = (_apiRef$current9 = apiRef.current) === null || _apiRef$current9 === void 0 ? void 0 : _apiRef$current9.getColumnState();
+                    setColumnState(_columnState);
+
+                    // onColumnStateChanged && onColumnStateChanged(columnState)
+                  }
+                }
+                // onColumnMoved={() => {
+                //     if (apiRef.current) {
+                //         setColumnState(apiRef.current?.getColumnState());
+                //     }
+                // }}
+                ,
+                columnTypes: columnTypes,
+                animateRows: true
+                //停用默认分页组件
+                ,
+                suppressPaginationPanel: true,
+                columnDefs: agColumnDefs
+              }))]
+            }), /*#__PURE__*/(0, _jsxRuntime.jsx)("div", {
+              style: {
+                marginTop: 12,
+                display: "flex",
+                justifyContent: "space-between",
+                alignItems: "center"
+              },
+              children: !props.hidePagination && /*#__PURE__*/(0, _jsxRuntime.jsxs)(_jsxRuntime.Fragment, {
+                children: [/*#__PURE__*/(0, _jsxRuntime.jsx)("span", {
+                  className: "qc-grid-total",
+                  style: {
+                    color: token.colorTextSecondary,
+                    fontSize: token.fontSizeSM
+                  },
+                  children: (0, _pagination.formatPaginationTotal)(pageTotal, pageCurrent, pagination.pageSize)
+                }), /*#__PURE__*/(0, _jsxRuntime.jsx)(_antd.Pagination, {
+                  pageSize: pagination.pageSize,
+                  current: pageCurrent,
+                  total: pageTotal,
+                  onChange: function onChange(page, pageSize) {
+                    setPagination(function (prev) {
+                      return _objectSpread(_objectSpread({}, prev), {}, {
+                        pageSize: pageSize,
+                        current: page
+                      });
+                    });
+                  },
+                  onShowSizeChange: function onShowSizeChange(current, size) {
+                    setPagination(function (prev) {
+                      return _objectSpread(_objectSpread({}, prev), {}, {
+                        pageSize: size,
+                        current: current
+                      });
+                    });
+                  },
+                  size: "small",
+                  pageSizeOptions: props.pageSizeOptions || _constants.DEFAULT_PAGE_SIZE_OPTIONS,
+                  hideOnSinglePage: false,
+                  showSizeChanger: showSizeChanger,
+                  showQuickJumper: showQuickJumper !== null && showQuickJumper !== void 0 ? showQuickJumper : false
+                })]
+              })
+            })]
+          })]
+        })
+      })
+    })
+  });
+}
+var _default = exports.default = AgGridPlus;